LocalFunctions

#!/bin/bash (source)

function ProxySudo() {
    sudo env http_proxy="$http_proxy" \
             https_proxy="$https_proxy" \
             HTTP_PROXY="$HTTP_PROXY" \
             HTTPS_PROXY="$HTTPS_PROXY" \
             SUDO_USER="" \
             PATH="$PATH" \
             "$@"
}

function BatchRun() {
    local keystrokes="$1"
    shift
    if [ "$batch" = "yes" ]
    then
        echo -en "$keystrokes" | "$@"
        local x=$?
        return $x
    else
        "$@"
        return $?
    fi
}

function GetPackageVersion() {
    ls "$BUILDDIR/Programs/$1/" 2> /dev/null | grep -v "Settings\|Current\|Variable"
}

function MoveSettingsFile() {
    local settingsFile="$1"
    local programName="$2"
    local programVersion=$(GetPackageVersion $programName)
    if [ -z "$programVersion" ]
    then
        return
    fi
    if [ -e "$BUILDDIR/System/Settings/$settingsFile" -a ! -h "$BUILDDIR/System/Settings/$settingsFile" ]
    then
        sudo mkdir -p "$BUILDDIR/Programs/$programName/Settings"
        sudo mkdir -p "$BUILDDIR/Programs/$programName/$programVersion/Resources/Defaults/Settings"
        sudo cp -v "$BUILDDIR/System/Settings/$settingsFile" "$BUILDDIR/Programs/$programName/Settings"
        sudo mv -v "$BUILDDIR/System/Settings/$settingsFile" "$BUILDDIR/Programs/$programName/$programVersion/Resources/Defaults/Settings"
        sudo ln -v -s "/Programs/$programName/Settings/$settingsFile" "$BUILDDIR/System/Settings/$settingsFile"
    fi
}

function MoveFile() {
    local filename="$1"
    local programName="$2"
    local programVersion=$(GetPackageVersion $programName)
    if [ -z "$programVersion" ]
    then
        return
    fi
    if [ -e "$BUILDDIR/usr/$filename" -a ! -h "$BUILDDIR/usr/$filename" ]
    then
        sudo mv -v "$BUILDDIR/usr/$filename" "$BUILDDIR/Programs/$programName/$programVersion/$filename"
        sudo ln -v -s "/Programs/$programName/$programVersion/$filename" "$BUILDDIR/usr/$filename"
    fi
}

function IsBlacklisted() {
    # Returns 0 if not blacklisted, 1 if blacklisted, 2 if package is currently commented out
    local appName="$1"
    # Blacklist packages from JHALFS that we do not intend to ship
    [ "$appName" = "BootScripts-ALFS" ] && echo "1" || {
       # Do not attempt to add back packages that have been commented out from Packages-List.
       grep -q "^#[ ]*${appName}$" "$WORKDIR/BuildLiveCD/Data/Packages-List-"* && echo "2" || echo "0"
    }
}

function RemoveFromPackageList() {
    local packageList="$WORKDIR/BuildLiveCD/Data/Packages-List-${1}"
    local packageName="$2"
    cat "${packageList}" | grep -v "^${packageName}$" > "${packageList}.new" && mv "${packageList}.new" "${packageList}"
}

function CreatePackageList() {
    local packageList="$WORKDIR/BuildLiveCD/Data/Packages-List-${1}"
    if [ -e "$packageList" ] && [ $(stat -c "%s" "$packageList") -gt 0 ]
    then
        return
    fi

    pushd "$BUILDDIR/Programs" > /dev/null
    for appName in *
    do
        result="$(IsBlacklisted $appName)"
        [ "$result" = "1" ] && continue
        if [ "$result" = "2" ]
        then
            grep -q "^#[ ]*${appName}$" "$packageList" && echo "# $appName" >> "$packageList"
            continue
        fi

        # If appName is already in any other existing list, do not add it to $packageList
        local skipPackage="false"
        for existingPackageList in "$WORKDIR/BuildLiveCD/Data/"*
        do
            if [ $(basename "$existingPackageList") != $(basename "$packageList") ]
            then
                if grep -q "^${appName}$" "$existingPackageList"
                then
                    skipPackage="true"
                    break
                fi
            fi
        done
        [ "$skipPackage" = "false" ] && echo "$appName" >> "$packageList"
    done
    popd > /dev/null
}

