#!/bin/bash

#

# factorio_manager.sh

#

# Copyright (C) 2020, Branko Majic <branko@majic.rs>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU 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 General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

program="factorio_manager.sh"

version="0.1"

function synopsis() {

cat <<EOF

$program $version, helper tool for managing Factorio instances

Usage:

  $program [OPTIONS] launch INSTANCE

  $program [OPTIONS] info INSTANCE

  $program [OPTIONS] list

  $program [OPTIONS] create INSTANCE

  $program [OPTIONS] copy SOURCE_INSTANCE DESTINATION_INSTANCE

  $program [OPTIONS] remove INSTANCE

  $program [OPTIONS] import INSTANCE SOURCE_DIRECTORY

  $program [OPTIONS] versions

  $program [OPTIONS] set-version INSTANCE

  $program [OPTIONS] list-backups INSTANCE

  $program [OPTIONS] backup INSTANCE [DESCRIPTION]

  $program [OPTIONS] restore INSTANCE BACKUP_NAME

  $program [OPTIONS] remove-backup INSTANCE BACKUP_NAME

  $program [OPTIONS] set-game-dir GAME_INSTALLATIONS_DIRECTORY

EOF

}

function short_usage() {

cat <<EOF

$(synopsis)

For more details see $program -h.

EOF

}

function usage() {

    cat <<EOF

$(synopsis)

$program is a helper tool for managing multiple Factorio

instances.

Each instance is designated a dedicated directory, which contains all

of its configuration files, saves games, and mods, and is kept

separate from all other instances.

A single Factorio version installation (base files) can be used by

multiple instances, but each instance is bound to a specific version

of Factorio.

Factorio Manager keeps instances in sub-directories under the

~/.factorio/ directory. Sub-directories are named after the

instances. The following instance names are reserved for special use

by the tool:

 - .game_installations (used for storing symlink towards directory

   containing Factorio installations)

Multiple commands are provided for managing Factorio instances, and

they all expect different positional parameters:

set-game-dir GAME_INSTALLATIONS_DIRECTORY

    Sets the passed-in directory path as the base directory where

    different versions of Factorio will be looked-up. Each

    sub-directory within this directory should be named after the

    version of Factorio it represents, and should be the base

    directory under which the Factorio installation files can be

    found.

versions

    Shows locally available Factorio versions.

list

    Lists available Factorio instances, and shows some basic

    information about them.

create INSTANCE

    Creates a new Factorio instance with the given name. Command will

    prompt the user to pick between locally available Factorio

    versions.

launch INSTANCE

    Launches an instance with the given name.

    NOTE:: When launching the instance for the first time, Factorio

    will report that its configuration file is invalid, and offer to

    fix it. The reason is that the manager creates a minimal

    configuration file when creating an instance, and Factorio does

    not like this. It should be safe to allow Factorio to fix the

    configuration file (this will populate it with the necessary

    commented-out options).

backup INSTANCE [DESCRIPTION]

    Creates backup of an instance. All backups will be stored as

    subdirectories under the .bak directory within the instance

    directory. An optional description can be passed-in to make it

    easier to distinguish between different backups. Hidden files

    (names starting with '.') will be omitted from the backup.

list-backups INSTANCE

    Lists available backups of an instance, including description (if any is set).

$program accepts the following options:

    -q

        Quiet mode. Output a message only if newer packages are available.

    -d

        Enable debug mode.

    -v

        Show script licensing information.

    -h

        Show usage help.

Please report bugs and send feature requests to <branko@majic.rs>.

EOF

}

function version() {

    cat <<EOF

$program, version $version

+-----------------------------------------------------------------------+

| Copyright (C) 2020, Branko Majic <branko@majic.rs>                    |

|                                                                       |

| This program is free software: you can redistribute it and/or modify  |

| it under the terms of the GNU 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 General Public License for more details.                          |

|                                                                       |

| You should have received a copy of the GNU General Public License     |

| along with this program.  If not, see <http://www.gnu.org/licenses/>. |

+-----------------------------------------------------------------------+

EOF

}

