sys

#!/bin/bash

## Ecosystems array (aka "ecos")
declare -A ecosystems
ecosystems["--python"]="Python"
ecosystems["--cloud"]="Cloud"
ecosystems["--containers_vms"]="Containers and VMs"
ecosystems["--db_clients"]="Database Clients"
ecosystems["--javascript_node"]="JavaScript and Node"
ecosystems["--web_tools"]="Web Tools"
ecosystems["--java"]="Java"
ecosystems["--c_c++"]="C and C++"
ecosystems["--go"]="Go"
ecosystems["--version_control"]="Version Control"
ecosystems["--php"]="PHP"
ecosystems["--ruby"]="Ruby"
ecosystems["--rust"]="Rust"

check_args() {
    local valid_args=false

    if [[ "$1" == "--init" ]]; then
        valid_args=true
    fi

    # Check is present and non-empty
    for arg in "$@"; do
        if [ -n "$arg" ] && [ -n "${ecosystems[$arg]}" ]; then
            valid_args=true
            break
        fi
    done

    if [ "$valid_args" = false ]; then
        show_cli_screen
        exit 1
    fi
}

show_cli_screen() {
cat << EOF
Welcome. Pass in your ecosystems with options below.

Usage: ./sys --init
       ./sys [ecosystem options]
    

Options:
$(for eco_key in "${!ecosystems[@]}"; do
    echo "  $eco_key"
done)

EOF
}

## Determines OS: ubuntu, fedora, macos, etc
detect_system() {
    if [ -e "/etc/os-release" ]; then
        sys_os=$(awk -F= '/^ID=/{print $2}' /etc/os-release)
    elif [ "$(uname)" == "Darwin" ]; then 
        sys_os="macos"
    fi
}

exec_script() {
    eco_key="$1"

    # Escaped path
    script=$(echo "$2" | sed 's/ /\\ /g')

    # Extract the name from script absolute file path
    name=$(echo "${script#*_}" | sed 's/_/ /g' | sed 's/\.sh$//')

    echo "[$eco_key] Processing $name..."

    #output=$(timeout 30s bash -c "$script" 2>&1)  # Redirect stderr to stdout
    output=$(timeout 30s bash -c "$script" 2>&1 | tee -a /var/log/progsys.log)
    if [ $? -ne 0 ]; then
        echo "[ERROR] check /var/log/progsys.log"
        echo "$output"
        echo "continuing..."
    fi
}

# For _Init_.sh
install_core_software() {
    local core_directory="$sys_root/$sys_os/#Core"
    local core_lock_file="/var/run/progsys.lock"
    local core_init_script=$core_directory"/_Init_.sh"
    local core_key="Core"

    if [ ! -e "$core_lock_file" ]; then
        exec_script "$core_key" "$core_init_script"

        for script in "$core_directory"/*; do
            if [ $script != "$core_init_script" ]; then
                exec_script "$core_key" "$script"
            fi
        done

        sudo touch "$core_lock_file"
    fi
}

sanitize_raw_filename() {
    local raw_filename="$1"

    # Don't process files that are commented out
    if ! [[ $raw_filename =~ ^# ]]; then
        sanitized=$(echo "$line" | sed 's/ /_/g')
        echo "$sanitized"
    fi
}

install_ecosystem_package() {
    local eco_key="$1"
    local package="$2"

    # TODO: better ways of match file number
    script=$(find "$sys_root/$sys_os/$eco_key" -maxdepth 1 -type f -name "???_${package}.sh")

    exec_script "$eco_key" "$script"
}

# Main installation logic. This reads in a "requirements.txt" file, inspired by the classic Python
# packaging format. If an selected ecosystem "flag" is matched, subsequent uncommented lines (keyed
# by package name) are installed. 
install_ecosystems() {
    local selected_flags=("$@")

    mapfile -t lines < "$sys_root/$sys_os/requirements.txt"

    for selected_flag_index in "${!selected_flags[@]}"; do
        selected_flag="${selected_flags[$selected_flag_index]}"

        for line in "${lines[@]}"; do
            if [[ $line =~ ^## ]]; then
                current_ecosystem=$(echo "$line" | sed -n 's/## \(.*\) ##/\1/p')
            elif [[ ! "$line" =~ ^[[:space:]]*$ && ! "$line" =~ ^# ]]; then
                flag_key="${selected_flag}"
                ecos_key="${ecosystems[$flag_key]}"

                filename=$(sanitize_raw_filename "$line")

                if [ "$current_ecosystem" == "$ecos_key" ] && [ -n "$filename" ]; then
                    install_ecosystem_package "$ecos_key" "$filename"
                fi
            fi
        done
    done
}



main() {
    sudo -v # prompt for sudo (unix-like standard)

    check_args "$@"

    detect_system

    export sys_root="/home/$(whoami)/system"

    # called in the scripts
    sys_check() {
        local package=$1

        if [ -e "$package" ] && [ -d "$package" ]; then
            return 0
        elif [ -e "$package" ]; then
            return 0
        else
            return 1
        fi
    }
    export -f sys_check

    sys_exec() { . "$sys_root/$1"; }
    export -f sys_exec

    if [[ "$1" == "--init" ]]; then
        install_core_software
        exec bash -l # done, reset 
    else
        install_ecosystems "$@"
    fi
}


main "$@"