#!/bin/bash
#
# Script to start khanat server
#
#    Copyright (C) 2017  AleaJactaEst
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.


declare -i IMAGE=1
declare -i BASICSERVER=0
declare -i KHANATSERVER=0
declare -i KHANATRESSOURCES=0
declare -i KHANATDATACLIENT=0
declare -i RYZOMRESSOURCES=0
declare -i LAUNCHKHANAT=1
declare -i DEBUG=0
declare -i AUTODETEC=1
declare -i STOPKHANAT=0
declare -i CLEANCONTAINERKHANAT=0
declare -i CONNECTSSHKHANAT=0
declare -i KHANAT_CLIENT_VERSION=1
declare -i SHOWIPKHANATSERVER=0
declare -i METHODSTARTSERVER=1
declare -i CLEANIMAGENONE=0
declare DOCKERBUILDOPT=""

declare IMAGEGENERICSERVER="server_generic_debian_jessie_x86_64"
declare IMAGEKHANATSERVER="server_khanat_debian_jessie_x86_64"
declare LOCALBUILDDIR="build/builder_khanat_debian_jessie_x86_64"

usage()
{
cat << EOF
usage:$0 [options]
  script to build under docker

  Step: 
   1) generate tar with khanat-ressources
   2) generate tar with ryzom-ressources
   3) create image basic server
   4) create image khanat server
   5) launch khanat server

options:
  -h, --help        : Show this help
  -d, --debug       : Show debug message
  -b, --force-basic : Force create/recreate image basic server
  -t, --force-tar-ressources : Generate TAR.GZ for khanat-ressources (look directory ../khanat-ressources)
  -q, --force-tar-data-client : Generate TAR.GZ for khanat-data-client (look directory ../khanat-data-client)
  -z, --force-tar-ryzom-ressources : Generate TAR.GZ in data khanat-code
  -k, --force-khanat : Force create/recreate image khanat server
  -n, --no-launch-khanat : Doesn't launch khanat server
  -s, --stop-server : Stop server khanat
  -c, --clean-container-khanat : Remove old server khanat (stopped)
  -w, --clean-images-none : Remove images docker (with name 'none')
  -i, --show-ip-khanat-server : show ip address for khanat server (launch under docker)
  --start-khanat-with-screen : [default] start khanat with screen 
  --start-khanat-with-full-log : start server khanat and show full log
  --start-khanat-with-watch-state : start server khanat and show state (loop)
  --ssh : connect on khanat server (with ssh) [Exclusive action, can't execute other action]
  --client-version=[INTEGER] : version client khanat (we need to communicate with our server)
  
Example :
  cd [root Khanat directory]
  ./server.sh
  ./server.sh -k
  ./server.sh --ssh
EOF
}

function msg_debug()
{
   if [[ $DEBUG -ne 0 ]]
   then
      echo "$(date "+%Y/%m/%d %H:%M:%S") DEBUG - $*"
   fi
}

function msg_info()
{
   echo "$(date "+%Y/%m/%d %H:%M:%S") INFO - $*"
}

function msg_error()
{
   echo "$(date "+%Y/%m/%d %H:%M:%S") ERROR - $*" >&2
}

#
# MAIN
#

#msg_info "START"

calldir="$(dirname $0)"
basedir=$(cd $calldir; pwd)
rootdir="$(dirname $(dirname $(dirname $(dirname $(dirname $(dirname ${basedir}))))))"
ressourcedir="$(dirname ${rootdir})/khanat-ressources"
dataclientdir="$(dirname ${rootdir})/khanat-data-client"