# Set-up colours for message printing if we're not piping and terminal is

# capable of outputting the colors.

_color_terminal=$(tput colors 2>&1)

if [[ -t 1 ]] && (( ${_color_terminal} > 0 )); then

    _text_black=$(tput setaf 0)

    _text_red=$(tput setaf 1)

    _text_green=$(tput setaf 2)

    _text_yellow=$(tput setaf 3)

    _text_blue=$(tput setaf 4)

    _text_purple=$(tput setaf 5)

    _text_cyan=$(tput setaf 6)

    _text_white=$(tput setaf 7)

    _text_bold=$(tput bold)

    _text_reset=$(tput sgr0)

    _bg_black=$(tput setab 0)

    _bg_red=$(tput setab 1)

    _bg_green=$(tput setab 2)

    _bg_yellow=$(tput setab 3)

    _bg_blue=$(tput setab 4)

    _bg_purple=$(tput setab 5)

    _bg_cyan=$(tput setab 6)

    _bg_white=$(tput setab 7)

else

    _text_black=""

    _text_red=""

    _text_green=""

    _text_yellow=""

    _text_blue=""

    _text_purple=""

    _text_cyan=""

    _text_white=""

    _text_bold=""

    _text_reset=""

    _bg_black=""

    _bg_red=""

    _bg_green=""

    _bg_yellow=""

    _bg_blue=""

    _bg_purple=""

    _bg_cyan=""

    _bg_white=""

fi

# Set-up functions for printing coloured messages.

function debug() {

    if [[ $debug != 0 ]]; then

        echo "${_text_bold}${_text_blue}[DEBUG]${_text_reset}" "$@"

    fi

}

function info() {

    echo "${_text_bold}${_text_white}[INFO] ${_text_reset}" "$@"

}

function success() {

    echo "${_text_bold}${_text_green}[OK]   ${_text_reset}" "$@"

}

function warning() {

    echo "${_text_bold}${_text_yellow}[WARN] ${_text_reset}" "$@"

}

function error() {

    echo "${_text_bold}${_text_red}[ERROR]${_text_reset}" "$@" >&2

}

function warning_prompt() {

    echo -n "${_text_bold}${_text_yellow}[WARN] ${_text_reset}" "$@"

}

function bold_green() {

    echo -n "${_text_bold}${_text_green}$@${_text_reset}"

}

function bold_red() {

    echo -n "${_text_bold}${_text_red}$@${_text_reset}"

}

function bold_blue() {

    echo -n "${_text_bold}${_text_blue}$@${_text_reset}"

}

# Define error codes.

SUCCESS=0

ERROR_ARGUMENTS=1

ERROR_CONFIGURATION=2

ERROR_GENERAL=3

# Disable debug and quiet modes by default.

debug=0

quiet=0

# Set-up some default paths.

manager_directory="$HOME/.factorio"

game_installations_directory="$manager_directory/.game_installations"

# If no arguments were given, just show usage help.

if [[ -z $1 ]]; then

    short_usage

    exit "$SUCCESS"

fi

# Parse the arguments

while getopts "qdvh" opt; do

    case "$opt" in

	q) quiet=1;;

	d) debug=1;;

        v) version

           exit "$SUCCESS";;

        h) usage

           exit "$SUCCESS";;

        *) usage

           exit "$ERROR_ARGUMENTS";;

    esac

done

i=$OPTIND

shift $(($i-1))

# Make sure the manager home directory exists.

if [[ ! -e $manager_directory ]]; then

    info "Creating Factorio Manager home directory under: $manager_directory"

    mkdir -p "$manager_directory"

fi

command="$1"

shift

#==============#

# set-game-dir #

#==============#

