#!/bin/bash

### Slackware
#################################################
### This script manages your Slackware and SBo pkgs.
### It can be used as a wrapper of the normal slackpkg command.
### To get started type:
### slackpkgExtend help
###
### I have found an interesting part in the slackpkg script:
###
### If you want a new function or need a rewrite of an existing
### feature, you can put your new function in a shell script under
### /usr/libexec/slackpkg/functions.d/
###
### Remember - the new function scripts need to be executable
###
### So i could include this functions directly into the slackpkg

PARAMETER="$1"
shift 1
INPUT="$@"

SCRIPT_PATH="$(realpath $0)"
DIR_BASE="/root/Slackbuilds"
DIR_INSTALLED="$DIR_BASE/installed"
DIR_INSTALL="$DIR_BASE/pkgs"
DIR_FAILED="$DIR_BASE/failed"
DIR_LOG="$HOME/.cache/slackpkgExtend"
DIR_PACKAGESLOG="/var/log/packages"
FILE_BLACKLIST="/etc/slackpkg/blacklist"
FILE_LOG="$DIR_LOG/log"

mkdir -p $DIR_INSTALLED $DIR_INSTALL $DIR_FAILED $DIR_LOG

# Check if slackbuilds git exist in ${DIR_INSTALL}
checkInitial() {
   if [ -z "$(ls -A $DIR_INSTALL)" ]; then
      echoHelp "Check if slackbuilds git exist in ${DIR_INSTALL}"
      echoOrange "You are missing the slackbuilds git folder!"
      echoGreen "Cloning git into $DIR_INSTALL"
      readInputYn "Yn" 
      [[ "$READ_CHECK" = "n" ]] && echoOrange "Clone slackbuild was canceled." && return 1
      git clone git://git.slackbuilds.org/slackbuilds.git $DIR_INSTALL
   fi
}
checkLock() {
   if [[ $(ls /var/lock | grep "^slackpkg.") ]]; then
      echo ""
      quit '\nAnother instance of slackpkg is running. If this is not correct, you can\nremove /var/lock/slackpkg.* files and run slackpkg again.\n'
   fi
}


NC='\033[0m'
COLOR_RED="\033[0;31;1m"
COLOR_GREEN="\033[0;32;1m"
COLOR_BLUE="\033[0;34;1m"

echoSeparator() {
   echo -en "\n\033[1;36;1m$(printf '%0.s▂' $(seq 1 $(tput cols)))\033[0m\n\n"
}
echoGreen() {
   p="-e"; [[ "$1" = "-n" ]] && p="-en" && shift 1
   echo $p "${COLOR_GREEN}$1${NC}"
}
echoOrange() {
   p="-e"; [[ "$1" = "-n" ]] && p="-en" && shift 1
   echo $p "\033[0;33;1m$1${NC}"
}
echoRed() {
   p="-e"; [[ "$1" = "-n" ]] && p="-en" && shift 1
   echo $p "${COLOR_RED}$1${NC}"
}
echoPurple() {
   p="-e"; [[ "$1" = "-n" ]] && p="-en" && shift 1
   echo $p "\033[0;35;1m$1${NC}"
}
echoBlue() {
   p="-e"; [[ "$1" = "-n" ]] && p="-en" && shift 1
   echo $p "${COLOR_BLUE}$1${NC}"
}
echoHelp() {
   [[ "$1" = "-q" ]] && return 1
   p="-e"; n="\n"; [[ "$1" = "-n" ]] && p="-en" && n="" && shift 1
   echoSeparator
   [[ -n $2 ]] && echo -e "\n\033[1;35;1m$2\033[0m"
   echo $p "\n${COLOR_BLUE}$1${NC}$n"
}

