#!/bin/sh
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # #       EXECUTION ORDER       # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#                                   |                                      |                                    #
#   INSTALLATION                    |   UPGRADE                            |    UNINSTALLATION                  #
#                                   |                                      |                                    #
#      prereplace                   | (->) start-stop-status prestop       | (->) start-stop-status prestop     #
#      preinst                      |  ->  start-stop-status stop          |  ->  start-stop-status stop        #
#      postinst                     |      preupgrade                      |      preuninst                     #
#      postreplace                  |      preuninst                       |      postuninst                    #
# (->) start-stop-status prestart   |      postuninst                      |                                    #
#  ->  start-stop-status start      |      prereplace                      |                                    #
#                                   |      preinst                         |                                    #
#                                   |      postinst                        |                                    #
#   START                           |      postreplace                     |                                    #
#                                   |      postupgrade                     |                                    #
# (->) start-stop-status prestart   | (->) start-stop-status prestart      |                                    #
#  ->  start-stop-status start      |  ->  start-stop-status start         |                                    #
#                                   |                                      |                                    #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

# Package
DNAME="Roon Server"
SPK_ROOT="/var/packages/${SYNOPKG_PKGNAME}"
SPK_ETC="${SPK_ROOT}/etc"
ROON_ID_DIR="${SYNOPKG_PKGHOME}/id/"
ROON_TMP_DIR="${SPK_ROOT}/tmp"
ROON_DATABASE_SHARE="$(get_section_key_value ${SPK_ETC}/RoonServer.ini General database_dir)"
ROON_DATABASE_SHARE_PATH="${SPK_ROOT}/shares/${ROON_DATABASE_SHARE}" 
ROON_DATABASE_DIR="${ROON_DATABASE_SHARE_PATH}/RoonOnNAS"
ROON_LOG_FILE="${ROON_DATABASE_DIR}/RoonOnNAS.log.txt"
ARCH=$(uname -m)
ROON_PIDFILE="${SPK_ROOT}/tmp/RoonServer.pid"
SYNO_MODEL="$(cat /proc/sys/kernel/syno_hw_version)"
SYNO_VERSION="$(get_key_value /etc.defaults/VERSION productversion)"
SYNO_BUILD="$(get_key_value /etc.defaults/VERSION buildnumber)"
SYNO_SMALL_FIX="$(get_key_value /etc.defaults/VERSION smallfixnumber)"
ROON_VERSION=`cat "${SPK_ROOT}/target/RoonServer/VERSION"`
MTU=`ifconfig | grep eth[0-9] -A1 | grep MTU | cut -d ":" -f 2 | awk '{print $1}' | xargs | sed "s/ ---- /\n---- /g"`
ROON_ARGS="-noraatserver"

ST_COLOR="\033[38;5;34m"
HL_COLOR="\033[38;5;197m"
REG_COLOR="\033[0m"

