# If you want CAN messaging to S3, make sure that you source can_messaging_functions and can_messaging_ids
#

if [ "$HAS_DEBUGGING_FUNCTIONS" != "yes" ]; then
. /etc/ags-celestia/debugging_functions
fi

HAS_AD_DMU_FUNCTIONS="yes"

DMU_FW_VERSION_CHECK_SCRIPT="dmu_version_check.sh"
DMU_FW_VERSION_CHECK_CMD="/bin/dmu_test -v"
DMU_FW_LOADER_CMD="ad_dmu_fwloader"
DMU_RESET_CMD="reset_dmu"


DMU_FIRMWARE_DIR="/lib/firmware/ags-ins-ad-dmu"
DMU_FIRMWARE_FILE=`ls -1 ${DMU_FIRMWARE_DIR}/AD_DMU_*.ldr | head -1`
DMU_FIRMWARE_NAME=`echo ${DMU_FIRMWARE_FILE} | sed "s/\/lib\/firmware\/ags-ins-ad-dmu\/\(.*\)/\1/"`

STOP_START_CELESTIA=1

DMU_FIRMWARE_UPDATE_REQUIRED=1

CURRENT_DMU_FIRMWARE_VERSION=0
PACKAGED_DMU_FIRMWARE_VERSION=0

function get_packaged_dmu_firmware_version
{
    debug_function "get_packaged_dmu_firmware_version"

    if [ "x${DMU_FIRMWARE_NAME}" != "x" ]; then
        PACKAGED_DMU_FIRMWARE_VERSION=`echo ${DMU_FIRMWARE_NAME} | sed "s/AD_DMU_\([0-9]*\)\.ldr/\1/"`
        debug_information "get_packaged_dmu_firmware_version - packaged DMU firmware version = $PACKAGED_DMU_FIRMWARE_VERSION"
    else
        echo "AD_DMU firmware update check script failed!"
    fi
}