quit() {
   echoSeparator
   echoRed "ERROR: $1"
   exit 0
}
#
#
#
readInputYn() {
   I=$1; a="$(sed 's/./&|/g;s/|$//g' <<<"$I")"; unset READ_CHECK
   echoHelp -n "Enter command: ${COLOR_GREEN}[$a] " "$2" && read -n1 c;
   echo ""
   if [[ "[${a,,}]" =~ "${c,}" ]]; then READ_CHECK="$(grep -oi "$c" <<< $I)"; else readInputYn "$I" "$2" ;fi
}

blacklistCheck() {
   sed -ne '/# This sction will be written by slackpkgExtend_build/,$ p' $FILE_BLACKLIST | grep -q "^$NAME\.\*\[0-9\]+_SBo"
}
blacklistAdd() {
   echo "$NAME.*[0-9]+_SBo" >> $FILE_BLACKLIST
}
blacklistClear() {
   sed -i "/^$NAME\.\*\[0-9\]+_SBo$/d" $FILE_BLACKLIST
}
failedInput() {
   echo "No package found named $INPUT"
}

getPkgPath() {
   NAME="$INPUT"
   INPUT="$( cd $DIR_INSTALL && find . -type d -name "$INPUT" | head -n1 | sed "s/^\.\///g")"
   [[ -z $INPUT ]] && failedInput
}

checkSbo() {
   sed -n "s/^$NAME-[0-9]//p" <<< $(ls --color=never /var/log/packages/) | grep -q "[0-9]_SBo$"
}
checkAlien() {
   sed -n "s/^$NAME-[0-9]//p" <<< $(ls --color=never /var/log/packages/) | grep -q "\-[0-9]alien$"
}
checkInstalled() {
   [[ -z $NAME ]] && quit "checkInstalled: no NAME set..."
   VERSION="$(sed -n "s/^$NAME-[0-9]//p" <<< $(ls --color=never /var/log/packages/) | sed "s/-.*$//g")"
}
#help info $NAME
slackGetInfo() { 
   check="$(find $DIR_INSTALL -type d -name "$INPUT" | head -n1 | sed "s/^\.\///g")"
   if [[ -z $check ]]; then
      command slackpkg info "$INPUT"
   else
      echoHelp "Get info of SBo package."
      echo "$INPUT" | grep -q "/" || getPkgPath
      BASENAME="$(basename $INPUT)"
      cat $DIR_INSTALL/$INPUT/$BASENAME.info
   fi
}
#help search-build $NAME
searchPkg() { 
   echoHelp "Search for SBo package."
   INPUT="$(echo $INPUT | sed "s/^search //g")"
   FINDS="$(find $DIR_INSTALL -type d -name "$INPUT")"
   echo "$FINDS" | sed "s|$DIR_INSTALL/||g"
}