while test $# -gt 0
do
   case "$1" in
      -h|--help)
         usage
         exit 1
         ;;
      -d|--debug) 
         DEBUG=1
         shift
         ;;
      --ssh)
         CONNECTSSHKHANAT=1
         shift
         ;;
      -c|--clean-container-khanat)
         CLEANCONTAINERKHANAT=1
         shift
         ;;
      -s|--stop-server)
         STOPKHANAT=1
         shift
         ;;
      -b|--force-basic)
         BASICSERVER=1
         DOCKERBUILDOPT="$DOCKERBUILDOPT --no-cache"
         shift
         ;;
      -n|--no-launch-khanat)
         LAUNCHKHANAT=0
         shift
         ;;
      -t|--force-tar-ressources)
         KHANATRESSOURCES=1
         shift
         ;;
      -q|--force-tar-data-client)
         KHANATDATACLIENT=1
         shift
         ;;
      -z|--force-tar-ryzom-ressources)
         RYZOMRESSOURCES=1
         shift
         ;;
      -k|--force-khanat)
         KHANATSERVER=1
         shift
         ;;
      -i|--show-ip-khanat-server)
         SHOWIPKHANATSERVER=1
         shift
         ;;
      --start-khanat-with-screen)
         METHODSTARTSERVER=1
         shift
         ;;
      --start-khanat-with-full-log)
         METHODSTARTSERVER=2
         shift
         ;;
      --start-khanat-with-watch-state)
         METHODSTARTSERVER=3
         shift
         ;;
      --client-version*)
         KHANAT_CLIENT_VERSION="${1#*=}"
         shift
         ;;
      -w|--clean-images-none)
         CLEANIMAGENONE=1
         shift
         ;;
      *)
         msg_error "options '$1' not recoginze"
         usage
         exit 1
         ;;
   esac
done

function chrashed()
{
   msg_error "BUILD FAILED (code:$?)"
   exit 2
}

trap chrashed EXIT

if [[ $SHOWIPKHANATSERVER -eq 0 ]]
then
   msg_info "START"
fi

msg_debug "prg: $0"

docker -v 1>/dev/null
if [[ $? -ne 0 ]]
then
   msg_error "docker not installed"
   exit 2
fi

case "$(uname -m)" in
  x86_64)
     ;;
  i686)
     msg_error "Bad Archi"
     exit 2
     ;;
  *)
     msg_error "Unknown archi : $(uname -m)"
     exit 2
     ;;
esac

