#!/usr/bin/env bash
# ============================================================================ #
# winez-create-prefix (C) GPL3 Mohammed Asif Ali Rizvan <fast.rizwaan@gmail.com>
# URL: https://github.com/fastrizwaan/WineZGUI
# Creates Application shortcut when called from winezgui.
# ============================================================================ #

if [ -f "${DATADIR}/winezgui-source" ]; then
     source "${DATADIR}/winezgui-source"
else
     source "${WINEZGUI_SCRIPTS}/winezgui-source"
fi

# Load file with dbug function
SOURCE "winezgui-dbug"
dbug "I: $(basename ${0}): Launched ${FUNCNAME[0]}"
HEADER="$(basename ${0})"

    
  SOURCE "script-check-variables-loaded-or-not"
  script-check-variables-loaded-or-not

 echo "*-*-*-*-*-*-*-*-*-*-*-*"
  echo "APPVERSION =$APPVERSION"
  echo "* * * * * * * * * * * *"
echo "EXE file given = ${1}"
echo "${PREFIXDIR} = ${SELECTED_PREFIX}"
# Must be called from winezgui-recreate-prefix-scripts
export PREFIXDIR="${SELECTED_PREFIX}"


dbug "I: ${HEADER}: Starting WineZGUI Create Script ($0)"

# Exit if no arguments are provided
if [ -z "${1}" ]; then
     dbug "I: ${HEADER}: No Arguments... bye";
fi
#unset WINEPREFIX # for WINEVER
#export APPNAME=WineZGUI
#export APPLICATIONSDIR="$(realpath -m ~/.local/share/applications)"
#export UPDATE_ICON_CACHE="gtk-update-icon-cache -f -t ~/.local/share/icons 2>/dev/null"
#export UPDATE_DESKTOP_DATABASE="update-desktop-database 2>/dev/null"
#export WINE_CMD="$(which wine)"
#export WINEVER="$(wine --version|cut -f1 -d " ")"
export WTRICKS_CMD=$(which winetricks)
export TEMPDIR="${WINEZGUIDIR}/tmp"
export EXIFTOOL=$(which exiftool)

# These values will be assigned by Setup using sed command
# Post install ${PREFIX}/bin/winezgui-create-prefix file will be different
#export APPVERSION="git"
#export APP_WITH_VER="${APPNAME}-${APPVERSION}"
#export INSTALL_TYPE="system"
#export WINEZGUIDIR="$(realpath -m ~/.local/share/winezgui)"
#export FLATPAK_NAME=${FLATPAK_ID}

#export DATADIR=/usr/share/winezgui    # /usr will be replaced by prefix

echo "
APPVERSION  = $APPVERSION
APP_WITH_VER= $APP_WITH_VER
INSTALL_TYPE= $INSTALL_TYPE
WINEZGUIDIR = $WINEZGUIDIR
FLATPAK_NAME= $FLATPAK_NAME
DATADIR     = $DATADIR
APPNAME     = $APPNAME 
APPLICATIONSDIR=$APPLICATIONSDIR
UPDATE_ICON_CACHE = $UPDATE_ICON_CACHE
UPDATE_DESKTOP_DATABASE = $UPDATE_DESKTOP_DATABASE
WINE_CMD    = $WINE_CMD
TEMPDIR     = $TEMPDIR
EXIFTOOL    = $EXIFTOOL
WINEVER     = $WINEVER
WTRICKS_CMD = $WTRICKS_CMD
TEMPDIR     = $TEMPDIR
SYSTEM_WINE = ${SYSTEM_WINE}

"

# Where to install .desktop shortcuts?
# for system install (./setup -i) use ~/.local/share/applications/winezgui
if [ "${INSTALL_TYPE}" = "system" ]; then
     #DEXSKTOPDIR="$(realpath -m ${APPLICATIONSDIR}/winezgui)"
     SHORTCUT_PREFIX="system_winezgui"
     
else
     # for flatpak create subdirectory with flatpakname
     #DEXSKTOPDIR="$(realpath -m ${APPLICATIONSDIR}/winezgui/${FLATPAK_NAME})"
     SHORTCUT_PREFIX="${FLATPAK_NAME}"
fi
#export DEXSKTOPDIR 
export SHORTCUT_PREFIX
# winezgui backup file extension
export BKP_EXT="wzt"

dbug "I: ${HEADER}: Checking if an exe file is provided"

export EXE_FILE=$(realpath -m "$1")
export EXE_NAME=$(basename "${EXE_FILE}")
export EXE_PATH=$(dirname  "${EXE_FILE}")
export EXE_NOSP=$(echo ${EXE_NAME}|tr " " "_");
export EXE_LESS=$(echo ${EXE_NOSP}|sed "s/\.[Ee][Xx][Ee]//"|sed "s/\.[Mm][Ss][Ii]//")
export EXE_EXT="${EXE_FILE##*.}"
export PREFIXES_DIR="${WINEZGUIDIR}/Prefixes"
export SINGLE_PREFIX_DIR="${PREFIXES_DIR}/WineZGUI-Single-Prefix"
export RUNNERS_DIR="${WINEZGUIDIR}/Runners"


