#!/usr/bin/env bash

license() {
    cat << EOF
    ■The contents of this file are subject to the Common Public Attribution
    License Version 1.0 (the ■License■); you may not use this file except in
    compliance with the License. You may obtain a copy of the License at
    https://opensource.org/licenses/CPAL-1.0. The License is based on the Mozilla Public License Version
    1.1 but Sections 14 and 15 have been added to cover use of software over a
    computer network and provide for limited attribution for the Original
    Developer. In addition, Exhibit A has been modified to be consistent with
    Exhibit B.

    Software distributed under the License is distributed on an ■AS IS■ basis,
    WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    for the specific language governing rights and limitations under the
    License.

    The Original Code is linux-game-manager.

    The Original Developer is not the Initial Developer and is . If
    left blank, the Original Developer is the Initial Developer.

    The Initial Developer of the Original Code is Billy "Storm Dragon" Wolfe. All portions of
    the code written by Billy Wolfe are Copyright (c) 2020. All Rights
    Reserved.

    Contributor Michael Taboada.

    Attribution Copyright Notice: linux-game-manager copyright 2022 Storm Dragon. All rights reserved.

    Attribution Phrase (not exceeding 10 words): A Stormux project

    Attribution URL: https://stormgames.wolfe.casa

    Graphic Image as provided in the Covered Code, if any.

    Display of Attribution Information is required in Larger
    Works which are defined in the CPAL as a work which combines Covered Code
    or portions thereof with code not governed by the terms of the CPAL.
EOF
}

# Dialog accessibility
export DIALOGOPTS='--no-lines --visit-items'