slackSearch() {
   NAME="$INPUT" bc=false
   blacklistCheck && blacklistClear && bc=true
   command slackpkg search $NAME 
   $bc && blacklistAdd
}
#help check-installed $NAMES
slackCheckInstalled() { 
   echoHelp "Check if a specific package is installed."
   notinstalled=()
   diffinstall=()
   isslack=()
   issbo=()
   isalien=()
   for NAME in ${INPUT[@]}; do
      checkInstalled
      if checkSbo; then
         issbo+=( "$NAME" )
      elif checkAlien; then
         isalien+=( "$NAME" )
      elif slackpkg search "$NAME" | awk '{print $1 " " $4}' | sed -r "s/\x1B\[([0-9]{1,3}(;[0-9]{1,2})?)?[mGK]//g"| grep -q "\[inst\] $NAME-[0-9]"; then
         isslack+=( "$NAME" )
      elif grep -q "$NAME" <<< $(whereis $NAME | awk '{print $2}'); then
         diffinstall+=( "$NAME" )
      elif [[ -n $VERSION ]]; then
         diffinstall+=( "$NAME" )
      else
         notinstalled+=( "$NAME" )
      fi
   done

   [[ -n ${notinstalled[@]} ]] || [[ -n $isslack ]] || [[ -n $isalien ]] || [[ -n $diffinstall ]] || [[ -n $issbo ]] && echo ""
   [[ -n ${notinstalled[@]} ]] && echoRed "Not installed:${NC}\t\t${notinstalled[*]}"
   [[ -n $isslack ]] && echoGreen "Slackpkg installed:${NC}\t${isslack[*]}"
   [[ -n $isalien ]] && echoGreen "Alien installed:${NC}\t${isalien[*]}"
   [[ -n $issbo ]] && echoGreen "SBo installed:${NC}\t\t${issbo[*]}"
   [[ -n $diffinstall ]] && echoOrange "Different installation:${NC}\t${diffinstall[*]}"
   echo ""
}
#help check-folder 
slackCheckInstalledFolder() { 
   echoHelp "Check the content of $DIR_INSTALLED for misplaced folders."
   notinstalled=()
   diffinstall=()
   issbo=()
   isalien=()
   for NAME in $(ls --color=never -1 $DIR_INSTALLED | sed "/^.*\.tar.gz/d;/^.*\.old/d" | sort | uniq | xargs); do
      checkInstalled
      if checkSbo; then
         issbo+=( "$NAME" )
      elif checkAlien; then
         isalien+=( "$NAME" )
      elif grep -q "$NAME" <<< $(whereis $NAME | awk '{print $2}'); then
         diffinstall+=( "$NAME" )
      elif [[ -n $VERSION ]]; then
         diffinstall+=( "$NAME" )
      else
         notinstalled+=( "$NAME" )
      fi
   done

   [[ -n ${notinstalled[@]} ]] && echoRed "Not installed:${NC} ${notinstalled[*]}"
   [[ -n $isalien ]] && echoOrange "Alien installed: ${NC}${isalien[*]}"
   [[ -n $diffinstall ]] && echoOrange "Different installation: ${NC}${diffinstall[*]}"
   [[ -n $issbo ]] && echoGreen "Installed: ${NC}${issbo[*]}"

}
slackCheckInstallSources() {
   add_c=false
   blacklistCheck && blacklistClear add_c=true
   sp=`slackpkg search $NAME | sed -r "s/\x1B\[([0-9]{1,3}(;[0-9]{1,2})?)?[mGK]//g" | grep -i "$NAME-[0-9]"`

   SOURCE_A="$(grep -i " : $NAME-[0-9]" <<< $sp | awk '{print $4}')"
   SOURCE_B="$(grep -i " $NAME.*sbo-current$" <<< $sp | awk '{print $1}')"
   PACKAGES_A=() PACKAGES_B=()
   [[ -n $SOURCE_A ]] && PACKAGES_A+=( "$SOURCE_A" )
   [[ -n $SOURCE_B ]] && PACKAGES_B+=( "$SOURCE_B" )
   SOURCE=" $([[ -n $SOURCE_A ]] && echo "Slackpkg ")$([[ -n $SOURCE_B ]] && echo "SBo ")" 
   $add_c && blacklistAdd
}
slackCheckInstalledByPackage() {
   p=( "$@" ) INSTALLED_PACKAGES=() UNINSTALLED_PACKAGES=() COLORED_LIST=""
      f=`ls --color=never "$DIR_PACKAGESLOG"`
      for i in ${p[@]}; do
         if grep -qw "$i" <<< $f; then
            INSTALLED_PACKAGES+=( "$i" )
         elif grep -q "$(sed "s/-sbo-current//g" <<< $i)" <<< $f; then
            INSTALLED_PACKAGES+=( "$(grep "$(sed "s/-sbo-current//g" <<< $i)" <<< $f | head -n1)" )
         else
            UNINSTALLED_PACKAGES+=( "$i" )
         fi
      done
      [[ -n ${INSTALLED_PACKAGES[@]} ]] && COLORED_LIST="${COLOR_GREEN}${INSTALLED_PACKAGES[*]}${NC} "
      [[ -n ${UNINSTALLED_PACKAGES[@]} ]] && COLORED_LIST="$COLORED_LIST${COLOR_RED}${UNINSTALLED_PACKAGES[*]}${NC}"
   }
   slackCheckDublicates() { 
      DUBLICATES="$(ls --color=never /var/log/packages | sort | sed "s/-[0-9].*$//g" | uniq -d | xargs)"
      [[ -n $DUBLICATES ]]
   }