if [[ $command == set-game-dir ]]; then

    # Read and verify additional positional arguments.

    game_installations_directory="$1"

    shift

    if [[ -z $game_installations_directory ]]; then

        error "Missing argument: GAME_INSTALLATIONS_DIRECTORY"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ ! -e $game_installations_directory ]]; then

        error "No such directory: $game_installations_directory"

        exit "$ERROR_GENERAL"

    fi

    # Set-up additional derived variables.

    symlink="$manager_directory/.game_installations"

    # Verify that at least one Factorio instance can be found.

    factorio_versions_found=0

    for candidate in "$game_installations_directory"/*; do

        if [[ -f $candidate/bin/x64/factorio ]]; then

            let factorio_versions_found++

        fi

    done

    if (( $factorio_versions_found == 0 )); then

        error "Could not locate any Factorio installations under: $game_installations_directory"

        exit "$ERROR_GENERAL"

    fi

    # Update the link

    if [[ -L $symlink ]]; then

        rm "$symlink"

    fi

    if ! ln -s "$game_installations_directory" "$symlink"; then

        error "Could not create symlink from $game_installations_directory to $symlink."

        exit "$ERROR_GENERAL"

    fi

#==========#

# versions #

#==========#

elif [[ $command == versions ]]; then

    # Make sure user has set directory with game installations - test

    # both symlink and target destination.

    if [[ ! -L $game_installations_directory ]]; then

        error "Game installations directory has not been properly set. Please run the set-game-dir command first."

        exit "$ERROR_CONFIGURATION"

    fi

    if [[ ! -d $game_installations_directory ]]; then

        error "Game installations directory has not been properly set. Please run the set-game-dir command first."

        exit "$ERROR_CONFIGURATION"

    fi

    echo "Locally available Factorio versions:"

    echo

    # Find all sub-directories that are Factorio installations.

    for candidate in "$game_installations_directory"/*; do

        if [[ -d $candidate && -e $candidate/bin/x64/factorio ]]; then

            echo "  - $(basename "$candidate")"

        fi

    done

    echo

#======#

# list #

#======#

elif [[ $command == list ]]; then

    echo "Available instances:"

    echo

    # Find all sub-directories that are valid instances.

    for candidate in "$manager_directory"/*; do

        if [[ -f $candidate/instance.conf ]]; then

            source "$candidate/instance.conf"

            echo "  - $(basename "$candidate") ($game_version)"

        fi

    done

    echo

#========#

# create #

#========#

elif [[ $command == create ]]; then

    # Make sure user has set directory with game installations - test

    # both symlink and target destination.

    if [[ ! -L $game_installations_directory ]]; then

        error "Game installations directory has not been properly set. Please run the set-game-dir command first."

        exit "$ERROR_CONFIGURATION"

    fi

    if [[ ! -d $game_installations_directory ]]; then

        error "Game installations directory has not been properly set. Please run the set-game-dir command first."

        exit "$ERROR_CONFIGURATION"

    fi

    # Read positional arguments.

    instance="$1"

    shift

    # Calculate derived variables.

    instance_directory="$manager_directory/$instance"

    instance_config="$instance_directory/instance.conf"

    game_config="$instance_directory/config.ini"

    # Verify arguments.

    if [[ -z $instance ]]; then

        error "Missing argument: INSTANCE"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ -e $instance_directory ]]; then

        error "Instance already exists."

        exit "$ERROR_ARGUMENTS"

    fi

    # Display list of available Factorio versions and let user pick one.

    echo "The following versions of Factorio are locally available:"

    echo

    for candidate in "$game_installations_directory"/*; do

        if [[ -f $candidate/bin/x64/factorio ]]; then

            echo "  - $(basename "$candidate")"

        fi

    done

    echo

    echo -n "Please specify what version you would like to use: "

    read game_version_selected

    # Validate user input.

    if [[ ! -f "$game_installations_directory/$game_version_selected/bin/x64/factorio" ]]; then

        error "Requested version not locally available: $game_version_selected"

        exit "$ERROR_ARGUMENTS"

    fi

    # Set-up the instance.

    mkdir "$instance_directory"

    mkdir "$instance_directory/mods"

    echo "{}" > "$instance_directory/mods/mod-list.json"

    cat <<EOF > "$instance_config"

game_version="$game_version_selected"

EOF

    # @TODO: If we could somehow obtain stock config.ini file without

    # having to first run Factorio, that would be great. As it is, the

    # user will presented with warning about corrupt config.ini when

    # running the instance for the first time.

    cat <<EOF > "$game_config"

[path]

read-data=__PATH__executable__/../../data

write-data=${instance_dir}

[general]

locale=

[other]

check-updates=false

enable-crash-log-uploading=false

[interface]

[controls]

[sound]

[map-view]

[debug]

[multiplayer-lobby]

[graphics]

EOF

    echo

    warning "Factorio Manager has created a minimal empty configuration file for Factorio under $game_config."

    warning "Since the generated configuration file is almost empty, Factorio will complain that the file seems corrupt."

    warning "Factorio will offer to fix the corrupted configuration file by filling-in the missing information during the first startup."

    warning "It should be safe to accept this. This warning will be shown by Factorio only the first time."

    echo

    echo "Please read the warning above, and press any key to continue."

    read

elif [[ $command == launch ]]; then

    # Read positional arguments.

    instance="$1"

    shift

    # Set-up derived variables.

    instance_directory="$manager_directory/$instance"

    instance_config="$instance_directory/instance.conf"

    game_config="$instance_directory/config.ini"

    # Verify arguments.

    if [[ -z $instance ]]; then

        error "Missing argument: INSTANCE"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ ! -f $instance_config ]]; then

        error "Missing instance configuration file: $instance_config"

        exit "$ERROR_GENERAL"

    fi

    if [[ ! -f $game_config ]]; then

        error "Missing game configuration file: $game_config"

        exit "$ERROR_GENERAL"

    fi

    # Update instance write directory prior to launching - this is a

    # failsafe in case it got changed by hand through some other means

    # (or maybe it was copied over from another instance).

    current_write_data=$(grep "^write-data=" "$game_config")

    expected_write_data="write-data=${instance_directory}"

    if [[ $current_write_data != $expected_write_data ]]; then

        warning "Incorrect path specified for write-data in game configuration file: $game_config"

        warning "Current configuration is: $current_write_data"

        warning "Configuration will be replaced with: $expected_write_data"

        sed -i -e "s#^write-data=.*#$expected_write_data#" "$game_config"

    fi

    # Read launcher configuration for the instance.

    source "$instance_config"

    if [[ -z $game_version ]]; then

        error "Missing game version information in $game_config."

        exit "$ERROR_CONFIGURATION"

    fi

    # Set-up paths for launching the game, and ensure they still exist

    # (versions can be removed by user).

    game_directory="${game_installations_directory}/${game_version}"

    factorio_bin="$game_directory/bin/x64/factorio"

    if [[ ! -e $factorio_bin ]]; then

        error "Could not locate Factorio binary under: $factorio_bin"

        error "Factorio $game_version installation may have been removed from game installations directory:"

        error "   $(readlink -f "$game_installations_directory")"

        exit "$ERROR_CONFIGURATION"

    fi

    # Launch instance

    "$factorio_bin" --config "$game_config"

elif [[ $command == backup ]]; then

    # Read positional arguments.

    instance="$1"

    description="$2"

    shift 2

    # Use timestamp-based names for backups.

    timestamp=$(date +%Y-%m-%d_%H:%M:%S)

    # Set-up derived variables.

    instance_directory="$manager_directory/$instance"

    instance_config="$instance_directory/instance.conf"

    game_config="$instance_directory/config.ini"

    lock_file="$instance_directory/.lock"

    backup_directory="$instance_directory/.bak"

    backup_destination="$backup_directory/$timestamp"

    backup_description="$backup_destination/.description"

    # Verify positional arguments.

    if [[ -z $instance ]]; then

        error "Missing argument: INSTANCE"

        exit "$ERROR_ARGUMENTS"

    fi

    # Verify that we are trying to backup an actual instance.

    if [[ ! -f $instance_config ]]; then

        error "Missing instance configuration file: $instance_config"

        exit "$ERROR_GENERAL"

    fi

    if [[ ! -f $game_config ]]; then

        error "Missing game configuration file: $game_config"

        exit "$ERROR_GENERAL"

    fi

    # Make sure we do not overwrite the backup destination by mistake

    # - although highly unlikely unless user spams the backup command.

    if [[ -e $backup_destination ]]; then

        error "Backup already exists: $backup_destination"

    fi

    (

        # Obtain lock - Factorio uses the same mechanism, so we should

        # be able to detect the game is running in this way.

        flock --exclusive --nonblock 200

        if [[ $? != 0 ]]; then

            error "Could not lock instance directory via lock file $lock_file. Is Factorio instance still running?"

            exit "$ERROR_GENERAL"

        fi

        function remove_lock() {

            rm "$lock_file"

        }

        trap remove_lock EXIT

        # Backup the instance. Clean-up the backup destination in case of failure.

        mkdir -p "$backup_destination"

        if ! cp -a "$instance_directory"/* "$backup_destination"; then

            error "Could not create backup under: $backup_destination"

            rm -rf "$backup_destination"

            exit "$ERROR_GENERAL"

        fi

        # Store (optional) description.

        if [[ -n $description ]]; then

            echo "$description" > "$backup_description"

        fi

        success "Backup saved to: $backup_destination"

    ) 200>"$lock_file"

#==============#

# list-backups #

#==============#

elif [[ $command == list-backups ]]; then

    # Read positional arguments.

    instance="$1"

    shift

    # Set-up derived variables.

    instance_directory="$manager_directory/$instance"

    instance_config="$instance_directory/instance.conf"

    game_config="$instance_directory/config.ini"

    backup_directory="$instance_directory/.bak"

    # Verify positional arguments.

    if [[ -z $instance ]]; then

        error "Missing argument: INSTANCE"

        exit "$ERROR_ARGUMENTS"

    fi

    # Verify instance.

    if [[ ! -d $instance_directory ]]; then

        error "No such instance: $instance"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ ! -f $instance_config ]]; then

        error "Missing instance configuration file: $instance_config"

        exit "$ERROR_GENERAL"

    fi

    if [[ ! -f $game_config ]]; then

        error "Missing game configuration file: $game_config"

        exit "$ERROR_GENERAL"

    fi

    # Extended regular expression for matching YYYY-MM-DD-hh:mm:ss format.

    backup_destination_name_pattern="[[:digit:]]{4}-[[:digit:]]{2}-[[:digit:]]{2}_[[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}"

    # Read current game version.

    source "$instance_config"

    current_game_version="$game_version"

    unset game_version

    # Detect and show available backups to the user.

    if [[ ! -d $backup_directory ]] || ! ls "$backup_directory" | grep -q -E "^$backup_destination_name_pattern\$"; then

        echo "No backups are available for instance $(bold_green $instance)."

    else

        echo "Available backups for instance $(bold_green $instance) (current version $(bold_green "$current_game_version"))."

        echo

        for backup_destination in "$backup_directory"/*; do

            if [[ $backup_destination =~ $backup_destination_name_pattern ]]; then

                backup_date=$(basename "$backup_destination")

                # Read instance configuration for backup.

                source "$backup_destination/instance.conf"

                if [[ -f "$backup_destination/.description" ]]; then

                    backup_description=$(<"$backup_destination/.description")

                    echo "  - $backup_date, version $(bold_green "$game_version") ($backup_description)"

                else

                    echo "  - $backup_date, version $(bold_green "$game_version")"

                fi

            fi

        done

        echo

    fi

#=========#

# restore #

#=========#

elif [[ $command == restore ]]; then

    # Read positional arguments.

    instance="$1"

    backup_name="$2"

    shift 2

    # Set-up derived values.

    instance_directory="$manager_directory/$instance"

    restore_source="$instance_directory/.bak/$backup_name"

    backup_instance_config="$restore_source/instance.conf"

    backup_game_config="$restore_source/config.ini"

    lock_file="$instance_directory/.lock"

    # Verify positional arguments.

    if [[ -z $instance ]]; then

        error "Missing argument: INSTANCE"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ -z $backup_name ]]; then

        error "Missing argument: BACKUP_NAME"

        exit "$ERROR_ARGUMENTS"

    fi

    # Verify we are working with legitimate instance and backup.

    if [[ ! -d $instance_directory ]]; then

        error "No such instance: $instance"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ ! -d $restore_source ]]; then

        error "Specified backup not available under: $restore_source"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ ! -f $backup_instance_config ]]; then

        error "Invalid backup, missing instance configuration file: $backup_instance_config"

        exit "$ERROR_GENERAL"

    fi

    if [[ ! -f $backup_game_config ]]; then

        error "Invalid backup, missing game configuration file: $backup_game_config"

        exit "$ERROR_GENERAL"

    fi

    (

        # Obtain lock - Factorio uses the same mechanism, so we should

        # be able to detect the game is running in this way.

        flock --exclusive --nonblock 200

        if [[ $? != 0 ]]; then

            error "Could not lock instance directory via lock file $lock_file. Is Factorio instance still running?"

            exit "$ERROR_GENERAL"

        fi

        function remove_lock() {

            rm "$lock_file"

        }

        trap remove_lock EXIT

        # Set-up a list of files and directories that will get removed.

        shopt -s nullglob

        entries_to_remove=($instance_directory/*)

        shopt -u nullglob

        # Present user with extensive warning on consequences.

        echo

        warning "You are about to replace current instance's files, including (but not limited to):"

        warning

        warning "  - configuration files"

        warning "  - blueprints"

        warning "  - savegames"

        warning "  - achievements"

        warning "  - mods"

        warning

        warning "All instance files will be replaced by files from specified backup."

        # Display backup information.

        echo

        if [[ -f "$restore_source/.description" ]]; then

            backup_description=$(<"$restore_source/.description")

            backup_info="$backup_name ($backup_description)"

        else

            backup_info="$backup_name"

        fi

        echo "Restore instance $(bold_green "$instance") from backup: $(bold_green "$backup_info")"

        echo

        # Show user what files will be removed.

        if [[ ${#entries_to_remove[@]} == 0 ]]; then

            echo "Instance directory is currently empty. No files will be removed."

            echo

        else

            echo "Files and directories that will be removed:"

            echo

            for entry in "${entries_to_remove[@]}"; do

                echo "  - $entry"

            done

            echo

        fi

        # Request from user to confirm the operation.

        warning_prompt "Are you sure you want to proceed? Type YES to confirm (default is no): "

        read confirm

        if [[ $confirm != "YES" ]]; then

            error "Aborted restore process, no changes have been made to instance files."

            exit "$ERROR_GENERAL"

        fi

        if [[ ${#entries_to_remove[@]} != 0 ]]; then

            if ! rm -rf "${entries_to_remove[@]}"; then

                error "Failed to remove existing instance files."

                exit "$ERROR_GENERAL"

            fi

        fi

        if ! cp -a "$restore_source"/* "$instance_directory"; then

            error "Failed to restore backup from: $restore_source"

            exit "$ERROR_GENERAL"

        fi

        success "Instance restored from backup."

    ) 200>"$lock_file"

#===============#

# remove-backup #

#===============#

elif [[ $command == remove-backup ]]; then

    # Read positional arguments.

    instance="$1"

    backup_name="$2"

    shift 2

    # Verify positional arguments.

    if [[ -z $instance ]]; then

        error "Missing argument: INSTANCE"

        exit "$ERROR_ARGUMENTS"

    fi

    if [[ -z $backup_name ]]; then

        error "Missing argument: BACKUP_NAME"

        exit "$ERROR_ARGUMENTS"

    fi

    # Set-up derived values.

    instance_directory="$manager_directory/$instance"

    removal_target="$instance_directory/.bak/$backup_name"

    backup_instance_config="$removal_target/instance.conf"

    backup_game_config="$removal_target/config.ini"

    lock_file="$instance_directory/.lock"