echo "
export EXE_FILE=$(realpath -m "$1")
export EXE_NAME=$(basename "${EXE_FILE}")
export EXE_PATH=$(dirname  "${EXE_FILE}")
export EXE_NOSP=$(echo ${EXE_NAME}|tr " " "_");
export EXE_LESS=$(echo ${EXE_NOSP}|sed "s/\.[Ee][Xx][Ee]//"|sed "s/\.[Mm][Ss][Ii]//")
export EXE_EXT="${EXE_FILE##*.}"
export PREFIXES_DIR="${WINEZGUIDIR}/Prefixes"
export SINGLE_PREFIX_DIR="${PREFIXES_DIR}/WineZGUI-Single-Prefix"
export RUNNERS_DIR="${WINEZGUIDIR}/Runners" 
"

# This should be existing PREFIXNAME
export PREFIXNAME="$(basename ${PREFIXDIR})"
export WINEZGUI_SCRIPTS="${PREFIXDIR}/winezgui-scripts"
# Files
export INFOFILE="${PREFIXDIR}/Info.yml"
export ICONFILE="${PREFIXDIR}/${EXE_LESS}.png"
export SCRIPTFILE="${PREFIXDIR}/${EXE_LESS}.sh"
export DESKTOPFILE="${PREFIXDIR}/${EXE_LESS}.desktop"

ICON="${ICONFILE}"

# If argument is not an exe file, then quit
# Make it small case to compare
EXTENSION="$(echo ${EXE_EXT}|tr A-Z a-z)"
EXE="exe"
MSI="msi"

echo "
EXTENSION="$(echo ${EXE_EXT}|tr A-Z a-z)"
EXE="exe"
MSI="msi"

"


# If exe or msi file is not given, we can't create script for other files
if [ "${EXTENSION}" != "${EXE}" ] && [ "${EXTENSION}" != "${MSI}" ]; then
     echo "E: Create Prefix: \"${EXE_NAME}\" is not an ${EXE} or ${MSI} file"
     dbug "I: ${HEADER}: Please, give an ${EXE} or ${MSI} file as argument"
     dbug "I: Usage: ${0} path/to/app.exe "
     exit 1
fi

# Clear variables
unset EXTENSION
unset EXE
unset MSI

# Create required directories
mkdir -p  "${PREFIXES_DIR}" && \
dbug "I: ${HEADER}: Created directory ${PREFIXES_DIR}"

#mkdir -p  "${DEXSKTOPDIR}" && \
#dbug "I: ${HEADER}: Created directory ${DEXSKTOPDIR}"


# Start processing submitted exe file
dbug "I: ${HEADER}: Preparing prefix for exe file"

# We are switching to Template based system, where user can install all
# winetricks verbs and save as a template. default will be the link to using
# Template.

export TEMPLATE=$(grep template ${SETTINGS_FILE}|cut -f2 -d ":")
export TEMPLATE_NAME=$(basename ${TEMPLATE})
export USE_SINGLE_PREFIX=$(grep "single-prefix:" ${SETTINGS_FILE}|cut -f2 -d ":")

# Copy the Default Prefix linked wine to avoid showing dialog
if [ ! -d "${PREFIXDIR}" ]; then
     echo "I: ${HEADER}: ${PREFIXNAME} not found, copying...${TEMPLATE_NAME}"

     (cp -rf "${TEMPLATE}" "${PREFIXDIR}" )| \
     ${ZENITY_CMD}  --progress --pulsate --auto-close --width=500 \
     --title="${APP_WITH_VER} - Create Game Prefix" \
     --text="Copying template <b>${TEMPLATE_NAME}</b> to <b>${PREFIXNAME}!</b>"

fi


# Ask user whether to use existing name and icon
# unset TITLE TEXT
# TITLE="Recreate All Scripts"
# TEXT="Use existing Name and Icon?"
# ${ZENITY_CMD} --question --title "${TITLE}" --text "$TEXT"

# ANSWER=$?
# unset TITLE TEXT