### Install
installPkg() {
   checkInstalled

   failed=false
   source $NAME.info

   if echo $DOWNLOAD_x86_64 | wc -c | grep -wq "[0|1]"; then
      LOADs="$DOWNLOAD"; MD5s="$MD5SUM" 
   else
      LOADs="$DOWNLOAD_x86_64"; MD5s="$MD5SUM_x86_64"
   fi

   c=0
   for LOAD in $(echo $LOADs); do
      c=$((c+1))
      wget "$LOAD" || quit "failed Downloads!"
      BASENAMELOAD=$(basename "$LOAD")
      MD5="$(echo $MD5s | cut -d " " -f $c)"
      echo "$MD5 ## $(md5sum $BASENAMELOAD | awk '{print $1}')" 
      if md5sum $BASENAMELOAD  | awk '{print $1}' | grep -qw "$MD5"; then
         echo "$BASENAMELOAD md5 checked"
      else
         echoRed "$BASENAMELOAD md5 check failed!"
         failed=true
         break
      fi
   done


   if $failed; then
      echoRed "\nInstall $NAME failed!"
      FAILED+=( "$NAME" )
   else
      chmod +x $NAME.SlackBuild
      ./$NAME.SlackBuild
      if /sbin/installpkg "/tmp/$(ls -t /tmp | grep "$NAME" | head -n1)"; then
         blacklistAdd
         echoGreen "\nInstalled:${NC} $NAME"
      else
         cd ..
         cp -r $DIR_INSTALLED/$NAME $DIR_FAILED && rm -r $DIR_INSTALLED/$NAME
         echoRed "\nInstall $NAME failed!"
      fi
   fi
}
installFromHttp() {
   PACK="$INPUT"
   BASENAME="$(basename $PACK)"
   NAME="$(echo "$BASENAME" | sed "s/.tar.gz$//g")"

   checkInstalled

   cd $DIR_INSTALLED
   wget "$PACK" || quit "failed getting $PACK!"
   tar -xvzf $BASENAME
   cd $DIR_INSTALLED/$NAME || quit "cd $DIR_INSTALLED/$NAME failed!"
   installPkg
}
installFromLocal() {
   NAME="$(basename $INPUT)"
   isinstalled=false
   if echo "$INPUT" | grep -q "/"; then
      NAME="$(basename $INPUT)"
   else
      getPkgPath
   fi

   checkInstalled
   [[ -n $VERSION ]] && echoOrange "$NAME-$VERSION is already installed.."
   grep "$NAME" <<< $(whereis $NAME | awk '{print $2}') && isinstalled=true
   [[ -n $VERSION ]] &&  echoOrange "$(echo "/var/log/packages/$(sed -n "s/^$NAME-/$NAME-/p" <<< $(ls --color=never /var/log/packages/))")"
   [[ -n $VERSION ]] && isinstalled=true

   if ! [[ "$PARAMETER" = "upgrade-build" ]] && ! $SKIP_REQUEST; then
      $isinstalled && return 1
      readInputYn "Yn" "Install:${NC} $INPUT?"
      [[ "$READ_CHECK" = "n" ]] && echoRed "Installation canceled: ${NC}$NAME##" && return 1
   fi

   echo "cp -r $DIR_INSTALL/$INPUT $DIR_INSTALLED"
   [[ -d "$DIR_INSTALLED/$NAME" ]] && mv $DIR_INSTALLED/$NAME $DIR_INSTALLED/$NAME.old
   cp -r $DIR_INSTALL/$INPUT $DIR_INSTALLED 
   ! [[ -d "$DIR_INSTALLED/$NAME" ]] && echoRed "Cant find $NAME in $DIR_INSTALLED." && return 1
   cd $DIR_INSTALLED/$NAME 
   installPkg
}
#help install $NAMES
slackInstall() { 
   echoHelp "Install Slackpkg, SBo or http packages."
   if echo "$INPUT" | grep "^http" | grep -q ".tar.gz$"; then
      installFromHttp
   else
      slackInstallNormal
   fi
}
slackInstallNormal() { 
   slackCheckInstalled
   SOURCE_ALL=""
   PACKAGES_ALL_A=() PACKAGES_ALL_B=() PACKAGES_ALL_AB=()

   for NAME in ${INPUT[@]}; do
      slackCheckInstallSources
      SOURCE_ALL="$SOURCE_ALL $NAME=($SOURCE)"
      if [[ "$SOURCE" =  " Slackpkg " ]]; then
         PACKAGES_ALL_A+=( "${PACKAGES_A[@]}" )
      elif [[ "$SOURCE" =  " SBo " ]]; then
         PACKAGES_ALL_B+=( "${PACKAGES_B[@]}" )
      elif [[ "$SOURCE" =  " Slackpkg SBo " ]]; then
         PACKAGES_ALL_AB+=( "${PACKAGES_A[@]}" )
         PACKAGES_ALL_AB+=( "${PACKAGES_B[@]}" )
      fi
   done

   slackCheckInstalledByPackage ${PACKAGES_ALL_A[@]}
   [[ -n ${PACKAGES_ALL_A[@]} ]] && echo -e "\nSlackpkg:\t$(sed "s/ /\n\t\t/g" <<< ${COLORED_LIST})"
   slackCheckInstalledByPackage ${PACKAGES_ALL_B[@]}
   [[ -n ${PACKAGES_ALL_B[@]} ]] && echo -e "SBo:\t\t$(sed "s/ /\n\t\t/g" <<< ${COLORED_LIST})"
   slackCheckInstalledByPackage ${PACKAGES_ALL_AB[@]}
   [[ -n ${PACKAGES_ALL_AB[@]} ]] && echo -e "\nSlackpkg & SBo:\t$(sed "s/ /\n\t\t/g" <<< ${COLORED_LIST}))"

   [[ -z ${notinstalled[@]} ]] && return 1

   echoGreen "\nInstall missing:${NC} ${notinstalled[*]}"
   [[ -n ${PACKAGES_ALL_AB[@]} ]] && readInputYn "n" "Enter n to prefer SBo" 
   [[ -z ${PACKAGES_ALL_AB[@]} ]] && [[ -n ${PACKAGES_ALL_B[@]} ]] && readInputYn "Y" "Install SBo package?"
   installnormal=()
   installsbo=()
   for i in ${notinstalled[@]}; do
      grep -wq "$i" <<< ${PACKAGES_ALL_A[*]} && installnormal+=( "$i" )
      grep -wq "$i" <<< ${PACKAGES_ALL_B[*]} && installsbo+=( "$i" )
      grep -wq "$i" <<< ${PACKAGES_ALL_AB[*]} && [[ "$READ_CHECK" = "i" ]]  && installnormal+=( "$i" )
      grep -wq "$i" <<< ${PACKAGES_ALL_AB[*]} && [[ "$READ_CHECK" = "s" ]] &&  installsbo+=( "$i" )
   done
   SKIP_REQUEST=true
   for NAME in ${installnormal[@]}; do
      echoGreen "Installing:${NC} $NAME"
      command slackpkg install $NAME
   done
   for NAME in ${installsbo[@]}; do
      INPUT="$NAME"
      installFromLocal
   done

   slackRemoveDublicates
}
#help remove $NAMES
slackRemoveBuild() { 
   echoHelp "Remove Slackpkg, Alienbob or SBo pkgs."
   notinstalled=()
   diffinstall=()
   remove=()
   for NAME in ${INPUT[@]}; do
      checkInstalled
      if [[ -n $VERSION ]]; then
         remove+=( "$NAME" )
         checkSbo && blacklistCheck && blacklistClear
      elif grep -q "$NAME" <<< $(whereis $NAME | awk '{print $2}'); then
         diffinstall+=( "$NAME" )
      else
         notinstalled+=( "$NAME" )
      fi
   done
   ## REMOVE
   [[ -n $remove ]] && command slackpkg remove ${remove[@]}

   [[ -n ${notinstalled[@]} ]] && echoOrange "Not installed:${NC}\t${notinstalled[*]}"

   failed=() removed_n=()
   for NAME in ${remove[@]}; do
      VERSION=""
      checkInstalled
      if checkSbo; then
         blacklistAdd
         failed+=( "$NAME" )
      elif [[ -n $VERSION ]]; then
         failed+=( "$NAME" )
      else
         removed_n+=( "$NAME" )
      fi
   done

   # clear build installed folder
   for i in ${removed_n[@]}; do [[ -d $DIR_INSTALLED/$i ]] && rm -r $DIR_INSTALLED/$i; done
   [[ -n $failed ]] || [[ -n $diffinstall ]] || [[ -n $removed_n ]] && echo ""
   [[ -n $failed ]] && echoRed "Failed: ${NC}${failed[*]}"
   [[ -n $diffinstall ]] && echoGreen "Different installation: ${NC}${diffinstall[*]}"
   [[ -n $removed_n ]] && echoGreen "Removed: ${NC}${removed_n[*]}"
}
#help remove-dublicate
slackRemoveDublicates() { 
   echoHelp -q "Remove dublicated Slackpkg Alienbob or SBo pkgs."
   slackCheckDublicates || return 1
   echoHelp "Remove dublicated Slackpkg Alienbob or SBo pkgs."
   echoGreen "Dublicates found: ${DUBLICATES[*]}" && INPUT="${DUBLICATES[@]}" slackRemoveBuild
}