if [[ ($CONNECTSSHKHANAT -ne 0) || ($SHOWIPKHANATSERVER -ne 0) ]]
then
   listcontainer="$(docker ps -qf 'status=running' -f 'ancestor='"${IMAGEKHANATSERVER}"'')"
   if [[ ${#listcontainer[@]} -eq 1 ]]
   then
      ipaddress=$(docker inspect --format="{{ .NetworkSettings.IPAddress }}" ${listcontainer[@]})
   fi
fi

if [[ $SHOWIPKHANATSERVER -ne 0 ]]
then
   trap '' EXIT
   echo "$ipaddress"
   exit 0
fi

if [[ $CONNECTSSHKHANAT -ne 0 ]]
then
   ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@$ipaddress
   trap '' EXIT
   msg_info "END SSH"
   exit 0
fi

if [[ $AUTODETEC -ne 0 ]]
then
   if [[ $(docker images -f "reference=$IMAGEGENERICSERVER" | wc -l) -lt 2 ]]
   then
      BASICSERVER=1
   fi
   if [[ ! -f ${rootdir}/khanat-ressources.tar.gz  ]]
   then
      KHANATRESSOURCES=1
   fi
   if [[ ! -f ${rootdir}/khanat-data-client.tar.gz  ]]
   then
      KHANATDATACLIENT=1
   fi
   if [[ ! -f ${rootdir}/ryzom-ressources.tar.gz ]]
   then
      RYZOMRESSOURCES=1
   fi
   if [[ $(docker images -f "reference=$IMAGEKHANATSERVER" | wc -l) -lt 2 ]]
   then
      KHANATSERVER=1
   fi

   if [[ -f ${rootdir}/ryzomcore.tar.gz ]]
   then
      sumsrc=$(md5sum ${rootdir}/code/${LOCALBUILDDIR}/ryzomcore-0.12.0..tar.gz | awk '{print $1}')
      sumdst=$(md5sum ${rootdir}/ryzomcore.tar.gz | awk '{print $1}')
   else
      sumsrc=1
      sumdsr=2
   fi
   msg_debug "ryzomcore checksum src:$sumsrc dst:$sumdst"
   if [[ "$sumsrc" != "$sumdst" ]]
   then
      msg_debug "copy ryzomcore"
      cp ${rootdir}/code/${LOCALBUILDDIR}/ryzomcore-0.12.0..tar.gz ${rootdir}/ryzomcore.tar.gz || exit 2
      KHANATSERVER=1
   fi
fi

DIRBUILD="${rootdir}/code/${LOCALBUILDDIR}"

msg_debug "calldir: $calldir"
msg_debug "basedir: $basedir"
msg_debug "rootdir: $rootdir"
msg_debug "ressourcedir: $ressourcedir"
msg_debug "generate basic image: $BASICSERVER"
msg_debug "generate tar khanat ressources: $KHANATRESSOURCES"
msg_debug "generate tar khanat data client: $KHANATDATACLIENT"
msg_debug "generate tar ryzom ressources: $RYZOMRESSOURCES"
msg_debug "generate khanat image: $KHANATSERVER"
msg_debug "launch khanat: $LAUNCHKHANAT"
msg_debug "stop khanat: $STOPKHANAT"

if [[ $KHANATRESSOURCES -ne 0 ]]
then
   msg_info "CREATE TAR with KHANAT Ressources"
   if [[ ! -d ${ressourcedir} ]]
   then
      msg_error "Missing khanat-ressources directory ($ressourcedir)"
      exit 2
   fi
   (cd $ressourcedir; tar --exclude='.git' -czf ${rootdir}/khanat-ressources.tar.gz .) || exit 2
fi

if [[ $KHANATDATACLIENT -ne 0 ]]
then
   msg_info "CREATE TAR with KHANAT DATA CLIENT"
   if [[ ! -d ${dataclientdir} ]]
   then
      msg_error "Missing khanat-data-client directory ($dataclientdir)"
      exit 2
   fi
   (cd $dataclientdir; tar --exclude='.git' -czf ${rootdir}/khanat-data-client.tar.gz .) || exit 2
fi

if [[ $RYZOMRESSOURCES -ne 0 ]]
then
   msg_info "CREATE TAR with RYZOM Ressources"
   if [[ ! -d ${ressourcedir} ]]
   then
      msg_error "Missing khanat-ressources directory ($ressourcedir)"
      exit 2
   fi
   cd ${rootdir}; tar czf ryzom-ressources.tar.gz \
           code/ryzom/server/shard.screen.rc \
           code/ryzom/common/* \
           code/ryzom/client/* \
           code/ryzom/server/* \
           code/ryzom/tools/scripts/linux/* \
           code/web/* || exit 2
fi

if [[ $STOPKHANAT -ne 0 ]]
then
   msg_info "STOP SERVER KHANAT"
   listcontainer="$(docker ps -qf 'status=running' -f 'ancestor='"${IMAGEKHANATSERVER}"'')"
   msg_debug "CONTAINER KHANAT UP : ${listcontainer[@]}"
   if [[ -n "$listcontainer" ]]
   then
      docker stop "$listcontainer" || exit 2
   fi
fi

if [[ $CLEANCONTAINERKHANAT -ne 0 ]]
then
   msg_info "CLEAN CONTAINER KHANAT"
   listcontainer=( $(docker ps -qf 'status=exited' -f 'ancestor='"${IMAGEKHANATSERVER}"'') )
   msg_debug "CONTAINER KHANAT EXITED : ${listcontainer[@]}"
   if [[ -n "${listcontainer[@]}" ]]
   then
      docker rm --force "${listcontainer[@]}" || exit 2
   fi
fi

if [[ $CLEANIMAGENONE -ne 0 ]]
then
   msg_info "CLEAN IMAGE DOCKER 'NONE'"
   listimages=( $(docker images | awk '{if ($1=="<none>")print $3}') )

   msg_debug "IMAGES NONE : ${listimages[@]}"
   if [[ -n "${listimages[@]}" ]]
   then
      docker rmi --force "${listimages[@]}" || exit 2
   fi
fi

if [[ $BASICSERVER -ne 0 ]]
then
   msg_info "GENERATE DOCKER IMAGE BASIC SERVER"
   cd $rootdir; docker build . ${DOCKERBUILDOPT} -t ${IMAGEGENERICSERVER} \
           --file "${basedir}/Dockerfile" || exit 2
fi

if [[ $KHANATSERVER -ne 0 ]]
then
   msg_info "GENERATE DOCKER IMAGE KHANAT SERVER"
   cat << EOF > $rootdir/todelete.sh
#!/bin/bash
# Temporary file, use only to send some information on build docker
export KHANAT_CLIENT_VERSION=$KHANAT_CLIENT_VERSION
EOF
   cd $rootdir; docker build . -t ${IMAGEKHANATSERVER} \
           --file "${basedir}/Dockerfile.khanat" || exit 2
   rm $rootdir/todelete.sh
fi

if [[ $LAUNCHKHANAT -ne 0 ]]
then
   msg_info "START KHANAT SERVER"
   cd $rootdir; docker run -it --hostname=khanat ${IMAGEKHANATSERVER} /opt/autostart.sh $METHODSTARTSERVER
   clear
fi

trap '' EXIT
msg_info "END"