# Check for updates
check_update() {
    local url="$(git ls-remote --get-url)"
    if [[ "$url" =~ ^ssh://|git@ ]] || [[ -z "$url" ]]; then
        return
    fi
    git remote update > /dev/null 2>&1
    local upstream='@{u}'
    local home="$(git rev-parse @)"
    local remote="$(git rev-parse "$upstream")"
if [[ "$home" == "$remote" ]]; then
    return
fi
    dialog --backtitle "Linux Game manager" \
        --yesno "Updates are available. Would you like to update now?" -1 -1 --stdout || return
    git pull
    exit $?
}

# Check architecture compatibility
check_architecture() {
    local architecture="$(uname -m)"
    for i in "$@" ; do
        if [[ "${architecture}" == "$i" ]]; then
            return
        fi
    done
    dialog --backtitle "Linux Game Manager" \
        --infobox "This game is not compatible with $architecture architecture." -1 -1
    exit 1
}

# Check dependencies required for games
check_dependencies() {
    local dependencies
    for i in "${@}"; do
        if ! command -v "$i" > /dev/null 2>&1 ; then
            dependencies+=("$i")
        fi
    done
    if [[ "${#dependencies[@]}" -eq 0 ]]; then
        return
    fi
    echo "missing dependencies. Please install the following:"
    echo
    for i in "${dependencies[@]}" ; do
        echo "$i"
    done
    exit 1
}

# Function to open a terminal emulator
terminal_emulator() {
    terminals=(
        "lxterminal"
        "mate-terminal"
        "gnome-terminal"
    )
    for i in "${terminals[@]}" ; do
        if command $i --working-directory="${game%/*}" -e $* ; then
            return
        fi
    done
    echo "No suitable terminal emulators found, please install one of:"
    for i in "${terminals[@]}" ; do
        echo "$i"
    done
}

# Function to open urls
open_url() {
    xdg-open "${*}" 2> /dev/null
}

# Create desktop launcher file
desktop_launcher() {
    local desktopFile="${HOME}/linux-game-manager.desktop"
    if [[ -e "${desktopFile}" ]]; then
        echo "the file ${desktopFile} exists. Cannot create the launcher."
        exit 1
    fi
    local dotDesktop
    local terminal
    # Try to find an accessible terminal
    for i in mate-terminal lxterminal terminator gnome-terminal ; do
        if command -v $i > /dev/null 2>&1 ; then
            terminal="$i"
            break
        fi
    done
    dotDesktop=('[Desktop Entry]'
        'Name=Linux game manager'
        'GenericName=Linux game Manager'
        'Comment=Install and launch games that are accessible to the blind'
        "Exec=${terminal} -t \"Linux Game Manager\" -e \"/usr/bin/bash -c 'nohup $(readlink -e "$0") 2> /dev/null'\""
        'Terminal=false'
        'Type=Application'
        'StartupNotify=false'
        'Keywords=game;'
        'Categories=Game;'
    'Version=1.0')
    for i in "${dotDesktop[@]}" ; do
        echo "$i" >> "${desktopFile}"
    done
    desktop-file-install --dir "${HOME}/.local/share/applications" -m 755 "${desktopFile}"
    xdg-desktop-icon install ~/.local/share/applications/linux-game-manager.desktop
    rm "${desktopFile}"
    exit 0
}

clear_cache() {
    local answer
    if [[ ! -d "${cache}" ]]; then
        echo "No cache found at ${cache}."
        return
    fi
    while ! [[ "${answer,,}" =~ ^yes$|^no$ ]]; do
        echo "This will delete all contents of ${cache}. Are you sure you want to continue?"
        echo "Please type yes or no."
        echo
        read -r answer
    done
    if [[ "$answer" == "no" ]]; then
        return
    fi
    # All safety checks done. Delete the cache.
    rm -rfv "${cache}"
    echo "Cache deleted."
}

download() {
    local source=($@)
    for i in "${source[@]}" ; do
        local dest="${i##*/}"
        dest="${dest//%20/ }"
        # Remove the destination file if it is empty.
        test -s "${cache}/${dest}" || rm -f "${cache}/${dest}" 2> /dev/null
        if [[ "${redownload}" == "true" ]] && [[ -e "${cache}/${dest}" ]]; then
            rm -v "${cache}/${dest}"
        fi
        # Skip if the item is in cache.
        test -e "${cache}/${dest}" && continue
        if ! wget -4 -O "${cache}/${dest}" "${i}" ; then
            echo "Could not download \"$i\"..."
            exit 1
        fi
    done
}

get_installer() {
    trap "exit 0" SIGINT
    # If the file is in cache nothing else needs to be done.
    if [[ -f "${cache}/$1" ]]; then
        return
    fi
    # Create message for dialog.
    local message="Make sure $1 is available in either your Downloads or Desktop directory and press enter to continue."
    if [[ -n "$2" ]]; then
        message+="\n\nThe last good known URL for $game is:"
        message+="\n$2"
    fi
    if echo "$2" | xclip -selection clipboard 2> /dev/null ; then
        message+="\n\nThe URL has been copied to the clipboard."
    fi
    dialog --ok-label "Continue" \
        --backtitle "Linux Game Manager" \
        --msgbox "$message" -1 -1
    # Search the Desktop and Downloads directories for the installation file
    for i in ~/Downloads ~/Desktop ; do
        find $i -type f -name "$1" -exec mv -v {} "${cache}/" \;
    done
    # If the file is still not available abort.
    if [[ ! -f "${cache}/$1" ]]; then
        echo "couldn't find $1. Please download the file and try again."
        exit 1
    fi
}

help() {
    echo "${0##*/}"
    echo "Released under the terms of the Common Public Attribution License Version 1.0"
    echo -e "This is a Stormux project: https://stormux.org\n"
    echo -e "Usage:\n"
    echo "With no arguments, open the game launcher."
    for i in "${!command[@]}" ; do
        echo "-${i/:/ <parameter>}: ${command[${i}]}"
    done | sort
    exit 0
}


# main script

add_launcher() {
    local launchSettings="${game}|${*}"
    if ! grep -F -q -x "${launchSettings}" "${configFile}" 2> /dev/null ; then
        echo "${launchSettings}" >> "${configFile}"
        sort -o "${configFile}" "${configFile}"
    fi
}

# Install games
game_installer() {
    mapfile -t installedGames < <(sed '/^$/d' "${configFile}" 2> /dev/null | cut -d '|' -f1)
    # Create the menu of installed games
    declare -a menuList
    for i in "${gameList[@]}" ; do
        local menuItem="$i"
        for j in "${installedGames[@]}" ; do
            if [[ "$j" == "$menuItem" ]]; then
                unset menuItem
            fi
        done
        if [[ -n "$menuItem" ]]; then
            menuList+=("$menuItem" "$menuItem")
        fi
    done
    if [[ ${#menuList[@]} -eq 0 ]]; then
        echo "All games are already installed."
        exit 0
    fi
    menuList+=("Donate" "Donate")
    game="$(dialog --backtitle "Game Installer" \
        --clear \
        --no-tags \
        --menu "Please select a game to install" 0 0 0 "${menuList[@]}" --stdout)"
}

# launch games that are installed
game_launcher() {
    mapfile -t lines < <(sed '/^$/d' "${configFile}" 2> /dev/null)
    # Create the menu of installed games
    declare -a menuList
    for i in "${lines[@]}" ; do
        menuList+=("${i#*|}" "${i%|*}")
    done
    # Web based games and donation
    menuList+=("Aliens" "Aliens")
    menuList+=("Cacophony" "Cacophony")
    menuList+=("Battle Weary" "Battle Weary")
    menuList+=("QuentinC Play Room" "QuentinC Play Room")
    menuList+=("Trigaea" "Trigaea")
    menuList+=("Donate" "Donate")
    game="$(dialog --backtitle "Linux Game Launcher" \
            --clear \
            --no-tags \
            --menu "Please select a game to play" 0 0 0 "${menuList[@]}" --stdout)"
    local menuCode=$?
    if [[ $menuCode -eq 1 ]]; then
        exit 0
    fi
    # Remove any trailing | from game variable.
    game="${game%|}"
    case "${game}" in
        "Aliens")
            open_url "https://files.jantrid.net/aliens/"
            ;;
        "Battle Weary")
            open_url "https://lonespelunker.itch.io/battle-weary"
        ;;
        "Cacophony")
            open_url "https://tianmaru.itch.io/cacophony"
        ;;
        "QuentinC Play Room")
            open_url "https://qcsalon.net/"
            ;;
        "Trigaea")
            open_url "https://ryngm.itch.io/trigaea"
            ;;
        "Donate")
            open_url "https://ko-fi.com/stormux"
            ;;
            *".tin")
                git -C "${game%/*}" pull | \
                    dialog --progressbox "Checking for updates, please wait..." -1 -1
                if [[ -n "${COLORTERM}" ]]; then
                    terminal_emulator tt++ ${game##*/}
                else
                    pushd "${game%/*}"
                    exec tt++ ${game##*/}
                fi
            ;;
            *)
                pushd "${game%/*}"
                exec ${game}
            ;;
    esac
    exit 0
}