#help update
slackUpdate() { 
   echoHelp "Update the regular slackpkgs."
   command slackpkg update
}
#help update-build
slackUpdateBuild() { 
   echoHelp "Update the SBo git."
   cd $DIR_INSTALL
   git pull
}

#help upgrade-all
slackUpgradeAll() {
   echoHelp "Upgrade the regular slackpkgs."
   command slackpkg upgrade-all
}
#help upgrade-build
slackUpgradeBuild() {
   echoHelp "Upgrade all SBo packages."
   slackUpdate

   FAILED=()
   INSTALLED=($(cd $DIR_INSTALLED && ls --color=never | grep -v "\."))
   aVersion=""
   bVersion=""

   # check versions
   checkVersion() {
      upgradeVersion=""
      name="$1"
      pkg_dir="$2"
      aVersion="$(grep "^VERSION" $DIR_INSTALLED/$name/$name.info | sed "s/VERSION=//g;s/\"//g")"
      bVersion="$(grep "^VERSION" $pkg_dir/$name.info | sed "s/VERSION=//g;s/\"//g")"
      [[ "$(echo $aVersion | sed 's/\./-/g' )" = "$(echo $bVersion | sed 's/\./-/g' )" ]] || upgradeVersion="$bVersion"
   }

   # iterate over pkgs
   echoHelp "\nCheckking versions."
   upgrade=()
   for name in ${INSTALLED[@]}; do
      #echo "$name"
      pkg_dir="$(find $DIR_INSTALL -name "$name" | head -n1)"
      if [[ -d $pkg_dir ]]; then
         checkVersion "$name" "$pkg_dir"
         t="\t"; [[ "${#name}" -lt "8" ]] && t="\t\t" 
         v="\t"; [[ "${#aVersion}" -gt "7" ]] && v=" " 
         [[ "${#upgradeVersion}" -le "0" ]] && echo -e "$name$t$aVersion$v= $bVersion"
         if [[ "${#upgradeVersion}" -gt "0" ]]; then
            SED="$(echo $DIR_INSTALL | sed 's/\//\\\//g')\/"
            pkg_dir="$(echo "$pkg_dir"  | sed "s/$SED//g")"
            echoGreen "$name$t$aVersion$v< $bVersion $pkg_dir"
            upgrade+=( "$name" )
         fi
      fi
   done

   if [[ -n ${upgrade[@]} ]]; then 
      echoGreen "\nUpgradelist:${NC} ${upgrade[*]}"
      c="false"
      readInputYn "Yn"
      for INPUT in ${upgrade[@]}; do
         echoGreen "Upgrading:${NC} $INPUT"
         installFromLocal
      done
   fi

   slackRemoveDublicates

   [[ -z $upgrade ]] && echoGreen "\nAll up to date."
   [[ -n ${FAILED[@]} ]] && echoRed "Upgrade failed:${NC} ${FAILED[*]}"
}