function GetRecipeDir() {
    local appName="$1"
    local appVersion="$2"
    local appMajorVersion=$(echo "$appVersion" | cut -d. -f1)

    # Special case Eudev
    if [ "$appName" = "Eudev" ]
    then InChroot GuessLatest "/Data/Compile/Git/Recipes/trunk/Udev/"*
    else InChroot GuessLatest "/Data/Compile/Git/Recipes/trunk/${appMajorVersion}"*
    fi
}

function SetExecutableBit() {
    local filenames="$@"
    for fname in "${filenames[@]}"
    do
        [ -e "$fname" ] || continue
        [ -x "$fname" ] || sudo chmod +x "$fname"
    done
}

function PopulateResources() {
    local appName="$1"
    local appVersion="$2"
    local output="$1/$2"

    local recipedir=$(GetRecipeDir "$appName" "$appVersion")
    local input="${BUILDDIR}${recipedir}"
    [ -z "$recipedir" ] && return

    sudo mkdir -p "$output/Resources"
    sudo rm -rf -- "$output/Resources/SettingsBackup"
    if [ -d "$appName/Settings" ]
    then
        # Make sure that any tweaked settings are carried over
        sudo mkdir -p "$output/Resources/Defaults"
        sudo cp -a "$appName/Settings" "$output/Resources/Defaults/"
    fi
    for resource in Tasks PostInstall Description
    do
        if [ ! -e "$output/Resources/$resource" ] && [ -e "$input/Resources/$resource" ]
        then
            sudo cp -a "$input/Resources/$resource" "$output/Resources/$resource"
        fi
    done
    SetExecutableBit "$output/Resources/PostInstall"
    SetExecutableBit "$output/Resources/Tasks/"*
    if [ ! -e "$output/Resources/Dependencies" ]
    then
        InChroot Dependencies "$appName" 2> /dev/null | sudo tee -a "$output/Resources/Dependencies" > /dev/null
    fi
    if [ ! -e "$output/Resources/Architecture" ]
    then
        InChroot uname -m | sudo tee -a "$output/Resources/Architecture" > /dev/null
    fi
    find "$output/Resources" -type d -name ".svn" 2> /dev/null | xargs sudo rm -rf
    find "$output/Resources" -type d -name ".git" 2> /dev/null | xargs sudo rm -rf
}

function CreateGoboPackage() {
    local appName="$1"
    if [ ! -d "$appName/" -o "$(IsBlacklisted $(basename $appName))" = "yes" ]
    then
        return
    fi
    local appVersions=( $(ls "$appName/" 2> /dev/null | grep -v "Settings\|Current\|Variable" | sort -n) )
    for appVersion in ${appVersions[@]}
    do
        local revision=$(cat "$appName/$appVersion/Resources/Revision" 2> /dev/null || echo "r0")
        local packageName="$PACKAGEDIR/${appName}--${appVersion}-${revision}--$(uname -m).tar.bz2"
        local hasModifications=$(find "$appName/Settings" "$appName/$appVersion" -newer "$packageName" 2> /dev/null | wc -l)
        local depFile="$appName/$appVersion/Resources/Dependencies"

        [ -e "$depFile" ] && [ $(stat -c "%s" "$depFile") -lt 2 ] && rm -f "$depfile"
        if [ ! -e "$packageName" -o $hasModifications -gt 0 -o ! -e "$depFile" ]
        then
            echo "Creating package for $appName $appVersion"
            PopulateResources "$appName" "$appVersion"
            sudo find "$appName/$appVersion" -type d -empty | grep -v "Settings/\|Unmanaged/" | while read line
            do 
                sudo rmdir -p $line >& /dev/null
            done
            sudo tar cjf "$packageName" "$appName/$appVersion"
        fi
    done
    # Create the Current link
    [ ! -e "$appName/Current" ] && sudo ln -s "$appVersion" "$appName/Current"
}

function CreateISO() {
    local startStage="$1"
    local endStage="$2"
    pushd "$WORKDIR/ISO" > /dev/null
    (
        export livecdDataDir="$WORKDIR/BuildLiveCD/Data"
        export livecdUseSystemIndex="true"
        export PATH="$PATH:$WORKDIR/BuildLiveCD/bin"
        if [ -e "$HOME/Programs/Rootless/Current/bin/StartRootless" ]
        then source "$HOME/Programs/Rootless/Current/bin/StartRootless"
        fi
        ProxySudo "$WORKDIR/BuildLiveCD/bin/CompressAndBuildISO" $startStage $endStage
    )
    popd > /dev/null
}

