#!/bin/bash
#
# .---.                  .              .
# |                      |              |
# |--- .--. .-.  .-.  .-.|  .-. .--.--. |.-.  .-. .--.  .-.
# |    |   (.-' (.-' (   | (   )|  |  | |   )(   )|  | (.-'
# '    '     --'  --'  -' -  -' '  '   -' -'   -' '   -  --'
#
#                    Freedom in the Cloud
#
# Functions for selecting which apps to install or remove
#
# License
# =======
#
# Copyright (C) 2015-2016 Bob Mottram <bob@freedombone.net>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# Array containing names of available apps
APPS_AVAILABLE=()

# Array containing 1 or 0 indicating installed apps
APPS_INSTALLED=()

# Apps selected with checklist
APPS_CHOSEN=()

# A list of the names of installed apps
APPS_INSTALLED_NAMES=()

# file containing a list of removed apps
REMOVED_APPS_FILE=/root/removed

INSTALLED_APPS_LIST=/usr/share/${PROJECT_NAME}/installed.txt

# keep a list of which users have been added to which apps
# so that when a new app is added existing users can be added
APP_USERS_FILE=$HOME/app_users.txt

if [ ! $COMPLETION_FILE ]; then
    COMPLETION_FILE=$HOME/${PROJECT_NAME}-completed.txt
fi

# Loads variables defined at the beginning of an app script
function app_load_variables {
    app_name=$1

    config_var_name=${app_name}_variables
    if [ ! ${!config_var_name} ]; then
        echo $"${app_name}_variables was not found"
        return
    fi

    configvarname=$config_var_name[@]
    configvarname=( ${!configvarname} )
    for v in "${configvarname[@]}"
    do
        read_config_param $v
    done
}

# Saves variables for a given app script
function app_save_variables {
    app_name=$1

    config_var_name=${app_name}_variables
    if [ ! ${!config_var_name} ]; then
        return
    fi

    configvarname=$config_var_name[@]
    configvarname=( ${!configvarname} )
    for v in "${configvarname[@]}"
    do
        write_config_param $v "${!v}"
    done
}

# gets the variants list from an app script
function app_variants {
    filename=$1
    variants_line=$(cat ${filename} | grep 'VARIANTS=')
    if [[ "$variants_line" == *"'"* ]]; then
        variants_list=$(echo "$variants_line" | awk -F '=' '{print $2}' | awk -F "'" '{print $2}')
    else
        variants_list=$(echo "$variants_line" | awk -F '=' '{print $2}' | awk -F '"' '{print $2}')
    fi
    echo "$variants_list"
}

# whether a given item is in an array
function item_in_array {
    local e
    for e in "${@:2}"; do [[ "$e" == "$1" ]] && return 0; done
    return 1
}

# returns a list of available system variants
# based upon the variants string in each app script
function available_system_variants {
    function_check item_in_array

    FILES=/usr/share/${PROJECT_NAME}/apps/${PROJECT_NAME}-app-*

    new_available_variants_list=()
    for filename in $FILES
    do
        system_variants_list=$(app_variants $filename)
        variants_array=($system_variants_list)
        for variant_str in "${variants_array[@]}"
        do
            item_in_array "${variant_str}" "${new_available_variants_list[@]}"
            if [[ $? != 0 ]]; then
                new_available_variants_list+=("$variant_str")
            fi
        done
    done
    available_variants_list=($(sort <<<"${new_available_variants_list[*]}"))
}

function is_valid_variant {
    sys_type="$1"
    available_variants_list=()

    function_check available_system_variants
    available_system_variants

    for variant_str in "${available_variants_list[@]}"
    do
        if [[ "$sys_type" == "$variant_str" ]]; then
            return "1"
        fi
    done
    return "0"
}

function show_available_variants {
    available_variants_list=()

    function_check available_system_variants
    available_system_variants

    for variant_str in "${available_variants_list[@]}"
    do
        echo "  $variant_str"
    done
}

# mark a given app as having been removed so that it doesn't get reinstalled on updates
function remove_app {
    app_name=$1
    if [ ! -f $REMOVED_APPS_FILE ]; then
        touch $REMOVED_APPS_FILE
    fi
    if ! grep -Fxq "_${app_name}_" $REMOVED_APPS_FILE; then
        echo "_${app_name}_" >> $REMOVED_APPS_FILE
    fi
    if grep -Fxq "install_${app_name}" $COMPLETION_FILE; then
        sed -i "/install_${app_name}/d" $COMPLETION_FILE
    fi
    if grep -Fxq "install_${app_name}" $INSTALLED_APPS_LIST; then
        sed -i "/install_${app_name}/d" $INSTALLED_APPS_LIST
    fi
}