# If display isn't set assume we are launching from console and an X environment is running using display :0
# Warning, launching games from console is not recommended.
if [[ -z "$DISPLAY" ]]; then
    export DISPLAY=":0"
fi
# Settings file
cache="${XDG_CACHE_HOME:-$HOME/.cache}/linux-game-manager"
configFile="${XDG_CONFIG_HOME:-$HOME/.config}/storm-games/linux-game-manager/games.conf"
mkdir -p "${cache}"
mkdir -p "${configFile%/*}"
# Load any arguments from settings.conf file
if [[ -r "${configFile%/*}/settings.conf" ]]; then
    source "${configFile%/*}/settings.conf"
fi
unset noCache

# The list of games available for installation.
# Use menu friendly names.
gameList=(
    "Aliens"
    "Alter Aeon"
    "Audo"
    "Auroboros"
    "Battle Weary"
    "Bladius"
    "Cacophony"
    "Chimera"
    "Echo Command"
    "E.X.O."
    "EmpireMUD"
    "End of Time"
    "Fantasy Story II"
    "Monkey Spank"
    "Numnastics"
    "Onslaught"
    "QuentinC Play Room"
    "Periphery Synthetic EP"
    "S.E.A."
    "SoundRTS"
    "soundStrider"
    "StickMUD"
    "System Fault"
    "Trigaea"
    "Wurmus"
)

# Check for required packages
requiredPackages=(
    "curl"
    "dialog"
    "unzip"
    "wget"
)
for i in "${requiredPackages[@]}" ; do
    if ! command -v $i > /dev/null 2>&1 ; then
        echo "Please install $i before continuing."
        exit 1
    fi
done
check_update
# With no arguments, open the game launcher.
if [[ $# -eq 0 ]]; then
    game_launcher
fi

# Array of command line arguments
declare -A command=(
    [C]="Clear the cache. All game installers will be deleted."
    [D]="Create desktop shortcut. You can launch Linux Game Manager from the desktop or applications menu."
    [h]="This help screen."
    [i]="Install games."
    [L]="Display license information."
    [N]="No cache, delete the installer after it has been extracted."
    [R]="Redownload. Removes old versions of packages from cache before installing."
    [t]="Total games. Show how many games are currently available."
)

# Convert the keys of the associative array to a format usable by getopts
args="${!command[*]}"
args="${args//[[:space:]]/}"
while getopts "${args}" i ; do
    case "$i" in
        C) clear_cache ;;
        D) desktop_launcher ;;
        h) help ;;
        i) game_installer ;;
        L) license ;;
        N) noCache="true" ;;
        R) redownload="true" ;;
        t)
            dialog --backtitle "Linux Game Manager" \
                --infobox "There are currently ${#gameList[@]} games available." -1 -1
            exit 0
            ;;
    esac
