#!/bin/bash

SYNC_CMD="xfsync"
QSEE_CMD="qsee -l 96H"
#QSEE_CMD="qsee -b yyyy/mm/ddThh:mm:ss"
#QSEE_CMD="qsee -b yyyy/mm/ddThh:mm:ss -e yyyy/mm/ddThh:mm:ss"
QS_CONF=""
UPDATE_OPT=""
VERBOSE="N"
PARALLEL="Y"
unset DO_QSEE
unset DO_SYNC

declare -a sync_pid
declare -a qs_pid
declare -a QS_JOBS
declare -a XFS_JOBS

#################################
# name: printUsage
# description: print use message
# args: none
#################################
printUsage(){
    echo
    echo "Description: $description"
    echo
    echo "usage: `basename $0` [options]"
    echo "Options:"
    echo "  -f <file> : config file"
    echo "  -Q : run qsee jobs"
    echo "  -S : run sync jobs"
    echo "  -p : disable parallel processing"
    echo "  -q <qsee> : qsee job/config file"
    echo "  -s <sync> : xfsync job/config file"
    echo "  -v        : verbose output   [$VERBOSE]"
    echo "  -h        : print use message"
    echo ""
    echo "Examples:"
    echo " `basename $0` -Qf /path/to/config"
    echo " `basename $0` -Sf /path/to/config"
    echo " `basename $0` -QSf /path/to/config"
    echo " `basename $0` -s /path/to/xfsync.conf -q /path/to/qsee.conf"
    echo
}

########################################
# name: getPID
# description: get PID of target process
# args:
#     process name
########################################
getPID(){
    local pid=`ps -C ${1} -o pid=`
    echo $pid
}

########################################
# name: vout
# description: print verbose message to stderr
# args:
#     msg: message
########################################
vout(){
    if [ "${VERBOSE}" == "Y" ] || [ "${VERBOSE}" == "TRUE" ]
    then
	echo "$1" >&2
    fi
}

########################################
# name: processCmdLine
# description: do command line processsing
# args:
#     args:       positional paramters
#     returnCode: none
########################################
processCmdLine(){
	OPTIND=1
	vout "`basename $0` all args[$*]"

while getopts f:Qpq:Ss:hv Option
	do
		vout "processing $Option[$OPTARG]"
		case $Option in
            f ) IFILE=$OPTARG
            ;;
            q ) QS_JOBS[${#QS_JOBS[@]}]=$OPTARG
            ;;
            s ) XFS_JOBS[${#XFS_JOBS[@]}]=$OPTARG
            ;;
            p) PARALLEL="N"
            ;;
            Q) DO_QSEE="Y"
            ;;
            S) DO_SYNC="Y"
            ;;
            h ) printUsage
                exit 0
            ;;
            v ) VERBOSE="TRUE"
            ;;
			*) exit 0 # getopts outputs error message
			;;
		esac
	done
}

########################################
# name: pid_wait
# description: wait for array of PIDs
# args:
# msg: message
########################################
wait_pid(){
    vout "`basename $0`:wait_pid - pids[$*]"

    read -a pid_list <<< "$*"

   for next_pid in "${pid_list[@]}"
    do
    if [ "$next_pid" ]
    then
        vout "`basename $0`:wait_pid - waiting for pid [$next_pid]"
        wait $next_pid
    fi
    done
}


########################################
# name: run_sync_jobs
# description: run archive sync jobs
# args:
# msg: message
########################################
run_sync_jobs(){
    for job in "${XFS_JOBS[@]}"
    do
        # sync archives
        vout ">>>> `basename $0` pid[$$] starting sync[$job]"
        $SYNC_CMD -f $job &>> ${CRON_LOG} &
        test_ret=$?
        pid=$!
        if [ "${test_ret}" == 0 ]
        then
            sync_pid[${#sync_pid[@]}]=$pid
        fi
    done

    # wait for them to finish
    wait_pid "${sync_pid[@]}"
}

########################################
# name: run_qs_jobs
# description: run qsee (plot) jobs
# args:
# msg: message
########################################
run_qs_jobs(){
    for job in "${QS_JOBS[@]}"
    do
        # sync archives
        vout ">>>> `basename $0` pid[$$] starting qs[$job]"
        if [ "${PARALLEL}" == "Y" ]
        then
            $QSEE_CMD -f $job &>> ${CRON_LOG} &
            test_ret=$?
            pid=$!
            if [ "${test_ret}" == 0 ]
            then
            qs_pid[${#qs_pid[@]}]=$pid
            fi
        else
            $QSEE_CMD -f $job &>> ${CRON_LOG}
            test_ret=$?
        fi
    done

    # wait for them to finish
    wait_pid "${qs_pid[@]}"
}

########################################
# name: dumpConfig
# description: show configuration
# args: none
# returnCode: none
########################################
dumpConfig(){
    vout "####### `basename $0` pid $$ config:"
    vout "IFILE         : ${IFILE}"
    vout "DO_QSEE       : ${DO_QSEE}"
    vout "DO_SYNC       : ${DO_SYNC}"
    vout "QS_OPATH      : ${QS_OPATH}"
    vout "QP_OPATH      : ${QP_OPATH}"
    vout "VERBOSE       : ${VERBOSE}"
    vout "ARGS          : ${*}"
}

# process options
processCmdLine $*

# set environment, define tasks
if [ "${IFILE}" ] && [ -f "${IFILE}" ]
then
    source ${IFILE}
fi

# set xfhome environment
XFHOME=${XFHOME:-"/home/ops/xfoce"}
source $XFHOME/src/scripts/xfenv $XFHOME &> /dev/null

# initialize log
CRON_LOG=${CRON_LOG:-"`basename $0`.log"}

if [ "${CRON_LOG_DIR}" ] && [ -d "${CRON_LOG_DIR}" ]
then
    tmp="${CRON_LOG_DIR}/${CRON_LOG}"
    CRON_LOG=${tmp}
fi

if [ -f "${CRON_LOG}" ]
then
    rm ${CRON_LOG}
fi

# show config (if verbose)
dumpConfig

echo "### `basename $0` `date` log[$CRON_LOG] " &> ${CRON_LOG}

if [ "${DO_SYNC}" == "Y" ]
then
    # run sync jobs...
    run_sync_jobs
else
    vout "skipping sync jobs"
fi

if [ "${DO_QSEE}" == "Y" ]
then
    # run qsee jobs...
    run_qs_jobs
else
    vout "skipping QC jobs"
fi

exit 0