getCommandFromHelp() {
   COMMAND="$(slackHelp --no-color | grep "command: $PARAMETER" | sed "s/.*-> //g")"
   ${COMMAND}
}
slackReadNew() {
   slackHelp
   while true; do
      SKIP_REQUEST=false
      echoSeparator
      echo ""
      echoBlue -n "Enter command: "
      read -e INPUT 
      PARAMETER="$(cut -d' ' -f1 <<< $INPUT)"
      INPUT=( "$(cut -d' ' -f2- <<< $INPUT)" )
      getCommandFromHelp 
   done
}

slackHelp() {
   command slackpkg help
   color_green="\\$COLOR_GREEN" color_blue="\\$COLOR_BLUE" color_yellow="\\$COLOR_YELLOW" color_cyan="\\$COLOR_CYAN"
   if grep -wq '\--no-color' <<< $1; then shift 1; color_green="" color_cyan="" color_yellow="" color_blue=""; fi
   SED="s/#help /"${color_blue}"command: ${color_green}/g;s/\$NAME/${color_yellow}\$NAME/g;s/() {//g;s/^.*echoHelp \"//g;s/^.*echoHelp -q \"//g;s/\"$//g;s/\$DIR_INSTALLED/$(sed "s/\//\\\\\//g"<<<$DIR_INSTALLED)/g;"
   echo -e "$(sed "$SED" <<< $(grep -A2 "#help" <<< cat $SCRIPT_PATH | sed -n "/SED=\"s\/\#help/q;p") | sed "2~4s/^/${color_cyan}-> /g;3~4s/^/\\${NC}\\t /g;s/^--//g" | xargs -n2 -d'\n')"
      echo ""
   } 

