CommonResources

# CommonResources for SetupHelper
# contains a functions and variables necessary for a setup script to interface with reinstallMods
#
# Refer to the SetupHelper ReadMe file for details on how to use these resources.

######## skip to bottom of file for code executed when script is called

setupHelperDir="/data/SetupHelper"
source "$setupHelperDir/EssentialResources"
source "$setupHelperDir/LogHandler"
source "$setupHelperDir/ServiceResources"
source "$setupHelperDir/UpdateResources"
source "$setupHelperDir/DbusSettingsResources"

# what action the script should take:
#  NONE - do noting - signals script to prompt for user input on how to proceed
#  INSTALL - install package components
#  (decommissioned) PROMPT - prompt user for additional installation options
#  UNINSTALL - remove package components
#  (decommissioned) EXIT - exit script without taking any action (now exits in-line)
# CommonResources may set the the action if initial checks
#  indicate a clear direction
# otherwise, the action will be set based on user input (in the script)
# if failures occur during installation,
# scriptAction should be changed to UNINSTALL so the installation can be cleaned up
# and the setup script should test for UNINSTALL after it attempts installation
# A file set error indicates the file set for the current verion is not usable
#  and installation should not occur
#  checkFileSets EXITS locally

scriptAction='NONE'

# flags to control setup script exit behavior
rebootNeeded=false
runAgain=false
filesUpdated=false
restartGui=false



# yesNoPrompt provides user prompting requesting a yes/no response
#
# $1 is the prompt displayed when pausing for user input
#
# $yesResponse is set to true if the response was yes

yesNoPrompt ()
{
    response=''
    while true; do
        /bin/echo -n "$*"
        read response
        case $response in
            [yY]*)
                yesResponse=true
                break
                ;;
            [nN]*)
                yesResponse=false
                break
                ;;
            *)
        esac
    done
}


# standardActionPrompt provides the standard set of options for selecting script's action
# scriptAction is set by install/uninstall
# other actions are handled locally, including quitting from the script
#
# if nonstandard prompts are necessary, duplicate this code in the setup script
# and add the additional options and do not call standardActionPrompt
#
# the reinstall option is permitted only if setup options were previously set
# if the the reinstall action is choosen, the script action is set to INSTALL
# the setup script can then test this to skip further prompts
#
# $1 indicates if there are additional prompts needed during installaiton
# if this parameter is 'MORE_PROMPTS', installaiton does NOT change scriptAction
# if this parameter does not exist, installation WILL change scriptAction to install
# this provides backaward compatibility with scripts written prior to the reinstall logic
#

standardActionPrompt ()
{
    if [ -f "$setupOptionsDir/optionsSet" ]; then
        enableReinstall=true
    else
        enableReinstall=false
    fi
    if [ $# -gt 0 ] && [ $1 == 'MORE_PROMPTS' ]; then
        updateScriptAction=false
    else
        updateScriptAction=true
    fi

    echo
    echo "Available actions:"
    echo "  Install and activate (i)"
    if $enableReinstall ; then
        echo "  Reinstall (r) based on options provided at last install"
    fi
    echo "  Uninstall (u) and restores all files to stock"
    echo "  Quit (q) without further action"
    echo "  Display setup log (s) outputs the last 100 lines of the log"
    if [ ! -z $packageLogFile ]; then
        echo "  Display Log (l) outputs the last 100 lines of the log"
    fi
    echo
    response=''
    while true; do
        /bin/echo -n "Choose an action from the list above: "
        read response
        case $response in
            [iI]*)
                if $updateScriptAction ; then
                    scriptAction='INSTALL'
                fi
                break
                ;;
            [rR]*)
                if $enableReinstall ; then
                    scriptAction='INSTALL'
                    break
                fi
                ;;
            [uU]*)
                scriptAction='UNINSTALL'
                break
                ;;
            [qQ]*)
                exit
                ;;
            [lL]*)
                displayLog $packageLogFile
                ;;
            [sS]*)
                displayLog $setupLogFile
                ;;
            *)
        esac
    done
}