if [ -z "${PROGNAME}" ] ; then
     # Extract icon and convert it to several png files of diferent quality,
     # Create a temporary Directory to extract icon from the exe file
     dbug "I: ${HEADER}: Icon: Extraction from ${EXE_NAME}"
     mkdir -p ${TEMPDIR} && \
     dbug "I: ${HEADER}: Icon: Created directory ${TEMPDIR}"
     cd ${TEMPDIR}

     # wrestool extracts ico file from EXE
     ${WRESTOOL_CMD} -x -t 14 "${EXE_FILE}" > "${TEMPDIR}/${EXE_LESS}.ico" 2> /dev/null && \
     dbug "I: ${HEADER}: Icon: Wrestool executed"

     # Only try to extract Icon when Icon is Found in the EXE
     # icotool extracts all png files from ico files
     # Select and copy the best png image file by sorting using ls -S1.
     ${ICOTOOL_CMD} -x "${TEMPDIR}/${EXE_LESS}.ico" 2>/dev/null && \
     dbug "I: ${HEADER}: Icotool: Extracting png files from" "${EXE_LESS}.ico" && \
     cp $(ls -S -1 ${TEMPDIR}/${EXE_LESS}*.png  | head -n 1) ${ICON} && \
     dbug "I: ${HEADER}: Icon: Copied successfully..." && WARN="false"

     # If icon could not be copied, warn the user
     if [ "${WARN}" != "false" ]; then
          dbug "I: ${HEADER}: Icon could not be copied..." \
               "use \"Change Icon...\" option"
     fi

     # Cleanup tempdir and clear variable
     unset WARN

     #remove tmp directory after copying icon png
     rm -rf "${TEMPDIR}" && \
     dbug "I: ${HEADER}: Icon: Cleanup ${TEMPDIR}"



     # Prepare Desktop file
     APP_CATEGORY="Game"
     dbug "I: ${HEADER}: Setting Category - ${APP_CATEGORY}"

     # Create Desktop Shortcut
     echo '`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`'
     echo "EXE FILE = ${EXE_FILE}"
     echo "EXIFTOOL = ${EXIFTOOL}"
     dbug "I: ${HEADER}: Name: Program Name Detection from exe file"
     # Automatically set name, read from pe file, if not found use exe name
     PRODUCT=$(${EXIFTOOL} "${EXE_FILE}"|grep -i "product name"|cut -f2 -d ":" \
                                                            |sed "s/^ //")
     # if language is not english inside exe name, or product is "", use exe name
     if [ $(echo ${PRODUCT} | grep -aEv [a-zA-Z] ) ] || [ -z "${PRODUCT}" ]; then
          unset PRODUCT
          unset PROGNAME
          # PROGNAME=$(echo "${EXE_NAME} (${APP_WITH_VER})"|sed "s/\.[mM][Ss][Ii]//g"\

          PROGNAME=$(echo "${EXE_NAME}"                  |sed "s/\.[mM][Ss][Ii]//g"\
                                                       |sed "s/\.[eE][Xx][Ee]//g");
          dbug "I: ${HEADER}: Name: Product Name not found, using exe name"
     else
          #PROGNAME=$(echo "${PRODUCT} (${APP_WITH_VER})");
          PROGNAME=$(echo "${PRODUCT}");
          dbug "I: ${HEADER}: Name: Product Name found: \"${PRODUCT}\""
     fi
fi



echo "-----------------------------------------------------------"
     echo "PROGNAME=$PROGNAME"
     echo "ICON=$ICON"
     echo "APP_CATEGORY=$APP_CATEGORY"
echo "-----------------------------------------------------------"

# Generate Sha256sum for the exefile if CHECKSUM not found
# Just inform user that CHECKSUM already exist, using that
if   [ -z "${CHECKSUM}" ]   ; then
       CHECKSUM=$(sha256sum "${EXE_FILE}"|cut -f1 -d " ")
elif [ ! -z "${CHECKSUM}" ] ; then
       echo "Using existing CHECKSUM=$CHECKSUM"
fi

dbug "I: ${HEADER}: Sha256sum: ${CHECKSUM}"

# Create Launch Script for the provided EXE file
# ------------------------------------------------
# Launch script needs
dbug "I: ${HEADER}: Script: Launch Script Creation..."
dbug "I: ${HEADER}: Script: Copying required script modules"

# Check PREFIXDIR is writable or not
if ! [ -w "${PREFIXDIR}" ] ; then
       echo "E: Create Prefix: Script: Cannot write to ${PREFIXDIR}"
       echo "W: Create Prefix: Script: Aborting!"
       exit 1
fi

#Create scripts directory inside prefixdir
mkdir -p "${WINEZGUI_SCRIPTS}"

# copy the scripts from datadir to winezgui-scripts directory inside prefixdir
SAVEIFS=${IFS}
IFS=$(echo -en "\n\b")
for SCRIPT in $(ls ${DATADIR}); do

   cp -f "${DATADIR}/${SCRIPT}" "${WINEZGUI_SCRIPTS}" 2>/dev/null || \
   (echo "Error copying modules" ; exit 1)
done
IFS=${SAVEIFS}

# # === = = = = = = = Recreate Prefix script with Runner 
# # If Infofile exists (old scripts) and Runner: is not found add it
# if [ -f ${INFOFILE} ]; then
#    grep "Runner:" "${INFOFILE}" || echo "Runner:${RUNNER}" >> "${INFOFILE}"
#    export RUNNER=$(grep -i "Runner:" ${INFOFILE}|cut -f2 -d ":")
# fi

# # If Runner is empty in Infofile, then get Runner info from Settings.yml
# if [ -z "${RUNNER}" ]; then
#      if [ -f "${SETTINGS_FILE}" ]; then
#           export RUNNER=$(grep "runner:" ${SETTINGS_FILE}|cut -f2 -d ":")
#      fi
# fi  

# # If runner is not specified in Infofile or Settings.yml then use wine
# if [ -z "${RUNNER}" ]; then
#     export RUNNER="$(which wine)"
# fi

# # if runner is from local install /app/bin/wine or /usr/bin/wine etc.
# # set RUNNER_NAME
# if [ "${RUNNER}" = "$(which wine)" ]; then
#      export RUNNER_NAME="System Default"
# else #Get directory name containing bin/wine
#      export RUNNER_NAME=$(basename $(dirname $(dirname ${RUNNER})))
# fi
# # Runner = wine command in a different directory
# export WINE_CMD="${RUNNER}"
# #/ === = = = = = = = Recreate Prefix script with Runner 
# Set WINE_CMD, WINEVER, RUNNER variables
SOURCE "winezgui-set-wine_cmd-runner-commands"
winezgui-set-wine_cmd-runner-commands