done

# Install game based on the selection above.
installPath="${HOME}/.local/games"
mkdir -p "${installPath}"
case "${game}" in
    "Aliens"|"Battle Weary"|"Cacophony"|"QuentinC Play Room"|"Trigaea")
        dialog --backtitle "Linux Game manager" \
            --infobox "${game} is a web based game and does not need to be installed." -1 -1
        ;;
    "Alter Aeon")
        check_dependencies git sox tt++
        git -C "${installPath}/" clone --recurse-submodules https://github.com/lilmike/tintin-alteraeon.git | \
            dialog --progressbox "Installing \"${game}\", please wait..." -1 -1
        add_launcher "${installPath}/tintin-alteraeon/aa.tin"
        ;;
    "Audo")
        check_architecture x86_64
        get_installer "Audo-linux-x64.zip" "https://shiftbacktick.itch.io/audo"
        mkdir -p "${installPath}/Audo"
        unzip -d "${installPath}/Audo" "${cache}/Audo-linux-x64.zip"
        add_launcher "${installPath}/Audo/Audo"
        ;;
    "Auroboros")
        check_architecture x86_64
        get_installer "Auroboros-linux-x64.zip" "https://shiftbacktick.itch.io/auroboros"
        mkdir -p "${installPath}/Auroboros"
        unzip -d "${installPath}/Auroboros" "${cache}/Auroboros-linux-x64.zip"
        add_launcher "${installPath}/Auroboros/Auroboros"
        ;;
    "Bladius")
        check_architecture x86_64
        get_installer "Bladius-linux-x64.zip" "https://shiftbacktick.itch.io/bladius"
        mkdir -p "${installPath}/Bladius"
        unzip -d "${installPath}/Bladius" "${cache}/Bladius-linux-x64.zip"
        add_launcher "${installPath}/Bladius/Bladius"
        ;;
    "Chimera")
        check_architecture x86_64
        get_installer "Chimera-linux-x64.zip" "https://shiftbacktick.itch.io/chimera"
        mkdir -p "${installPath}/Chimera"
        unzip -d "${installPath}/Chimera" "${cache}/Chimera-linux-x64.zip"
        add_launcher "${installPath}/Chimera/Chimera"
        ;;
    "Echo Command")
        check_architecture x86_64
        get_installer "Echo Command.tar.xz" "https://pancakedev.itch.io/echo-command"
        mkdir -p "${installPath}/Echo-Command"
        tar xf "${cache}/Echo Command.tar.xz" -C "${installPath}/Echo-Command"
        ln -sr "${installPath}/Echo-Command/Echo Command.x86_64" "${installPath}/Echo-Command/Echo_Command.x86_64"
        add_launcher "${installPath}/Echo-Command/Echo_Command.x86_64"
        ;;
    "E.X.O.")
        check_architecture x86_64
        get_installer "EXO-linux-x64.zip" "https://shiftbacktick.itch.io/exo"
        mkdir -p "${installPath}/E.X.O."
        unzip -d "${installPath}/E.X.O." "${cache}/EXO-linux-x64.zip"
        add_launcher "${installPath}/E.X.O./EXO"
        ;;
    "EmpireMUD")
        check_dependencies git sox tt++
        git -C "${installPath}/" clone --recurse-submodules https://github.com/lilmike/tintin-empiremud.git | \
            dialog --progressbox "Installing \"${game}\", please wait..." -1 -1
        add_launcher "${installPath}/tintin-empiremud/em.tin"
        ;;
    "End of Time")
        check_dependencies git opusdec sox tt++
        git -C "${installPath}/" clone https://git.2mb.codes/~stormdragon2976/tintin-endoftime | \
            dialog --progressbox "Installing \"${game}\", please wait..." -1 -1
        add_launcher "${installPath}/tintin-endoftime/eot.tin"
        ;;
    "Fantasy Story II")
        check_architecture x86_64
        get_installer "FS2_2.6_Linux.zip" "https://drive.google.com/file/d/187OaD1HhPoty85yJafZyvfqD5_G3P04c/view?usp=sharing"
        unzip -d "${installPath}" "${cache}/FS2_2.6_Linux.zip"
        chmod +x "${installPath}/FS2_2.6_Linux/FS2.x86_64"
        add_launcher "${installPath}/FS2_2.6_Linux/FS2.x86_64" "-ESpeakApplication=espeak-ng"
        ;;
    "Monkey Spank")
        git -C "${installPath}" clone --recurse-submodules https://gitlab.com/stormdragon2976/monkeyspank.git
        add_launcher "${installPath}/monkeyspank/monkeyspank"
        ;;
    "Numnastics")
        git -C "${installPath}" clone --recurse-submodules https://gitlab.com/stormdragon2976/numnastics.git
        add_launcher "${installPath}/numnastics/numnastics"
        ;;
    "Onslaught")
        check_architecture x86_64
        get_installer "onslaught.AppImage" "https://lightsoutgames.itch.io/onslaught"
        mkdir -p "${installPath}/Onslaught"
        cp -v "${cache}/onslaught.AppImage" "${installPath}/Onslaught/onslaught.AppImage"
        chmod +x "${installPath}/Onslaught/onslaught.AppImage"
        add_launcher "${installPath}/Onslaught/onslaught.AppImage"
        ;;
    "Periphery Synthetic EP")
        check_architecture x86_64
        get_installer "periphery-synthetic-ep-linux-x64.zip" "https://shiftbacktick.itch.io/periphery-synthetic-ep"
        mkdir -p "${installPath}/periphery-synthetic-ep"
        unzip -d "${installPath}/periphery-synthetic-ep" "${cache}/periphery-synthetic-ep-linux-x64.zip"
        add_launcher "${installPath}/periphery-synthetic-ep/periphery-synthetic-ep"
        ;;
    "S.E.A.")
        check_architecture x86_64
        get_installer "SEA-linux-x64.zip" "https://shiftbacktick.itch.io/sea"
        mkdir -p "${installPath}/S.E.A."
        unzip -d "${installPath}/S.E.A." "${cache}/SEA-linux-x64.zip"
        add_launcher "${installPath}/S.E.A./SEA"
        ;;
    "SoundRTS")
        mkdir -p "${installPath}"
        git -C "${installPath}" clone "https://github.com/soundmud/soundrts.git"
        git -C "${installPath}/soundrts" checkout v1.3.5
        sed -i 's;git+https://github.com/soundmud/accessible_output2;accessible_output2;' "${installPath}/soundrts/requirements.txt"
        pip3 install --user -r "${installPath}/soundrts/requirements.txt"
        chmod +x "${installPath}/soundrts/soundrts.py"
        sed -i '1c\#!/usr/bin/env python3' "${installPath}/soundrts/soundrts.py"
        add_launcher "${installPath}/soundrts/soundrts.py"
        ;;
    "soundStrider")
        check_architecture x86_64
        get_installer "soundStrider-linux-x64.zip" "https://shiftbacktick.itch.io/soundstrider"
        mkdir -p "${installPath}/soundStrider"
        unzip -d "${installPath}/soundStrider" "${cache}/soundStrider-linux-x64.zip"
        add_launcher "${installPath}/soundStrider/soundStrider"
        ;;
    "StickMUD")
        check_dependencies git sox tt++
        git -C "${installPath}/" clone --recurse-submodules https://github.com/stormdragon2976/tintin-stickmud.git | \
            dialog --progressbox "Installing \"${game}\", please wait..." -1 -1
        add_launcher "${installPath}/tintin-stickmud/stickmud.tin"
        ;;
    "System Fault")
        check_architecture x86_64
        get_installer "system-fault-linux-x86_64.AppImage" "https://lightsoutgames.itch.io/systemfault"
        mkdir -p "${installPath}/System_Fault"
        cp -v "${cache}/system-fault-linux-x86_64.AppImage" "${installPath}/System_Fault/system-fault-linux-x86_64.AppImage"
        chmod +x "${installPath}/System_Fault/system-fault-linux-x86_64.AppImage"
        add_launcher "${installPath}/System_Fault/system-fault-linux-x86_64.AppImage"
        ;;
    "Wurmus")
        check_architecture x86_64
        get_installer "Wurmus-linux-x64.zip" "https://shiftbacktick.itch.io/wurmus"
        mkdir -p "${installPath}/Wurmus"
        unzip -d "${installPath}/Wurmus" "${cache}/Wurmus-linux-x64.zip"
        add_launcher "${installPath}/Wurmus/Wurmus"
        ;;
    "Donate")
        open_url "https://ko-fi.com/stormux"
        ;;
    *)
        [[ -n "${game}" ]] && echo "Game \"${game}\" not found."
        exit 1
        ;;
esac

exit 0