# backupActiveFile makes a copy of the active file in file.orig
# if the original file does not exist, no backup is made
# BUT sets a flag file that will cause restoreFile to delete the active copy
#
# $1 is the full path/file name to be backed up

backupActiveFile ()
{
    backupExisted=false
    baseName=$(basename $1)
    if [ -e "$1.orig" ] || [ -e "$1.NO_ORIG" ]; then
        mayHaveBeenUpdated=true
    elif [ ! -f "$1" ]; then
        touch "$1.NO_ORIG"
    else
        cp "$1" "$1.orig"
        rm -f "$1.NO_ORIG"
    fi
}


# updateActiveFile first backs up the active file
# then copies the replacement (aka source) to the active file location (aka destination)
#
# two variations:
#
# updateActiveFile activeFile
#   an attempt is made to locate the source (replacement)
#   in the version directory or FileSets
#
# updateActiveFile sourceFile activeFile
#   a separate source (replacement) file is specified
#     either as a full path to the actual file
#     or as the basename of a file to be found in the version directory or FileSets
#
# if the update fails, scriptAction is changed to UNINSTALL

updateActiveFile ()
{
    sourceFound=false
    thisFileUpdated=false
    
    sourceFile="$1"

    # separate replacement file specified
    if [ $# == 2 ]; then
        if [ -f "$sourceFile" ]; then
            sourceFound=true
        fi
        destinationFile="$2"
    # use active file for both source and destination
    else
        destinationFile="$1"
    fi
    
    # look for source in FileSets
    if ! $sourceFound ; then
        sourceFile="$(basename "$sourceFile")"
        # found in version directory
        if [ -f "$fileSet/$sourceFile" ]; then
            sourceFile="$fileSet/$sourceFile"
            sourceFound=true
        elif [ -f "$pkgFileSets/$sourceFile" ]; then
            sourceFile="$pkgFileSets/$sourceFile"
            sourceFound=true
        fi
    fi

    if ! $sourceFound; then
        # replacement files are not be needed for some versions
        # if so marked, leave original untouched
        if [ -f "$fileSet/$(basename $sourceFile).USE_ORIGINAL" ]; then
            return
        # if not flagged, this is a fatal error
        else
            logMessage "ERROR: no replacement file for $sourceFile"
            thisFileUpdated=false
            scriptAction='UNINSTALL'
        fi
        return
    fi
    mayHaveBeenUpdated=false
    backupActiveFile "$destinationFile"
    # package may already have been installed - check to see
    needToUpdate=true
    if $mayHaveBeenUpdated ; then
        cmp -s "$sourceFile" "$destinationFile" > /dev/null
        # already updated - no change to active file
        if [ $? == 0 ]; then
            needToUpdate=false
        fi
    fi
    if $needToUpdate ; then
        cp "$sourceFile" "$destinationFile"
        filesUpdated=true
        thisFileUpdated=true
    fi
}


# restoreActiveFile moves the backup copy to the active location
# if the backup copy doesn't exist BUT the NO_ORIG flag is set
# the active copy is deleted to restore the system to stock
# $1 is the active name, the one to be backed up

restoreActiveFile ()
{
    thisFileUpdated=false

    baseName="$(basename $1)"
    if [ -e "$1.orig" ]; then
        mv "$1.orig" "$1"
        rm -f "$1.NO_ORIG"
        filesUpdated=true
        thisFileUpdated=true
    elif [ -f "$1.NO_ORIG" ]; then
        rm -f "$1"
        rm -f "$1.NO_ORIG"
        filesUpdated=true
        thisFileUpdated=true
    fi
}


# checkFileSets validates the file sets used install package modifications
#
# It attempts to create a file set for a new Venus version
#   If the new active files for the new version all match another version
#       the new file set is populated automatically and may be used with no further action
#   If not, new version is marked for manual editing (NO_REPLACEMENT)
#       and scriptAction is set to EXIT so incompatible files are not installed
#
# Replacement files that have no original specify an "alternate original" that is used
# for version comparisons that locate an appropriate replacement

# dummy routine for backward compatibility
# the actual work is now done in-line when CommonResources is sourced

checkFileSets ()
{
    return
}

_checkFileSets ()
{
    # skip checks if uninstalling 
    if [ $scriptAction == 'UNINSTALL' ];then
        return
    fi

    # nothing to do if there is no fileList (version-dependent files)
    if [ ! -f "$pkgFileSets/fileList" ]; then
        return
    fi

    # attempt to create file set if it doesn't exist
    if [ ! -d "$fileSet" ]; then
        logMessage "creating file set for $venusVersion"
        mkdir "$fileSet"
    fi

    local fileList=$(cat "$pkgFileSets/fileList")
    local versionList=($(ls -d "$pkgFileSets"/v*))
    local activeFile=""
    local baseName=""
    local file=""
    
    rm -f "$pkgFileSets/INCOMPLETE"

    for file in $fileList ; do
        baseName=$(basename "$file")
        activeFile=$file        

        if [ -f "$pkgFileSets/$baseName.ALT_ORIG" ]; then
            activeFile=$(cat "$pkgFileSets/$baseName.ALT_ORIG")
        fi
        # package already installed, use .orig file for comparisons
        if [ -f "$activeFile.orig" ]; then
            activeFile="$activeFile.orig"
        fi

        # can't process if no Venus file
        if [ ! -f "$activeFile" ]; then
            logMessage "WARNING $venusVersion $baseName no active file"
            touch "$fileSet/$baseName.NO_ACTIVE_FILE"
            continue
        fi

        # skip checks if replacement file already exists in file set
        # or if there is no replacement file for this version
        if [ -f "$fileSet/$baseName" ] || [ -f "$fileSet/$baseName.USE_ORIGINAL" ]; then
            rm -f "$fileSet/$baseName.NO_REPLACEMENT"
            continue
        fi

        # if an active file exists
        # find the LATEST match in PREVOUS file sets
        if [ ! -z "$activeFile" ]; then
            # look for a match in another version
            matchFound=false
            # search the version list backwards so the first match is the latest one
            local i=${#versionList[@]}
            while (( i > 0 )); do
                (( i-- ))
                otherVersion=$(basename ${versionList[i]})
                versionStringToNumber $otherVersion
                otherVersionDir="$pkgFileSets/$otherVersion"
                otherFile="$pkgFileSets/$otherVersion/$baseName"

                # skip future versions
                if (( $versionNumber > $venusVersionNumber )); then
                    continue
                fi
                # skip symbolic links and nonexistent originals
                if [ ! -f "$otherFile.orig" ] || [ -L "$otherFile.orig" ] ; then
                    continue
                fi
                cmp -s "$activeFile" "$otherFile.orig" > /dev/null
                # files match
                if [ $? -eq 0 ]; then
                    matchFound=true
                    break
                fi
            done
            
            if $matchFound ;then
                ln -s "../$otherVersion/$baseName.orig" "$fileSet/$baseName.orig"
                rm -f "$fileSet/$baseName.NO_ORIG"
                # if other file set contains a replacement file, link to it
                if [ -f "$otherFile" ]; then
                    ln -s "../$otherVersion/$baseName" "$fileSet/$baseName"
                    rm -f "$fileSet/$baseName.NO_REPLACEMENT"
                    rm -f "$fileSet/$baseName.USE_ORIGINAL"
                # if other file set does not contain a replacement, this one will not either
                # this IS permitted and handled in the updateActiveFile and restoreActiveFile functions
                elif [ -f "$otherFile.USE_ORIGINAL" ]; then
                    touch "$fileSet/$baseName.USE_ORIGINAL"
                    rm -f "$fileSet/$baseName.NO_REPLACEMENT"
                fi
            # no match to a previous verison - can't create file set automatically
            # but copy original file to aid manual editing
            else
                logMessage "ERROR $venusVersion $baseName no replacement file"
                cp "$activeFile" "$fileSet/$baseName.orig"
                touch "$fileSet/$baseName.NO_REPLACEMENT"
                touch "$fileSet/INCOMPLETE"
            fi
        fi
    done

    if [ -f "$fileSet/INCOMPLETE" ]; then
        logMessage "ERROR: incomplete file set for $venusVersion - can't continue"
        exit
    fi
}


# determine how startup script should exit based on $scriptAction and other flags
# may EXIT or REBOOT within the function - DOES NOT RETURN TO CALLER

endScript ()
{
    if $restartGui $$ !rebootNeeded ; then
        logMessage "restarting GUI"
        svc -t /service/gui
    fi

    if [ $scriptAction == 'INSTALL' ] ; then
        # indicate installation was successful, so reinstalls can use the existing options in the future
        touch "$setupOptionsDir/optionsSet"

        # set up reinstallMods to run this script again after a VenusOS update
        if [ ! -f "$reinstallScriptsList" ] || [ $(grep -c "$fullScriptName" "$reinstallScriptsList") == 0 ]; then
            logMessage "adding $shortScriptName" to $(basename "$reinstallScriptsList")
            echo "$fullScriptName" "$reinstallParam" >> "$reinstallScriptsList"
        fi
        if [ ! -f "$rcLocal" ]; then
            logMessage "creating $rcLocal"
            cat "$setupHelperDir/rcS.local" > "$rcLocal"
            chmod +x "$rcLocal"
        elif  [ $(grep -c "SetupHelper" "$rcLocal") == 0 ]; then
            logMessage "adding SetupHelper reinstall script to $rcLocal"
            sed -e '1d' "$setupHelperDir/rcS.local" >> $rcLocal
        # update reinstall call to nohup background
        elif [ $(grep -c "nohup /data/SetupHelper" "$rcLocal") == 0 ]; then
            logMessage "updating SetupHelper reinstall script in $rcLocal"
            sed -i -e 's?/data/SetupHelper?nohup /data/SetupHelper?' -e 's?reinstallMods?reinstallMods > /dev/null \&?' "$rcLocal"
        fi

        # installed flag is removed if script needs to run again
        if $runAgain ; then
          logMessage "script will run again at startup"
            rm -f "$installedFlag"
        # otherwise installed flag is set so script won't be run again at boot
        else
            cp "$scriptDir/version" "$installedFlag"
      fi

        # add package to packageList if not already there and the GitHub paths have been specified
        if [ ! -z $packageGitHubUser ] && [ ! -z $packageGitHubBranch ]; then
            # move from previous locaiton
            oldPackageListFile="$setupOptionsRoot/SetupHelper/packageList"
            if [ -f "$oldPackageListFile" ]; then
                mv "$oldPackageListFile" "$packageListFile"
            fi

            if  [ ! -f "$packageListFile" ] || [ $(grep -c "^$packageName\s" "$packageListFile") == 0 ]; then
                logMessage "adding $packageName to SetupHelper package list"
                echo "$packageName $packageGitHubUser $packageGitHubBranch" >> "$packageListFile"
            fi
        fi

        # update package version for the gui - takes time so do in background
        nohup "/data/SetupHelper/updatePackageVersions" > /dev/null &


    elif [ $scriptAction == 'UNINSTALL' ] ; then
        # remove this script from reinstallScriptsList to prevent further calls during boot
        if [ -f "$reinstallScriptsList" ] && [ ! $(grep -c "$fullScriptName" "$reinstallScriptsList") == 0 ]; then
            logMessage removing "$shortScriptName" from $(basename "$reinstallScriptsList")    
            sed "\:$fullScriptName:d" "$reinstallScriptsList" > "$scriptDir/tmp"
            mv "$scriptDir/tmp" "$reinstallScriptsList"
        fi

        # clean up only - flag not used since package is being removed
        rm -f "$installedFlag"
        
        # update package version for the gui - takes time so do in background
        nohup "/data/SetupHelper/updatePackageVersions" > /dev/null &
    fi

    # this script was called from reinstallMods
    # set exit code based on actual code
    if $runningAtBoot ; then
        if $rebootNeeded ; then
            logMessage "reboot pending"
            exit $exitReboot
        else
            logMessage "completed"
            exit $exitSuccess
        fi

    # this script was run manually
    else
        # if reboot needed ask user if it should be done now
        if $rebootNeeded ; then
            if $deferReboot ; then
                exit $exitReboot
            else
                yesNoPrompt "Reboot system now (y) or issue a reboot manually later (n): "
                if $yesResponse ; then
                    echo "rebooting ..."
                    reboot
                else
                    echo "system must be rebooted to finish installation and activate components"
                fi
            fi

        elif $runAgain ; then
            echo "$shortScriptName NOT completed"
            echo "  run it again manually to finish"
            echo "  or reboot the system to finish automatically"
            exit $exitSuccess
        else
            logMessage "completed"
            exit $exitSuccess
        fi
    fi
}

######## this code is executed in-line when CommonResources is sourced

# check for reinstall parameter
# set $scriptAction to control work following the source command
# if "force" is also provided on the command line, then the installedFlag is not checked
# installedFlag contains the installed version (if any)
# it is compared to the version file in the package directory
#  if installedFlag is missing or contents are different, the installation will proceed
# if the two versions matched, there is no need to reinstall the package
# we assume a reinstall is always run without benefit of a console (runningAtBoot will be true)
# so there will be no prompts and all actions will be automatic
#
# "deferReboot" signals that endScript should not prompt for a user reboot, but return exitReboot
# This is used by the manual package install called from SetupHelper setup script
#
# "uninstall" causes the package to be uninstalled silently
#
# command line parameters may appear in any order

# make sure rootfs is mounted R/W
if [ -f /opt/victronenergy/swupdate-scripts/remount-rw.sh ]; then
    /opt/victronenergy/swupdate-scripts/remount-rw.sh
fi

reinstall=false
force=false
deferReboot=false
while [ $# -gt 0 ]; do
        case $1 in
            $reinstallParam)
                reinstall=true
                ;;
            "force")
                force=true
                ;;
            "deferReboot")
                deferReboot=true
                ;;
            "uninstall")
                scriptAction='UNINSTALL'
                logToConsole=false
                ;;
            *)
        esac
    shift