echo "winezgui-recreate-prefix-script ----------------------------- RUNNER:${RUNNER}"
echo "winezgui-recreate-prefix-script ----------------------------- WINE_CMD:${WINE_CMD}"
echo "winezgui-recreate-prefix-script ----------------------------- RUNNER_NAME:${RUNNER_NAME}"
# Clean up variables
unset SCRIPT_MODULES
unset SCRIPT

# need variables from this script
echo "
#!/bin/bash
export PATH=\"${PATH}\"       
export APPNAME=\"${APPNAME}\"
export FLATPAK_NAME=\"${FLATPAK_NAME}\"
export APPVERSION=\"${APPVERSION}\"
export APP_WITH_VER=\"${APPNAME}-${APPVERSION}\"
export WINEVER=\"${WINEVER}\"
export WINEARCH=\"${WINEARCH}\"
export PROGNAME=\"${PROGNAME}\"
export INSTALL_TYPE=\"\"${INSTALL_TYPE}\"\"
export WINEZGUIDIR=\"${WINEZGUIDIR}\"
export PREFIXES_DIR=\"${WINEZGUIDIR}/Prefixes\"
export RUNNERS_DIR=\"${WINEZGUIDIR}/Runners\"
export EXE_FILE=\"${EXE_FILE}\"
export EXE_NAME=\"${EXE_NAME}\"
export CHECKSUM=\"${CHECKSUM}\"
export EXE_PATH=\"${EXE_PATH}\"
export EXE_NOSP=\"${EXE_NOSP}\"
export EXE_LESS=\"${EXE_LESS}\"
export EXE_EXT=\"${EXE_FILE##*.}\"
export PREFIXDIR=\"${PREFIXDIR}\"
export PREFIXNAME=\"$(basename ${PREFIXDIR})\"
export WINEPREFIX=\"${PREFIXDIR}\"
export APPLICATIONSDIR=\"${APPLICATIONSDIR}\"
export WINEZGUI_SCRIPTS=\"${WINEZGUI_SCRIPTS}\"
export DATADIR=\"${DATADIR}\"
export SETTINGS_FILE=\"${WINEZGUIDIR}/Settings.yml\"

#export DEXSKTOPDIR=\"${DEXSKTOPDIR}\"
export SHORTCUT_PREFIX=\"${SHORTCUT_PREFIX}\"
export UPDATE_DESKTOP_DATABASE=\"${UPDATE_DESKTOP_DATABASE}\"
export EXIFTOOL=\"\$(which exiftool)\"
# winezgui backup file extension
export BKP_EXT=\"${BKP_EXT}\"

# Files
export INFOFILE=\"${PREFIXDIR}/Info.yml\"
export ICONFILE=\"${PREFIXDIR}/${EXE_LESS}.png\"
export SCRIPTFILE=\"${PREFIXDIR}/${EXE_LESS}.sh\"
export DESKTOPFILE=\"${PREFIXDIR}/${EXE_LESS}.desktop\"

export SYSTEM_WINE=\"${SYSTEM_WINE}\"
echo \"SYSTEM_WINE=${SYSTEM_WINE}\"