#########
### Main
checkLock
checkInitial

echo "$(date) $@" >> $FILE_LOG
cd $DIR_INSTALL
echoSeparator
case "$PARAMETER" in
   dialog)
      slackpkgExtend_dialog ${INPUT[@]}
      ;;
   install)
      slackInstall
      ;;
   update)
      slackUpdate
      ;;
   update-build)
      slackUpdateBuild
      ;;
   upgrade-build)
      slackUpgradeBuild
      ;;
   upgrade-all)
      slackUpgradeAll
      ;;
   remove)
      slackRemoveBuild
      ;;
   search)
      slackSearch
      ;;
   search-build)
      searchPkg
      ;;
   info)
      slackGetInfo
      ;;
   list)
      slackpkgExtend_list ${INPUT[@]}
      ;;
   read)
      slackReadNew
      ;;
   check-folder)
      slackCheckInstalledFolder
      ;;
   check-installed)
      slackCheckInstalled
      ;;
   check-dublicates)
      slackCheckDublicates
      ;;
   remove-dublicates)
      slackRemoveDublicates
      ;;
   help)
      slackHelp ${INPUT[@]}
      ;;
   --help)
      slackHelp ${INPUT[@]}
      ;;
   -h)
      slackHelp ${INPUT[@]}
      ;;
   *)
      command slackpkg ${INPUT[@]} 
      ;;
esac