## Log Function
echolog() {
    TIMESTAMP=$(date +%d.%m.%y-%H:%M:%S)
    if [[ $# == 2 ]]; then
        PARAMETER1=$1
        PARAMETER2=$2
        echo -e "${ST_COLOR}${TIMESTAMP}${REG_COLOR} --- ${HL_COLOR}${PARAMETER1}:${REG_COLOR} ${PARAMETER2}"
        echo "${TIMESTAMP} --- ${PARAMETER1}: ${PARAMETER2}" >> $ROON_LOG_FILE
    elif [[ $# == 1 ]]; then
        PARAMETER1=$1
        echo -e "${ST_COLOR}${TIMESTAMP}${REG_COLOR} --- ${PARAMETER1}"
        echo "${TIMESTAMP} --- ${PARAMETER1}" >> $ROON_LOG_FILE
    else
        echo -e "The echolog function requires 1 or 2 parameters."
    fi
}

if [[ $SYNO_SMALL_FIX -gt 0 ]]; then
   SYNO_SMALL_FIX="(Update ${SYNO_SMALL_FIX})"
else
   SYNO_SMALL_FIX="";
fi

info ()
{
    ## Echoing System Info
    echolog "ROON_DATABASE_DIR" "${ROON_DATABASE_DIR}"
    echolog "ROON_DIR" "${SPK_ROOT}"
    echolog "Model" "${SYNO_MODEL}"
    echolog "Architecture" "${ARCH}"
    echolog "DSM Version" "${SYNO_VERSION} ${SYNO_SMALL_FIX}"
    echolog "PKG Version" "${SYNOPKG_PKGVER}"
    echolog "Hostname" "${HOSTNAME}"
    echolog "MTU" "${MTU}"
}

start_daemon ()
{
  info
    # Launch the service in the background if RoonServer share exists.
    if [[ "$ROON_DATABASE_SHARE_PATH" != "" ]] && [ -d "$ROON_DATABASE_DIR" ]; then

        if [[ -f $ROON_DATABASE_DIR/ROON_DEBUG_LAUNCH_PARAMETERS.txt ]]; then
            ROON_ARGS="$ROON_ARGS $(cat $ROON_DATABASE_DIR/ROON_DEBUG_LAUNCH_PARAMETERS.txt)"
        fi
        
        if [ ! -d ${ROON_ID_DIR} ]; then
            mkdir ${ROON_ID_DIR}
        fi

        echolog "ROON_DEBUG_ARGS" "${ROON_ARGS}"
        # Launch RoonServer
        export ROON_DATAROOT=${ROON_DATABASE_DIR}
        export ROON_INSTALL_TMPDIR="${ROON_TMP_DIR}"
        export TMP="${ROON_TMP_DIR}"
        export PATH=${ROON_DATABASE_DIR}/bin:$PATH
        export ROON_ID_DIR
        
        # check if ffmpeg exists and is executable
        [ -f "${ROON_DATABASE_DIR}/bin/ffmpeg" ] && [ ! -x "${ROON_DATABASE_DIR}/bin/ffmpeg" ] && chmod +x "${ROON_DATABASE_DIR}/bin/ffmpeg" 
        echolog "ffmpeg" "$(which ffmpeg)"
        
        # Roon tries on launch to set open files limit to 8096. This will fail due to its hard limit. So we are increasing it to the max possible value...
        openFilesHardLimit=$(ulimit -Hn)
        if [ $openFilesHardLimit -lt 8192 ]; then
          ulimit -n $openFilesHardLimit
        fi
        
        ${SPK_ROOT}/target/RoonServer/start.sh $ROON_ARGS &
        echo $! > ${ROON_PIDFILE}

        echolog "RoonServer PID" "`cat ${ROON_PIDFILE}`"

        echo "" | tee -a "${ROON_LOG_FILE}"
        echo "" | tee -a "${ROON_LOG_FILE}"
        echo "########## Installed RoonServer Version ##########" | tee -a "${ROON_LOG_FILE}"
        echo "${ROON_VERSION}" | tee -a "${ROON_LOG_FILE}"
        echo "##################################################" | tee -a "${ROON_LOG_FILE}"
        echo "" | tee -a "${ROON_LOG_FILE}"
        echo "" | tee -a "${ROON_LOG_FILE}"
    else
        echolog "RoonServer shared folder does not exist or external storage device has not been setup properly."
        return 1
    fi

}

roon_state ()
{
  # If no PID file, it's stopped (1)
  [ ! -f "$ROON_PIDFILE" ] && return 1

  # Return true (0) if PID file exists
  [ -d /proc/`cat "$ROON_PIDFILE"` ] && return 0

  # The PID file is pointing off to something bad. (implied stopped state)
  return 1
}

stop_daemon ()
{
   if [ -r "$ROON_PIDFILE" ]; then
   PID=$(cat "$ROON_PIDFILE")
      
   kill -TERM "$PID" >> /dev/null 2>&1
   wait_for_status 1 || kill -KILL "$PID" >> /dev/null 2>&1
      
   [ -f "$ROON_PIDFILE" ] && rm -f "$ROON_PIDFILE" >> /dev/null 2>&1
   fi
      
   return 0
      
   Pids="$(ps -ef | grep RoonServer | awk '{print $2}')"
      
   Count=10
   Sig=-9
      
   while [ "$Pids" != "" ] && [ $Count -gt 0 ]
      do
         kill $Sig $Pids
         sleep 5
      
         Pids="$(ps -ef | grep RoonServer | awk '{print $2}')"
         Count=$(($Count -1))
      
         if [ $Count -eq 1 ]; then
            Sig=-11
         fi
      done
   return 0
}

wait_for_status ()
{
  counter=20 # 20 seconds
  while [ ${counter} -gt 0 ]; do
    roon_state
    [ $? -eq "$1" ] && return
    counter=$((counter-1))
    sleep 1
  done
  return 1
}

case $1 in
    start)
        if roon_state; then
            echo "${DNAME} is already running"
            exit 0
        else
            echo "" > $ROON_LOG_FILE
            echo "Starting ${DNAME} ..."
            start_daemon
            exit 0
        fi
        ;;
    stop)
        if roon_state; then
            echo "Stopping ${DNAME}..."
            stop_daemon
            exit 0
        else
            echo ${DNAME} is not running
            exit 0
        fi
        ;;
    status)
        if roon_state; then
            echo ${DNAME} is running
            exit 0
        else
            echo ${DNAME} is not running
            exit 3
        fi
        ;;
    *)
        exit 1
        ;;
esac