# returns 1 if an app has been marked as removed
function app_is_removed {
    app_name="$1"
    if [ ! -f $REMOVED_APPS_FILE ]; then
        echo "0"
        return
    fi

    if ! grep -Fxq "_${app_name}_" $REMOVED_APPS_FILE; then
        echo "0"
    else
        echo "1"
    fi
}

# Allows an app to be reinstalled even if it was previously marked as being removed
function reinstall_app {
    app_name=$1
    if [ ! -f $REMOVED_APPS_FILE ]; then
        return
    fi
    if [[ $(app_is_removed $app_name) == "1" ]]; then
        sed -i "/_${app_name}_/d" $REMOVED_APPS_FILE
    fi
}

# returns 1 if an app is installed
function app_is_installed {
    app_name="$1"

    # Why does this secondary file exist, apart from COMPLETION_FILE ?
    # It's so that it is visible to unprivileged users from the user control panel
    if [ -f $INSTALLED_APPS_LIST ]; then
        if ! grep -Fxq "install_${app_name}" $INSTALLED_APPS_LIST; then
            echo "0"
        else
            echo "1"
        fi
        return
    fi

    # check the completion file to see if it was installed
    if [ ! -f $COMPLETION_FILE ]; then
        echo "0"
        return
    fi

    if ! grep -Fxq "install_${app_name}" $COMPLETION_FILE; then
        echo "0"
    else
        echo "1"
    fi
}

# called at the end of the install section of an app script
function install_completed {
    if [ ! ${1} ]; then
        exit 673935
    fi
    if ! grep -Fxq "install_${1}" $COMPLETION_FILE; then
        echo "install_${1}" >> $COMPLETION_FILE
    fi
}

# populates an array of "0" or "1" for whether apps are installed
function get_apps_installed {
    for a in "${APPS_AVAILABLE[@]}"
    do
        APPS_INSTALLED+=("$(app_is_installed $a)")
    done
}

# populates an array of installed app names
function get_apps_installed_names {
    APPS_INSTALLED_NAMES=()
    for a in "${APPS_AVAILABLE[@]}"
    do
        if [[ $(app_is_installed $a) == "1" ]]; then
            APPS_INSTALLED_NAMES+=("$a")
        fi
    done
}

# detects what apps are available
function detect_apps {
    FILES=/usr/share/${PROJECT_NAME}/apps/${PROJECT_NAME}-app-*

    function_check item_in_array

    APPS_AVAILABLE=()
    APPS_CHOSEN=()

    # for all the app scripts
    for filename in $FILES
    do
        app_name=$(echo "${filename}" | awk -F '-app-' '{print $2}')

        item_in_array "${app_name}" "${APPS_AVAILABLE[@]}"
        if [[ $? != 0 ]]; then
            APPS_AVAILABLE+=("${app_name}")
            APPS_CHOSEN+=("0")
        fi
    done

    function_check get_apps_installed
    get_apps_installed
    get_apps_installed_names
}