done

if $reinstall ; then
    if $force ; then
        scriptAction='INSTALL'
    elif [ ! -f "$installedFlag" ]; then
        scriptAction='INSTALL'
    else
        # compare installed version with the one in the package directory
        # nothing to do
        # if they are not the same, continue with install
        iVer=$(cat "$installedFlag")
        pVer=$(cat "$scriptDir/version")
        if [ "$iVer" = "$pVer" ]; then
            exit
        else
            scriptAction='INSTALL'
        fi
    fi
    runningAtBoot=true
    logToConsole=false

# not a reinstall, continue with MANUAL installation
else
    runningAtBoot=false
fi

# initialze integer version number for venus version
# used below and in _checkFileSets
versionStringToNumber $venusVersion
venusVersionNumber=$versionNumber

# check to see if package is compatible with this Venus version
notCompatible=false
if [ -f "$scriptDir/obsoleteVersion" ]; then
    versionStringToNumber $(cat "$scriptDir/obsoleteVersion")
    obsoleteVersion=$versionNumber

    if (( $venusVersionNumber >= $obsoleteVersion )); then
        notCompatible=true
    fi
fi

if $notCompatible ; then
    logMessage "$packageName not compatible with Venus $venusVersion"
    scriptAction='UNINSTALL'
else
    if [ ! -d "$setupOptionsRoot" ]; then
        logMessage "creating root setup options directory $setupOptionsRoot"
        mkdir $setupOptionsRoot
    fi

    if [ ! -d "$setupOptionsDir" ]; then
        logMessage "creating package options directory to $setupOptionsDir"
        mkdir $setupOptionsDir
    fi
fi

# if forcing an uninstall, skip file set checks
if [ $scriptAction != 'UNINSTALL' ]; then
    _checkFileSets
fi