# if icon is found grep it
if [ -f \"${ICONFILE}\" ]; then
     export ICON=\"\$(grep Icon \${DESKTOPFILE}|cut -f2 -d \"=\")\"
else
     export ICON="null"
fi
" > "${SCRIPTFILE}"

# Append rest
echo '

if [ -f "${DATADIR}/winezgui-source" ]; then
     source "${DATADIR}/winezgui-source"
else
     source "${WINEZGUI_SCRIPTS}/winezgui-source"
fi

# Load file with dbug function
SOURCE "winezgui-dbug"

# If Settings.yml exists, get arch value from it: win32 or win64
if [ -f "${SETTINGS_FILE}" ]; then
     export DEBUG=$(grep "debug:" ${SETTINGS_FILE}|cut -f2 -d ":")
     export NO_SHORTCUTS=$(grep "no-shortcuts:" ${SETTINGS_FILE}|cut -f2 -d ":")
     export USE_SINGLE_PREFIX=$(grep "single-prefix:" ${SETTINGS_FILE}|cut -f2 -d ":")
fi

# LD_LIBRARY_PATH
# If empty LD_LIBRARY_PATH, add lib paths
if [ -z "${LD_LIBRARY_PATH}" ]; then
LD_LIBRARY_PATH+="/lib:/lib32:/lib64"; fi
LD_LIBRARY_PATH+="${LD_LIBRARY_PATH}:/app/lib:/app/lib32:/app/lib64:"
LD_LIBRARY_PATH+="/app/lib/i386-linux-gnu:/app/lib/wine:"
LD_LIBRARY_PATH+="/app/lib64/wine:"
LD_LIBRARY_PATH+="/usr/lib/x86_64-linux-gnu/wine:"
LD_LIBRARY_PATH+="/usr/lib/wine:"
LD_LIBRARY_PATH+="/usr/lib/wine/wine:"
LD_LIBRARY_PATH+="/usr/lib64/wine:"
LD_LIBRARY_PATH+="/usr/lib64/wine/wine:"
LD_LIBRARY_PATH+="/usr/lib/i386-linux-gnu/wine:"
LD_LIBRARY_PATH+="$(pwd)"
export LD_LIBRARY_PATH 
export DESKTOP_FILE_EDIT=$(which desktop-file-edit)

SOURCE "script-locate-exe-function"
# LOCATE_EXE_FUNCTION required on Launch
# Get runner from info file

# # === = = = = = = = Recreate Prefix script with Runner 
# # If Infofile exists (old scripts) and Runner: is not found add it
# if [ -f ${INFOFILE} ]; then
#    grep "Runner:" "${INFOFILE}" || echo "Runner:${RUNNER}" >> "${INFOFILE}"
#    export RUNNER=$(grep -i "Runner:" ${INFOFILE}|cut -f2 -d ":")
# fi

# # If Runner is empty in Infofile, then get Runner info from Settings.yml
# if [ -z "${RUNNER}" ]; then
#      if [ -f "${SETTINGS_FILE}" ]; then
#           export RUNNER=$(grep "runner:" ${SETTINGS_FILE}|cut -f2 -d ":")
#      fi
# fi  

# # If runner is not specified in Infofile or Settings.yml then use wine
# if [ -z "${RUNNER}" ]; then
#     export RUNNER="$(which wine)"
# fi

# # if runner is from local install /app/bin/wine or /usr/bin/wine etc.
# # set RUNNER_NAME
# if [ "${RUNNER}" = "$(which wine)" ]; then
#      export RUNNER_NAME="System Default"
# else #Get directory name containing bin/wine
#      export RUNNER_NAME=$(basename $(dirname $(dirname ${RUNNER})))
# fi
# # Runner = wine command in a different directory
# export WINE_CMD="${RUNNER}"
# #/ === = = = = = = = Recreate Prefix script with Runner 
# echo "11. --------------------------------------- WINE_CMD = $WINE_CMD"
# echo "11. --------------------------------------- RUNNER = $RUNNER"
# echo "11. --------------------------------------- RUNNER_NAME = $RUNNER_NAME"

# # If ${FLATPAK_NAME} is installed, and script created using flatpak
# if  [ ${INSTALL_TYPE} = "flatpak" ] && \
#     [ $(flatpak --command=echo run ${FLATPAK_NAME} 0 2>/dev/null) ]; then
#       dbug "I: Script: Install type: Flatpak, Running from host!"
#       WINE_CMD="flatpak run --command=${RUNNER} ${FLATPAK_NAME}"
#       WTRICKS_CMD="flatpak run --command=winetricks ${FLATPAK_NAME}"
#       WINECFG_CMD="flatpak run --command=wine ${FLATPAK_NAME} winecfg"
#       WEXPLORER_CMD="flatpak run --command=wine ${FLATPAK_NAME} explorer"
#       WBOOT_CMD="flatpak --command=wineboot run ${FLATPAK_NAME} -i"
#       # wine winetricks icotool exiftool zenity gnome-terminal zstd"
#       ICOTOOL_CMD="flatpak run --command=icotool ${FLATPAK_NAME}"
#       WRESTOOL_CMD="flatpak run --command=wrestool ${FLATPAK_NAME}"
#       ZENITY_CMD="flatpak run --command=zenity ${FLATPAK_NAME}"
#       EXIFTOOL_CMD="flatpak run --command=exiftool ${FLATPAK_NAME}"
#       ZSTD_CMD="flatpak run --command=zstd ${FLATPAK_NAME}"
#       TAR_CMD="flatpak run --command=tar ${FLATPAK_NAME}"
#       WGET_CMD="flatpak run --command=wget ${FLATPAK_NAME}"
#       export WINE_CMD WTRICKS_CMD WINECFG_CMD WEXPLORER_CMD WBOOT_CMD
#       export ICOTOOL_CMD ZENITY_CMD EXIFTOOL_CMD ZSTD_CMD TAR_CMD WGET_CMD WRESTOOL_CMD

# else
#      # flatpak install and running from shell inside flatpak winezgui
#      if [ "${INSTALL_TYPE}" = "flatpak" ]; then
#           dbug "I: Script: Install type: Flatpak, Running from flatpak!"
#           export WINE_CMD=${RUNNER}
#           export WTRICKS_CMD="/app/bin/winetricks"
#           export WINECFG_CMD="${WINE_CMD} winecfg"
#           export WEXPLORER_CMD="${WINE_CMD} explorer"
#           export WBOOT_CMD="$(which wineboot) -i"
#           export ICOTOOL_CMD="$(which icotool)"
#           export WRESTOOL_CMD="$(which wrestool)"
#           export ZENITY_CMD="$(which zenity)"
#           export EXIFTOOL_CMD="$(which exiftool)"
#           export ZSTD_CMD="$(which zstd)"
#           export TAR_CMD="$(which tar)"
#           export WGET_CMD="$(which wget)"
          
#      else
#           # We are using non flatpak install
#           dbug "I: Script: Install type: System, Running from host!"
#           export WINE_CMD=${RUNNER}
#           export WTRICKS_CMD="$(which winetricks)"
#           export WINECFG_CMD="${WINE_CMD} winecfg"
#           export WEXPLORER_CMD="${WINE_CMD} explorer"
#           export WBOOT_CMD="$(which wineboot) -i"
#           export ICOTOOL_CMD="$(which icotool)"
#           export WRESTOOL_CMD="$(which wrestool)"
#           export ZENITY_CMD="$(which zenity)"
#           export EXIFTOOL_CMD="$(which exiftool)"
#           export ZSTD_CMD="$(which zstd)"
#           export TAR_CMD="$(which tar)"
#           export WGET_CMD="$(which wget)"
#      fi
# fi


# Needed for Info.yml and backup and restore function

# Set WINE_CMD, WINEVER, RUNNER variables
SOURCE "winezgui-set-wine_cmd-runner-commands"
winezgui-set-wine_cmd-runner-commands

# Debug output for Variables created 
for i in WINE_CMD WTRICKS_CMD WINECFG_CMD WEXPLORER_CMD WBOOT_CMD ICOTOOL_CMD ZENITY_CMD \
         EXIFTOOL_CMD ZSTD_CMD TAR_CMD WGET_CMD WRESTOOL_CMD; do
         if [ ! -z "${i}" ]; then
              echo "Exporting: $i = ${!i}" && export $i 
         else
              echo "=e=e=e=e=e=e=e=e=e=e=e="
              echo "Failed to export: $i"
              echo "=e=e=e=e=e=e=e=e=e=e=e="
         fi
done

echo "${SCRIPTFILE} ----------------------------- RUNNER:${RUNNER}"
echo "${SCRIPTFILE} ----------------------------- WINE_CMD:${WINE_CMD}"
echo "${SCRIPTFILE} ----------------------------- RUNNER_NAME:${RUNNER_NAME}"

# For Zenity 4
ZENITY_VERSION=$(${ZENITY_CMD} --version|cut -f1 -d ".")

Script_Window()
{
  unset SELECTION
  # EXE handling by providing dialog
  if [ "${ZENITY_VERSION}" -eq 4 ]; then
       WINDOW_HEIGHT=820
       WINDOW_WIDTH=500
  else
       WINDOW_HEIGHT=440
       WINDOW_WIDTH=360
  fi

  SELECTION=$(${ZENITY_CMD} --title "${PROGNAME}"       \
                     --window-icon="${ICON}"            \
                     --width=${WINDOW_WIDTH}            \
                     --height=${WINDOW_HEIGHT}          \
                     --list      --hide-header          \
                     --radiolist --column " "           \
                     --column "Action"                  \
                       TRUE   "Launch..."               \
                          0   "Open Other EXE..."       \
                          0   "Winetricks GUI..."       \
                          0   "Winetricks CLI..."       \
                          0   "Wine Programs..."        \
                          0   "Open File Manager..."    \
                          0   "Open Shell..."           \
                          0   "Change..."               \
                          0   "Backup..."               \
                          0   "Save/Load..."            \
                          0   "More..."                 \
                          0   "About..."                \
                          0   "Help..."                 \
                          0   "Quit...."                \
                     --text   "Select action for <b>${EXE_NAME}</b>..." )

  # Exit if Cancel is clicked
  if   [ -z "${SELECTION}" ]; then
         echo "I: Script: Cancel Selected. Bye!"
         exit 0
         
  elif [ "${SELECTION}" = "Launch..." ]; then
         SOURCE "script-launch"
         script-launch

  elif [ "${SELECTION}" = "Open Other EXE..." ]; then
         SOURCE "script-open-other-exe"
         script-open-other-exe

  elif [ "${SELECTION}" = "Winetricks GUI..." ]; then
         SOURCE "script-winetricks-gui"
         script-winetricks-gui

  elif [ "${SELECTION}" = "Winetricks CLI..." ]; then
         SOURCE "script-winetricks-cli"
         script-winetricks-cli

  elif [ "${SELECTION}" = "Wine Programs..." ]; then
         SOURCE "script-wine-programs"
         script-wine-programs

  elif [ "${SELECTION}" = "Open Shell..." ]; then
         SOURCE "script-open-shell"
         script-open-shell

  elif [ "${SELECTION}" = "Open File Manager..." ]; then
         SOURCE "script-open-file-manager"
         script-open-file-manager

  elif [ "${SELECTION}" = "Change..." ]; then
         SOURCE "script-change"
         script-change
         
  elif [ "${SELECTION}" = "Backup..." ]; then
         SOURCE "script-backup"
         script-backup
         
  elif [ "${SELECTION}" = "Save/Load..." ]; then
         SOURCE "script-save-load"
         script-save-load

  elif [ "${SELECTION}" = "More..." ]; then
         SOURCE "script-more"
         script-more
         
  elif [ "${SELECTION}" = "About..." ]; then
         SOURCE "script-about"
         script-about

  elif [ "${SELECTION}" = "Help..." ]; then
         SOURCE "script-help"
         script-help

  elif [ "${SELECTION}" = "Quit...." ]; then
         SOURCE "script-quit"
         script-quit
  fi

  dbug "I: Script: ${SELECTION} Selected!" # Show What is selected
  Script_Window # After All options 
}

# Change Prefix on changing EXE
if [ -f "${PREFIXDIR}/Change-Prefix-Name" ]; then
     dbug "I: Script: Change Prefix Requested..."
     PREFIX_NAME_TO_CHANGE="$(grep Prefix "${PREFIXDIR}/Change-Prefix-Name" \
                             |cut -f2 -d ":")"
     dbug "I: Script: Launching script-rename-prefix function (script-rename-prefix)"
     SOURCE "script-rename-prefix"
     rm "${PREFIXDIR}/Change-Prefix-Name"
     dbug "I: Script: Change Prefix to ${PREFIX_NAME_TO_CHANGE}"
     script-rename-prefix ${PREFIX_NAME_TO_CHANGE}

fi

# If restored from Backup, update the wineprefix on different wine version
# without install mono and install html dialog
if [ -f "${PREFIXDIR}/restored.txt" ]; then
     dbug "I: Script: Updating wine prefix on 1st run after restoring backup"
     #WINEDLLOVERRIDES="mscoree,mshtml=" \
     ## Disabling wineboot for proton etc. runners
     #WINEPREFIX=${PREFIXDIR} \
     #${WBOOT_CMD} 2>/dev/null
     
     # Do not prompt for found new exe after restore
     # On backup bundle, gamedir is copied, so, update found_exe_files 
     SOURCE "script-create-found-new-exe-files-file"
     script-create-found-new-exe-files-file
     rm "${PREFIXDIR}/restored.txt"
fi

# Creating/Updating Prefix for the EXE prefix

# Sandboxify by rm links to ~/Documents ~/Downloads ~/Videos etc.
if [ ! -f "${PREFIXDIR}/replaced_symlinks.txt" ]; then

     dbug "I: Script: Prefix: Creating Prefix..."
     # Create Prefix and delete base system linked directory links
     dbug "I: Script: Prefix: wine=$(which wine)"
     dbug "I: Script: Prefix: WINEPREFIX=${WINEPREFIX}"
     dbug "I: Script: Prefix: Wineboot command = ${WBOOT_CMD}"
     dbug "I: Script: Prefix: WINEARCH ${WINEARCH}"
     #WINEDLLOVERRIDES="mscoree,mshtml=" \
     WINEDEBUG=-all \
     WINEPREFIX="${PREFIXDIR}" \
     ${WBOOT_CMD} 2>/dev/null

     # Replace home liked directory links with normal directories
     # For Games which saves in ~/Documents now will save in
     # Prefix-dir/drive_c/users/${USER}/Documents
     dbug "I: Script: Prefix: Replacing symlinks with directories inside prefix"
     SAVEIFS=${IFS}
     IFS=$(echo -en "\n\b")
     for i in $(find ${WINEPREFIX}/drive_c/users/${USER} -type l); do
           rm $i && mkdir -p $i && \
           echo $i >> "${PREFIXDIR}/replaced_symlinks.txt"
     done
     IFS=${SAVEIFS}

     # Create file to check later
     touch "${PREFIXDIR}/replaced_symlinks.txt"

     # Create H: for HOME Directory for Wine Explorer
     ln -sf "${HOME}" "${PREFIXDIR}/dosdevices/h:"
     dbug "I: Script: Prefix: Creating H: symlink to ${HOME}"
     dbug "I: Script: Prefix: Created Prefix: ${PREFIXDIR}"
fi

# Create Metadata Info.yml for the prefix
if [ ! -f "${INFOFILE}" ]; then
     #  Insert Data into Info.yml
     DATE=$(date +%F_%H%M)

     echo "Name:${PROGNAME}"                >  "${INFOFILE}"
     echo "Exe:${EXE_FILE}"                 >> "${INFOFILE}"
     echo "Sha256sum:${CHECKSUM}"           >> "${INFOFILE}"
     echo "Exe Path:${EXE_PATH}"            >> "${INFOFILE}"
     echo "Prefix:${PREFIXNAME}"            >> "${INFOFILE}"
     echo "Script:${SCRIPTFILE}"            >> "${INFOFILE}"
     echo "Icon:${ICONFILE}"                >> "${INFOFILE}"
     echo "Shortcut:${DESKTOPFILE}"         >> "${INFOFILE}"
     echo "Created:${DATE}"                 >> "${INFOFILE}"
     echo "Wine:${WINEVER}"                 >> "${INFOFILE}"
     echo "Runner:${RUNNER}"                >> "${INFOFILE}"
     echo "Wine Arch:${WINEARCH}"           >> "${INFOFILE}"
     echo "WineZGUI:${APPVERSION}"          >> "${INFOFILE}"
     echo "WineZGUI Prefix:${WINEZGUIDIR}"  >> "${INFOFILE}"
     echo "Install:${INSTALL_TYPE}"         >> "${INFOFILE}"

     # Include flatpak id in Info.yml
     if [ "${INSTALL_TYPE}" = "flatpak" ]; then
          echo "Flatpak:${FLATPAK_NAME}"    >> "${INFOFILE}"
     fi
     dbug "I: Script: Prefix: Created ${INFOFILE}"
fi

# Handle Commandline Argument ${0} backup, ${0} launch etc.
# Either we run with argumement from winezgui or from prefixdir manually
if   [ "$1" = "delete" ]; then
       SOURCE "script-delete"
       SCRIPT_DELETE
       exit 0;
elif [ "$1" = "backup" ]; then
       cd ${PREFIXES_DIR}
       SOURCE "script-backup"
       script-backup
       exit 0;
elif [ "$1" = "shortcut" ]; then
       SOURCE "script-get-selected-exe"
       script-get-selected-exe
       # Just launching the selected exe, create desktop file and run this
       SOURCE "script-create-other-shortcuts"
       script-create-other-shortcuts
       exit 0;
elif [ "$1" = "launch" ] || [ -f "${PREFIXDIR}/launch" ] && \
     [ "${LAUNCH}" != "False" ]; then
       # If asked to run "wine exe" by winezgui using launch option
       # Launch 
       # 1. If launch file is found, and it is not running from winezgui window
       # 2. If Script is called from WineZGUI Shortcuts...
       # 3. If $LAUNCH variable is not set to False
       SOURCE "script-launch"
       script-launch
       # Return to Game window
       # 
       exit 0;
fi

# Start WineZGUI when no argument is supplied
if [ $# -eq 0 ] ; then
     dbug "I: Script: Launching ${EXE_NAME} script"
     Script_Window
fi


' >> "${SCRIPTFILE}"
# Script file Created, now make it executable
chmod +x "${SCRIPTFILE}"

# Create desktop shortcut file for menu
echo "[Desktop Entry]"                       >  "${DESKTOPFILE}"
echo "Name=${PROGNAME}"                      >> "${DESKTOPFILE}"
echo "Type=Application"                      >> "${DESKTOPFILE}"
echo "Exec=bash -c \"'${SCRIPTFILE}'\""      >> "${DESKTOPFILE}"
echo "Icon=${ICON}"                          >> "${DESKTOPFILE}"
echo "Keywords=winezgui; game; ${EXE_LESS};" >> "${DESKTOPFILE}"
echo "NoDisplay=false"                       >> "${DESKTOPFILE}"
echo "StartupNotify=true"                    >> "${DESKTOPFILE}"
echo "Terminal=false"                        >> "${DESKTOPFILE}"
echo "Categories=${APP_CATEGORY};"           >> "${DESKTOPFILE}"

# Update INFOFILE after creating script
if [ -f "${INFOFILE}" ]; then
     #  Insert Data into Info.yml
     DATE=$(date +%F_%H%M)

     echo "Name:${PROGNAME}"                >  "${INFOFILE}"
     echo "Exe:${EXE_FILE}"                 >> "${INFOFILE}"
     echo "Sha256sum:${CHECKSUM}"           >> "${INFOFILE}"
     echo "Exe Path:${EXE_PATH}"            >> "${INFOFILE}"
     echo "Prefix:${PREFIXNAME}"            >> "${INFOFILE}"
     echo "Script:${SCRIPTFILE}"            >> "${INFOFILE}"
     echo "Icon:${ICONFILE}"                >> "${INFOFILE}"
     echo "Shortcut:${DESKTOPFILE}"         >> "${INFOFILE}"
     echo "Created:${DATE}"                 >> "${INFOFILE}"
     echo "Wine:${WINEVER}"                 >> "${INFOFILE}"
     echo "Runner:${RUNNER}"                >> "${INFOFILE}"
     echo "Wine Arch:${WINEARCH}"           >> "${INFOFILE}"
     echo "WineZGUI:${APPVERSION}"          >> "${INFOFILE}"
     echo "WineZGUI Prefix:${WINEZGUIDIR}"  >> "${INFOFILE}"
     echo "Install:${INSTALL_TYPE}"         >> "${INFOFILE}"

     # Include flatpak id in Info.yml
     if [ "${INSTALL_TYPE}" = "flatpak" ]; then
          echo "Flatpak:${FLATPAK_NAME}"    >> "${INFOFILE}"
     fi
     dbug "I: Script: Prefix: Created ${INFOFILE}"
fi

# link the launcher  file to a shortcut on applications menu.
#mkdir -p "${DEXSKTOPDIR}" && \
#dbug "I: ${HEADER}: Created ${DEXSKTOPDIR}"

# set x permissions
chmod +rx "${DESKTOPFILE}" "${SCRIPTFILE}" "${S_SCRIPTFILE}" "${S_DESKTOPFILE}" "${NEW_SCRIPT_FILE}" "${NEWDESKTOPFILE}" "${NEWSCRIPTFILE}"

#ln -sf "${DESKTOPFILE}" "${DEXSKTOPDIR}/${EXE_LESS}.desktop" && \
# If NO_SHORTCUTS= NOTHING/EMPTY then create shortcuts
  echo "xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo" 
if [ -z "${NO_SHORTCUTS}" ]; then
     ln -sf "${DESKTOPFILE}" "${APPLICATIONSDIR}/${SHORTCUT_PREFIX}_${EXE_LESS}.desktop" && \
     dbug "I: ${HEADER}: Symlinked ${EXE_LESS}.desktop at ${APPLICATIONSDIR}"
     # Test if the app link was created sucessfully on applications menu
     if [ $? -eq 0 ]; then
          dbug "I: ${HEADER}: Shortcut ${EXE_LESS}.desktop created"
          dbug "I: ${HEADER}: Shortcut: Name: ${PROGNAME}"
          dbug "I: ${HEADER}: Can use \"Rename...\" to change name"
          dbug "I: ${HEADER}: Shortcut: Exe: ${EXE_NAME}"
     fi
     dbug "I: ${HEADER}: Shortcut is created at ${APPLICATIONSDIR}/${SHORTCUT_PREFIX}_${EXE_LESS}.desktop"
else 
     dbug "I: ${HEADER}: WARNING: Shortcut NOT CREATED at ${APPLICATIONSDIR}/${SHORTCUT_PREFIX}_${EXE_LESS}.desktop"
fi
# Update Menu, Icon cache and Desktop shortcuts
find ${APPLICATIONSDIR} -maxdepth 1 -iname "${SHORTCUT_PREFIX}*" -xtype l -delete 2>/dev/null
${UPDATE_ICON_CACHE} 2>/dev/null
${UPDATE_DESKTOP_DATABASE} ${APPLICATIONSDIR} 2>/dev/null