function UpdateProgramsDu() {
    local duFile="$1"
    if [ $(basename "$PWD") != "Programs" ]
    then
        echo "Error: UpdateProgramsDu called with invalid \$PWD (should be /path/to/Programs)"
        return
    fi
    for packageName in "$PACKAGEDIR/"*.tar.bz2
    do
        #$appName--$appVersion-r0--$(uname -m).tar.bz2"
        if [ "$packageName" -nt "$duFile" ]
        then
            local appName=$(echo "$(basename $packageName)" | sed 's,\(.*\)--\(.*\)--\(.*\).*,\1,g')
            local duData="$(sudo du -s ./$appName)"
            echo "Updating Programs_du entry for package $appName"
            sudo sed -i~ "s,.* \./$appName$,$duData,g" "$duFile"
        fi
    done
}

function UpdateProgramsDescriptions() {
    local descriptionsFile="$1"
    if [ $(basename "$PWD") != "Programs" ]
    then
        echo "Error: UpdateProgramsDescriptions called with invalid \$PWD (should be /path/to/Programs)"
        return
    fi
    for appName in *
    do
        grep -q "^${appName} ::" "$descriptionsFile" && continue
        local appDesc="$PWD/$appName/Current/Resources/Description"
        if [ -e "$appDesc" ]
        then
            local summary=$(grep "^\[Summary\]" "$appDesc" | cut -d" " -f2-)
            echo "${appName} :: ${summary}" | sudo tee -a "$descriptionsFile" > /dev/null
        fi
    done
}

function InChroot() {
    sudo mount -o bind /proc "$BUILDDIR/proc"
    sudo mount -o bind /dev "$BUILDDIR/dev"
    cat << EOF > "$BUILDDIR/tmp/in_chroot.sh"
#!/bin/bash
#export NO_UNIONFS=yes
export PATH=/bin:/sbin:/usr/bin:/usr/sbin
export GIT_SSL_NO_VERIFY=1
export SUDO_OK=1
export goboTemp=/tmp

if [ -e "/System/Environment/Cache" ]
then
    # Loading environment variables is vital so that XML catalogs can be found
    export PATH="$PATH:/Programs/Scripts/Current/bin"
    source "/System/Environment/Cache"
fi

rm -f "/etc/mtab"
touch "/etc/mtab"
$@
ret=$?
sync; sleep 1; exit \$ret
EOF
    chmod +x "$BUILDDIR/tmp/in_chroot.sh"
    ProxySudo /usr/sbin/chroot "$BUILDDIR" /tmp/in_chroot.sh
    ret=$?
    rm -f "$BUILDDIR/tmp/in_chroot.sh"
    sudo umount "$BUILDDIR/dev"
    sudo umount "$BUILDDIR/proc"
    return $ret
}

function InstallGoboPackage() {
    local appName="$1"
    local snapshotDir="$(date +%Y%m%d)-GIT"
    local packageDir="$BUILDDIR/Programs/$appName/$snapshotDir"
    sudo mkdir -p "$packageDir"
    sudo cp -a "$WORKDIR/ISO/LocalGit/tools/$appName/"* "$packageDir/"
    sudo ln -fs "$snapshotDir" "$BUILDDIR/Programs/$appName/Current"
    sudo rm -rf "$packageDir/.git"
    sudo cp -a "$packageDir/Resources/Defaults/Settings" "$packageDir/.."
    InChroot make -C "/Programs/$appName/$snapshotDir"
    InChroot /tools/bin/SymlinkProgram -c overwrite $appName
}

function SanityCheckProgram() {
    local programName="$1"
    local programVersion=$(GetPackageVersion $programName)
    local retval=0
    pushd "$BUILDDIR/Programs" > /dev/null
    if [ -d "${programName}/${programVersion}/etc" ]
    then
        echo "*** Error: $programName/$programVersion has an etc/ directory"
        retval=1
    fi
    if [ -d "${programName}/${programVersion}/man" ]
    then
        echo "*** Error: $programName/$programVersion has a misplaced man/ directory"
        retval=1
    fi
    if [ -d "${programName}/${programVersion}/Shared" ]
    then
        echo "*** Error: $programName/$programVersion has a legacy Shared directory"
        retval=1
    fi
    popd > /dev/null
    return $retval
}