# @param $1 restat celestia if stopped
function get_current_dmu_firmware_version
{
    debug_function "get_current_dmu_firmware_version"

    local RESTART_CELESTIA_IF_STOPPED=0
    local CELESTIA_WAS_STOPPED=0
    local CELESTIA_WAS_RUNNING=0
    local RESULT=1
    local LOOP=5

    if [ $# -eq 1 ]; then
        if [ $1 -eq 1 ]; then
            RESTART_CELESTIA_IF_STOPPED=1
        fi
    fi

    if [ $( ps ax | grep -v grep | grep Control | wc -c ) -gt 0 ]; then
        CELESTIA_WAS_RUNNING=1
    fi

    if [ "$CELESTIA_WAS_RUNNING" -eq 1 ]; then
        CELESTIA_WAS_STOPPED=1
        invoke-rc.d celestia stop
    fi


    debug_information "get_current_dmu_firmware_version - attempting to retrieve DMU version"

    while [ $LOOP -gt 0 ]
    do
        debug_information "get_current_dmu_firmware_version - $LOOP attempts left"
        echo "Getting current DMU firmware version - $LOOP attempts left"

        $DMU_RESET_CMD
        
        CURRENT_DMU_FIRMWARE_VERSION=`$DMU_FW_VERSION_CHECK_CMD`

        RESULT=$?

        if [ $RESULT -eq 0 ]
        then
            debug_information "get_current_dmu_firmware_version - current DMU firmware version = $CURRENT_DMU_FIRMWARE_VERSION"
            echo "Current DMU firmware version = $CURRENT_DMU_FIRMWARE_VERSION"
            LOOP=0
        else
            debug_information "get_current_dmu_firmware_version - Failed to get current DMU firmware version - Using $CURRENT_DMU_FIRMWARE_VERSION"
            echo "Failed to get current DMU firmware version"
            LOOP=`expr $LOOP - 1`
        fi
    done

    if [ "$CELESTIA_WAS_STOPPED" -eq 1 ]; then
        if [ $RESTART_CELESTIA_IF_STOPPED -eq 1 ]; then
            invoke-rc.d celestia start
        else
            STOP_START_CELESTIA=1
        fi
    fi
}

function check_dmu_firmware_update_required
{
    debug_function "check_dmu_firmware_update_required"

    if [ $CURRENT_DMU_FIRMWARE_VERSION -eq 0 ]; then
        get_current_dmu_firmware_version 1
    fi

    if [ $PACKAGED_DMU_FIRMWARE_VERSION -eq 0 ]; then
        get_packaged_dmu_firmware_version
    fi

    if [[ "$CURRENT_DMU_FIRMWARE_VERSION" -eq "$PACKAGED_DMU_FIRMWARE_VERSION" ]]; then
        DMU_FIRMWARE_UPDATE_REQUIRED=0
    else
        DMU_FIRMWARE_UPDATE_REQUIRED=1
    fi

    debug_information "check_dmu_firmware_update_required - required = $DMU_FIRMWARE_UPDATE_REQUIRED"
}

function parse_progress
{
    debug_function "parse_progress"

    local RETURN_FILE=$1

    read line
    if [ "x$line" != "x" ]; then
        if [ "$HAS_CAN_MESSAGING_FUNCTIONS" = "yes" ]; then
            PROGRESS=$(echo $line | sed "s/.*\. \([0-9].*\)%/\1/")
            if [ "x$PROGRESS" != "x" ]; then
                PERCENTAGE=$(echo $PROGRESS | sed "s/\([0-9]*\)\.[0-9]/\1/")
                send_update_progress_message $UPDATE_PROGRESS_MSG_ID_DMU_FIRMWARE_FLASH $PERCENTAGE

                if [ $PERCENTAGE -ge 100 ]; then
                    rm -rf $RETURN_FILE
                fi
            fi
        else
            PROGRESS=$(echo $line | sed "s/.*\]: \(.*\)$/\1/")
            echo $PROGRESS
        fi
    fi
}

function do_dmu_update_progress_messaging
{
    debug_function "do_dmu_update_progress_messaging"

    local PID=$1
    local RETURN_FILE=$2
    local RETURN_FILE2=$3

    tail -f /var/log/messages --pid=$PID | while read line; do echo $line | grep $DMU_FW_LOADER_CMD | grep $PID | grep % | parse_progress $RETURN_FILE2; done

    rm -rf $RETURN_FILE
}

# @param $1 number of times to loop. 0 = infinite
function do_dmu_firmware_update_loop
{
    debug_function "do_dmu_firmware_update_loop"

    local DMU_FW_LOADER_PID=0
    local DMU_FW_LOADER_RESULT=-1
    local LOOP=0
    local COUNT=0

    if [ $1 ]; then
        if [ $(echo "$1" | grep -E "^[0-9]+$") ]; then
            LOOP=$1
        fi
    fi

    if [ $( ps ax | grep -v grep | grep Control | wc -c ) -eq 0 ]; then
        STOP_START_CELESTIA=0
    fi

    if [ "$STOP_START_CELESTIA" -eq 1 ]; then
        invoke-rc.d celestia stop
    fi

    check_dmu_firmware_update_required

    while [ "$DMU_FIRMWARE_UPDATE_REQUIRED" -eq 1 ]; do
        COUNT=`expr $COUNT + 1`

        echo "Loading DMU firmware - attempt ${COUNT}/${LOOP} - please wait..."

        if [ "$HAS_CAN_MESSAGING_FUNCTIONS" = "yes" ]; then
            # Reset the progress bar on the S3
            send_update_progress_message $UPDATE_PROGRESS_MSG_ID_DMU_FIRMWARE_FLASH 0
            # Send a fake 1% message to make sure the progress bar is displayed on the S3
            send_update_progress_message $UPDATE_PROGRESS_MSG_ID_DMU_FIRMWARE_FLASH 1
        fi

        # Reset the DMU
        $DMU_RESET_CMD
        $DMU_FW_LOADER_CMD $DMU_FIRMWARE_FILE >/dev/null &
        DMU_FW_LOADER_PID=$!

        # Generate temporary files for return results
        TEMP_FILE=$(tempfile -p parser -s .txt )
        touch $TEMP_FILE

        COMPLETED_FILE=$(tempfile -p completed -s .txt )
        touch $COMPLETED_FILE

        do_dmu_update_progress_messaging $DMU_FW_LOADER_PID $TEMP_FILE $COMPLETED_FILE &

        wait $DMU_FW_LOADER_PID

        while [ -e $TEMP_FILE  ]; do
            sleep 5
        done;

        # What what what?
        #DMU_FW_LOADER_RESULT=$?

        if [ ! -e $COMPLETED_FILE ]; then
            if [ "$HAS_CAN_MESSAGING_FUNCTIONS" = "yes" ]; then
                send_update_progress_message $UPDATE_PROGRESS_MSG_ID_DMU_FIRMWARE_FLASH_COMPLETE 100
            fi

            get_current_dmu_firmware_version

            check_dmu_firmware_update_required
        fi

        if [ $LOOP -ne 0 ]; then
            if [ $COUNT -ge $LOOP ]; then
                DMU_FIRMWARE_UPDATE_REQUIRED=0
            fi
        fi
    done

    if [ "$STOP_START_CELESTIA" -eq 1 ]; then
        # Check whether celestia has already been restarted
        if [ $( ps ax | grep -v grep | grep Control | wc -c ) -gt 0 ]; then
            STOP_START_CELESTIA=0
        fi
    fi

    if [ "$STOP_START_CELESTIA" -eq 1 ]; then
        invoke-rc.d celestia start
    fi
}