# detects what apps are available and can be installed
# If the variants list within an app script is an empty string then
# it is considered to be too experimental to be installable
function detect_installable_apps {
    FILES=/usr/share/${PROJECT_NAME}/apps/${PROJECT_NAME}-app-*

    APPS_AVAILABLE=()
    APPS_CHOSEN=()
    APPS_INSTALLED=()
    APPS_INSTALLED_NAMES=()

    function_check app_variants
    function_check app_is_installed
    function_check item_in_array

    # for all the app scripts
    for filename in $FILES
    do
        app_name=$(echo "${filename}" | awk -F '-app-' '{print $2}')

        item_in_array "${app_name}" "${APPS_AVAILABLE[@]}"
        if [[ $? != 0 ]]; then
            variants_list=$(app_variants $filename)
            # check for empty string
            if [ ${#variants_list} -gt 0 ]; then
                APPS_AVAILABLE+=("${app_name}")
                APPS_CHOSEN+=("0")
                APPS_INSTALLED+=("$(app_is_installed $app_name)")
                if [[ $(app_is_installed $app_name) == "1" ]]; then
                    APPS_INSTALLED_NAMES+=("$app_name")
                fi
            fi
        fi
    done
}

function detect_installed_apps {
    FILES=/usr/share/${PROJECT_NAME}/apps/${PROJECT_NAME}-app-*

    APPS_AVAILABLE=()
    APPS_INSTALLED=()
    APPS_INSTALLED_NAMES=()

    function_check app_variants
    function_check app_is_installed
    function_check item_in_array

    # for all the app scripts
    for filename in $FILES
    do
        app_name=$(echo "${filename}" | awk -F '-app-' '{print $2}')

        if [[ $(app_is_installed $app_name) == "1" ]]; then
            item_in_array "${app_name}" "${APPS_AVAILABLE[@]}"
            if [[ $? != 0 ]]; then
                variants_list=$(app_variants $filename)
                if [ ${#variants_list} -gt 0 ]; then
                    APPS_AVAILABLE+=("${app_name}")
                    APPS_INSTALLED_NAMES+=("$app_name")
                fi
            fi
        fi
    done
}

# creates the APPS_AVAILABLE and APPS_CHOSEN arrays based on
# the given variant name
function choose_apps_for_variant {
    variant_name="$1"

    function_check item_in_array
    function_check app_variants
    function_check app_is_removed

    if [ ${#variant_name} -eq 0 ]; then
        echo $"No variant name for choosing apps"
        exit 237567
    fi

    FILES=/usr/share/${PROJECT_NAME}/apps/${PROJECT_NAME}-app-*

    APPS_CHOSEN=()

    # for all the app scripts
    for filename in $FILES
    do
        app_name=$(echo "${filename}" | awk -F '-app-' '{print $2}')

        item_in_array "${app_name}" "${APPS_AVAILABLE[@]}"
        if [[ $? == 0 ]]; then
            if grep -q "VARIANTS=" ${filename}; then
                variants_list=$(app_variants $filename)
                if [[ "${variants_list}" == 'all'* || \
                      "${variants_list}" == "$variant_name" || \
                      "${variants_list}" == "$variant_name "* || \
                      "${variants_list}" == *" $variant_name "* || \
                      "${variants_list}" == *" $variant_name" ]]; then
                    if [[ $(app_is_removed ${a}) == "0" ]]; then
                        #echo $"${app_name} chosen"
                        APPS_CHOSEN+=("1")
                    else
                        APPS_CHOSEN+=("0")
                    fi
                else
                    APPS_CHOSEN+=("0")
                fi
            else
                APPS_CHOSEN+=("0")
            fi
        fi
    done

    function_check get_apps_installed
    get_apps_installed
}

# show a list of apps which have been chosen
function list_chosen_apps {
    app_index=0
    for a in "${APPS_AVAILABLE[@]}"
    do
        if [[ ${APPS_CHOSEN[$app_index]} == "1" ]]; then
            echo $"${a}"
        fi
        app_index=$[app_index+1]
    done
}

function remove_apps {
    app_index=0
    for a in "${APPS_AVAILABLE[@]}"
    do
        if [[ ${APPS_INSTALLED[$app_index]} == "1" ]]; then
            if [[ ${APPS_CHOSEN[$app_index]} == "0" ]]; then
                echo $"Removing users for application: ${a}"

                function_check remove_users_for_app
                remove_users_for_app ${a}

                echo $"Removing application: ${a}"

                function_check app_load_variables
                app_load_variables ${a}

                function_check remove_app
                remove_app ${a}

                function_check remove_${a}
                remove_${a}

                echo $"${a} was removed"
            fi
        fi
        app_index=$[app_index+1]
    done
    update_installed_apps_list
}

function install_apps_interactive {
    echo $"Interactive installer"
    app_index=0
    for a in "${APPS_AVAILABLE[@]}"
    do
        if [[ ${APPS_INSTALLED[$app_index]} == "0" ]]; then
            if [[ ${APPS_CHOSEN[$app_index]} == "1" ]]; then
                # interactively obtain settings for this app
                if [[ $(function_exists install_interactive_${a}) == "1" ]]; then
                    install_interactive_${a}
                fi
            fi
        fi

        app_index=$[app_index+1]
    done
    echo $"Interactive settings complete"
}

function user_added_to_app {
    user_name="$1"
    app_name="$2"

    if [[ $(is_valid_user "$user_name") == "1" ]]; then
        if [[ $(function_exists add_user_${app_name}) == "1" ]]; then
            if grep -Fxq "${app_name}_${user_name}" $APP_USERS_FILE; then
                echo "1"
                return
            fi
        fi
    fi
    echo "0"
}

function add_users_after_install {
    app_name="$1"

    read_config_param MY_USERNAME

    # ensure a minimum password length
    if [ ! $MINIMUM_PASSWORD_LENGTH ]; then
        MINIMUM_PASSWORD_LENGTH=20
    fi
    if [ ${#MINIMUM_PASSWORD_LENGTH} -lt 20 ]; then
        MINIMUM_PASSWORD_LENGTH=20
    fi

    ADMIN_USERNAME=$(get_completion_param "Admin user")
    if [ ! $ADMIN_USERNAME ]; then
        ADMIN_USERNAME=$MY_USERNAME
    fi

    for d in /home/*/ ; do
        USERNAME=$(echo "$d" | awk -F '/' '{print $3}')
        if [[ $(is_valid_user "$USERNAME") == "1" ]]; then
            if [[ "$USERNAME" != "$ADMIN_USERNAME" ]]; then
                if [[ $(user_added_to_app "${USERNAME}" "${app_name}") == "0" ]]; then
                    valstr=$"Login for user ${USERNAME}="
                    app_password="$(create_password ${MINIMUM_PASSWORD_LENGTH})"
                    add_user_${app_name} "${USERNAME}" "${app_password}"
                    echo "${app_name}_${USERNAME}" >> $APP_USERS_FILE
                fi
            fi
        fi
    done
}

function remove_users_for_app {
    app_name="$1"

    read_config_param MY_USERNAME

    for d in /home/*/ ; do
        USERNAME=$(echo "$d" | awk -F '/' '{print $3}')
        if [[ $(is_valid_user "$USERNAME") == "1" ]]; then
            if [[ "$USERNAME" != "$MY_USERNAME" ]]; then
                if [[ $(user_added_to_app "${USERNAME}" "${app_name}") == "1" ]]; then
                    if [[ $(function_exists remove_user_${app_name}) == "1" ]]; then
                        remove_user_${app_name} "${USERNAME}"
                    fi
                    sed -i "/${app_name}_${USERNAME}/d" $APP_USERS_FILE
                fi
            fi
        fi
    done
}

function install_apps {
    is_interactive=$1

    APP_INSTALLED_SUCCESS=1

    # interactive install configuration for each app
    if [ ${is_interactive} ]; then
        install_apps_interactive
    fi

    # now install the apps
    app_index=0
    for a in "${APPS_AVAILABLE[@]}"
    do
        if [[ ${APPS_INSTALLED[$app_index]} == "0" ]]; then
            if [[ ${APPS_CHOSEN[$app_index]} == "1" ]]; then

                # remove any temp files
                rm -rf /tmp/*

                if [ ${is_interactive} ]; then
                    # clears any removal indicator
                    function_check reinstall_app
                    reinstall_app ${a}

                    function_check app_load_variables
                    app_load_variables ${a}

                    if [[ $(app_is_installed ${a}) == "1" ]]; then
                        echo $"Upgrading application from interactive: ${a}"
                        upgrade_${a}
                        echo $"${a} was upgraded from interactive"
                    else
                        echo $"Installing application from interactive: ${a}"
                        APP_INSTALLED=
                        install_${a}
                        if [ $APP_INSTALLED ]; then
                            function_check app_save_variables
                            app_save_variables ${a}

                            function_check add_users_after_install
                            add_users_after_install ${a}

                            function_check lockdown_permissions
                            lockdown_permissions

                            function_check install_completed
                            install_completed ${a}
                            echo $"${a} was installed from interactive"
                        else
                            echo "Failed to install: ${a}" >> /var/log/${PROJECT_NAME}.log
                            APP_INSTALLED_SUCCESS=
                            echo $"${a} was not installed from interactive"
                        fi
                    fi
                else
                    # check if the app was removed
                    if [[ $(app_is_removed ${a}) == "0" ]]; then
                        function_check app_load_variables
                        app_load_variables ${a}
                        if [[ $(app_is_installed ${a}) == "1" ]]; then
                            echo $"Upgrading application: ${a}"
                            upgrade_${a}
                            echo $"${a} was upgraded"
                        else
                            echo $"Installing application: ${a}"
                            APP_INSTALLED=
                            install_${a}
                            if [ $APP_INSTALLED ]; then
                                function_check app_save_variables
                                app_save_variables ${a}

                                function_check add_users_after_install
                                add_users_after_install ${a}

                                function_check lockdown_permissions
                                lockdown_permissions

                                function_check install_completed
                                install_completed ${a}
                                echo $"${a} was installed"
                            else
                                echo "Failed to install: ${a}" >> /var/log/${PROJECT_NAME}.log
                                APP_INSTALLED_SUCCESS=
                                echo $"${a} was not installed"
                            fi
                        fi
                    else
                        echo $"${a} has been removed and so will not be reinstalled"
                    fi
                fi
            fi
        fi
        app_index=$[app_index+1]
    done

    function_check update_installed_apps_list
    update_installed_apps_list
}

# NOTE: deliberately no exit 0
