/**************************************************************************
*
* Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
*
* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
*
* @file Prime.c
*
* @author (last) Quang Nguyen
* @date (last) 08-Dec-2020
*
* @author (original) Quang Nguyen
* @date (original) 08-Dec-2020
*
***************************************************************************/

#include "AirTrap.h"
#include "AlarmMgmt.h"
#include "BloodFlow.h"
#include "DialInFlow.h"
#include "DialOutFlow.h"
#include "DGInterface.h"
#include "Prime.h"
#include "SelfTests.h"
#include "SystemCommMessages.h"
#include "TaskGeneral.h"
#include "Timers.h"
#include "Valves.h"

/**
 *  @addtogroup Prime
 *  @{
 */

// ********** private definitions **********

#define MAX_PRIME_TIME                          ( 10 * SEC_PER_MIN )                                ///< Maximum prime time (in seconds).
#define PRIME_DATA_PUB_INTERVAL                 ( MS_PER_SECOND / TASK_GENERAL_INTERVAL )           ///< Interval (ms/task time) at which the prime data is published on the CAN bus.

#define BLOOD_PUMP_FLOW_RATE_PURGE_AIR          500                                                 ///< Blood pump flow rate during prime purge air state.
#define BLOOD_PUMP_FLOW_RATE_CIRC_BLOOD_CIRCUIT 300                                                 ///< Blood pump flow rate during prime recirculate blood circuit state.

#define DIALYSATE_PUMP_PRIME_FLOW_RATE          300                                                 ///< Dialysate pump flow rate during priming fluid path.
#define LOAD_CELL_VOLUME_NOISE_TOLERANCE        0.05                                                ///< Allow 5% tolerance on load cell readings.

#define NO_AIR_DETECTED_COUNT                   ( 20 * MS_PER_SECOND )                              ///< No air detected time period count.
#define PURGE_AIR_TIME_OUT_COUNT                ( 60 * MS_PER_SECOND )                              ///< Time period count for purge air time out.
#define MIN_LOAD_CELL_STEADY_VOLUME_TIME        ( 10 * MS_PER_SECOND )                              ///< Minimum time load cell reading need to remain steady in ms.
#define PRIME_DIALYSATE_DIALYZER_TIME_LIMIT     ( 120 * MS_PER_SECOND )                             ///< Time limit for priming dialysate dialyzer circuit.
#define PRIME_DIALYSATE_BYPASS_TIME_LIMIT       ( 120 * MS_PER_SECOND )                             ///< Time limit for priming dialysate bypass circuit.

/// States of the treatment reservoir management state machine.
typedef enum PrimeReservoirMgmt_States
{
    PRIME_RESERVOIR_MGMT_START_STATE = 0,                    ///< If DG not already in re-circ mode, try to get it there.
    PRIME_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE,               ///< In DG re-circ, wait for lines to flush - then start draining inactive reservoir.
    PRIME_RESERVOIR_MGMT_WAIT_FOR_DRAIN_CMD_RESP,            ///< After sending drain command, wait for DG to response back.
    PRIME_RESERVOIR_MGMT_DRAIN_STATE,                        ///< Wait for drain to complete.
    PRIME_RESERVOIR_MGMT_START_FILL_STATE,                   ///< Command DG to start filling reservoir.
    PRIME_RESERVOIR_MGMT_WAIT_FOR_FILL_CMD_RESP,             ///< After sending fill command, wait for DG to response back.
    PRIME_RESERVOIR_MGMT_FILL_STATE,                         ///< Wait for fill to complete.
    PRIME_RESERVOIR_MGMT_FILL_COMPLETE_STATE,                ///< Reservoir fill has completed.
    PRIME_RESERVOIR_MGMT_WAIT_RESERVOIR_TWO_INACTIVE,        ///< Wait for reservoir 2 become inactive.
    NUM_OF_PRIME_RESERVOIR_MGMT_STATES                       ///< Number of prime reservoir mgmt. states.
} PRIME_RESERVOIR_MGMT_STATE_T;

// ********** private data **********

static HD_PRE_TREATMENT_PRIME_STATE_T currentPrimeState;                                        ///< Current state of the prime sub-mode state machine.
static HD_PRE_TREATMENT_PRIME_STATE_T previousPrimeState;                                       ///< Previous state of the prime sub-mode, to use when resuming from pause.
static PRIME_RESERVOIR_MGMT_STATE_T currentReservoirMgmtState;                                  ///< Current reservoir management state.

static U32 primeStartTime;                                                                      ///< Starting time of priming (in ms).
static U32 primePauseStartTime;                                                                 ///< Priming pause start time (in ms).
static U32 primeStatusBroadcastTimerCounter;                                                    ///< Prime status data broadcast timer counter used to schedule when to transmit data.

static BOOL primeStartRequested;                                                                ///< Flag indicates user requesting to start prime.
static BOOL primeResumeRequested;                                                               ///< Flag indicates user requesting prime resume.

static U32 noAirDetectedStartTime;                                                              ///< starting time when detecting no air.
static U32 purgeAirTimeOutStartTime;                                                            ///< Starting time for purge air state time out.
static U32 primeDialysateDialyzerStartTime;                                                     ///< Starting time of priming dialysate dialyzer circuit.
static U32 primeDialysateBypassStartTime;                                                       ///< Starting time of priming dialysate bypass circuit.
static U32 previousLoadCellReading;                                                             ///< Previous load cell reading.
static U32 loadcellSteadyVolumeStartTime;                                                       ///< Load cell steady volume starting time.
static BOOL runBloodCircuitPrimeAgain;                                                          ///< Flag indicates HD should run blood circuit prime once more time.

// ********** private function prototypes **********

static void resetPrimeFlags();
static void setupForPrimePause( void );
static void broadcastPrimingStatus( void );
static void purgeAirValvesBloodPumpControl( void );

static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeWaitForUserStartState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeSalineSetupState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimePurgeAirState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeCircBloodCircuitState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeReservoirOneFillCompleteState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeDialysateDialyzerState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeReservoirTwoFillCompleteState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeDialysateBypassState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeWetSelfTestsState( void );
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimePause( void );

/*********************************************************************//**
 * @brief
 * The initPrime function initializes the prime sub-mode module.
 * This function will reset anything required before the start of priming sequence.
 * @details Inputs: none
 * @details Outputs: Prime sub-mode module initialized.
 * @return none
 *************************************************************************/
void initPrime( void )
{
    transitionToPrime();
}

/*********************************************************************//**
 * @brief
 * The transitionToPrime function prepares for transition to prime sub-mode.
 * This function will reset anything required before the start of priming sequence.
 * @details Inputs: none
 * @details Outputs: currentPrimeState, wetSelfTestsResult, primeStartReqReceived, reservoirFilledStatus[]
 * @return none
 *************************************************************************/
void transitionToPrime( void )
{
    currentPrimeState = HD_PRIME_START_STATE;
    currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_START_STATE;

    primeStartTime = getMSTimerCount();
    primePauseStartTime = 0;
    primeStatusBroadcastTimerCounter = 0;
    runBloodCircuitPrimeAgain = TRUE;

    setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, TRUE );
    setAlarmUserActionEnabled( ALARM_USER_ACTION_RINSEBACK, FALSE );
    setAlarmUserActionEnabled( ALARM_USER_ACTION_END_TREATMENT, TRUE );

    resetPrimeFlags();
}

/*********************************************************************//**
 * @brief
 * The execPrime function executes the prime sub-mode state machine.
 * @details Inputs: currentPrimeState
 * @details Outputs: currentPrimeState
 * @return none
 *************************************************************************/
void execPrime( void )
{
    // execute prime sub-mode state machine
    switch ( currentPrimeState )
    {
        case HD_PRIME_START_STATE:
#ifdef SKIP_PRIMING
            currentPrimeState = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE;
#else
            currentPrimeState = HD_PRIME_WAIT_FOR_USER_START_STATE;
#endif
            break;

        case HD_PRIME_WAIT_FOR_USER_START_STATE:
            currentPrimeState = handlePrimeWaitForUserStartState();
            break;

        case HD_PRIME_SALINE_SETUP_STATE:
            currentPrimeState = handlePrimeSalineSetupState();
            break;

        case HD_PRIME_SALINE_PURGE_AIR_STATE:
            currentPrimeState = handlePrimePurgeAirState();
            break;

        case HD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE:
            currentPrimeState = handlePrimeCircBloodCircuitState();
            break;

        case HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE:
            currentPrimeState = handlePrimeReservoirOneFillCompleteState();
            break;

        case HD_PRIME_DIALYSATE_DIALYZER_STATE:
            currentPrimeState = handlePrimeDialysateDialyzerState();
            break;

        case HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE:
            currentPrimeState = handlePrimeReservoirTwoFillCompleteState();
            break;

        case HD_PRIME_DIALYSATE_BYPASS_STATE:
            currentPrimeState = handlePrimeDialysateBypassState();
            break;

        case HD_PRIME_WET_SELF_TESTS_STATE:
            currentPrimeState = handlePrimeWetSelfTestsState();
            break;

        case HD_PRIME_COMPLETE:
            break;

        case HD_PRIME_PAUSE:
            currentPrimeState = handlePrimePause();
            break;

        default:
            currentPrimeState = HD_PRIME_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_PRE_TREATMENT_PRIME_INVALID_STATE, (U32)currentReservoirMgmtState );
            break;
    }

    // Prime flags should be handled by now
    resetPrimeFlags();

    // Broadcast priming data
    broadcastPrimingStatus();
}

/*********************************************************************//**
 * @brief
 * The getPrimeState function returns the current state of prime sub-mode.
 * @details Inputs: currentPrimeState
 * @details Outputs: none
 * @return current prime state
 *************************************************************************/
U32 getPrimeState( void )
{
    return (U32)currentPrimeState;
}

/*********************************************************************//**
 * @brief
 * The signalStartPrime function signals the prime sub-mode the user requested
 * to start priming operation.
 * @details Inputs: none
 * @details Outputs: primeStartRequested
 * @return none
 *************************************************************************/
void signalStartPrime( void )
{
    BOOL accepted = FALSE;
    REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NOT_ALLOWED_IN_CURRENT_MODE;

    if ( HD_PRIME_WAIT_FOR_USER_START_STATE == currentPrimeState )
    {
        primeStartRequested = TRUE;
        accepted = TRUE;
        rejReason = REQUEST_REJECT_REASON_NONE;
    }

    sendStartPrimeCmdResponse( accepted, rejReason );
}

/*********************************************************************//**
 * @brief
 * The signalResumePrime function signals the prime sub-mode to resume
 * previous operation.
 * @details Inputs: none
 * @details Outputs: primeResumeRequested
 * @return none
 *************************************************************************/
void signalResumePrime( void )
{
    primeResumeRequested = TRUE;
}

/*********************************************************************//**
 * @brief
 * The resetPrimeFlags function resets all prime signal flags.
 * @details Inputs: none
 * @details Outputs: signal flags set to FALSE
 * @return none
 *************************************************************************/
static void resetPrimeFlags( void )
{
    primeStartRequested = FALSE;
    primeResumeRequested = FALSE;
}

/*********************************************************************//**
 * @brief
 * The setupForPrimePause function stop pumps handles prime pause request.
 * @details Inputs: none
 * @details Outputs: stop all pumps, switch to prime pause state.
 * @return none
 *************************************************************************/
static void setupForPrimePause( void )
{
    signalDialOutPumpHardStop();
    signalDialInPumpHardStop();
    signalBloodPumpHardStop();

    primePauseStartTime = getMSTimerCount();
    previousPrimeState  = currentPrimeState;
}

/*********************************************************************//**
 * @brief
 * The broadcastPrimeTimeAndStatus function broadcasts prime status
 * data during priming.
 * @details Inputs: pre-treatment time and state data
 * @details Outputs: pre-treatment time and state messages sent on interval
 * @return none
 *************************************************************************/
static void broadcastPrimingStatus( void )
{
    U32 const elapsedPrimeTimeInSecs = calcTimeSince( primeStartTime ) / MS_PER_SECOND;

    if ( elapsedPrimeTimeInSecs > MAX_PRIME_TIME )
    {
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_PRIME_OUT_OF_TIME, elapsedPrimeTimeInSecs, MAX_PRIME_TIME );
    }

    if ( ++primeStatusBroadcastTimerCounter >= PRIME_DATA_PUB_INTERVAL )
    {
        PRIMING_DATA_PAYLOAD_T primeData;
        primeData.totalTime         = MAX_PRIME_TIME;
        primeData.remainingTime     = MAX_PRIME_TIME - elapsedPrimeTimeInSecs;

        broadcastPrimeData( &primeData );
        primeStatusBroadcastTimerCounter = 0;
    }
}

/*********************************************************************//**
 * @brief
 * The purgeAirValvesBloodPumpControl function controls valves and blood pump
 * to purge air.
 * @details Inputs: none
 * @details Outputs: run blood pump, close VDI, VDO, VBA and VBV valves, open VBT valve
 * @return current state (sub-mode)
 *************************************************************************/
static void purgeAirValvesBloodPumpControl( void )
{
    setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
    setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
    setValvePosition( VBA, VALVE_POSITION_C_CLOSE );
    setValvePosition( VBV, VALVE_POSITION_C_CLOSE );
    setValveAirTrap( STATE_OPEN );

    signalDialOutPumpHardStop();
    signalDialInPumpHardStop();
    setBloodPumpTargetFlowRate( BLOOD_PUMP_FLOW_RATE_PURGE_AIR, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
}

/*********************************************************************//**
 * @brief
 * The handlePrimeSalineSetupState function checks user's request to start
 * priming.
 * @details Inputs: primeStartReqReceived
 * @details Outputs: control valves to purge air
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeWaitForUserStartState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_WAIT_FOR_USER_START_STATE;

    // Keep updating start time until the user requested priming
    primeStartTime = getMSTimerCount();

#ifndef SKIP_UI_INTERACTION
    if ( TRUE == primeStartRequested )
#endif
    {
        primeStartRequested = FALSE;
        state = HD_PRIME_SALINE_SETUP_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeSalineSetupState function checks user's request to start
 * priming.
 * @details Inputs: primeStartReqReceived
 * @details Outputs: control valves to purge air
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeSalineSetupState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_SALINE_PURGE_AIR_STATE;

    purgeAirValvesBloodPumpControl();
    purgeAirTimeOutStartTime = getMSTimerCount();

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimePurgeAirState function checks for air trap level and moves
 * to blood circuit circulation state if fluid is detected at upper sensor.
 * @details Inputs: air trap levels
 * @details Outputs: runs blood pump, control valves to trap air
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimePurgeAirState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_SALINE_PURGE_AIR_STATE;

    if ( TRUE == didTimeout( purgeAirTimeOutStartTime, PURGE_AIR_TIME_OUT_COUNT ) )
    {
        activateAlarmNoData( ALARM_ID_HD_PRIME_PURGE_AIR_TIME_OUT );
    }

    if ( AIR_TRAP_LEVEL_FLUID == getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_UPPER ) )
    {
        setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
        setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
        setValvePosition( VBA, VALVE_POSITION_B_OPEN );
        setValvePosition( VBV, VALVE_POSITION_B_OPEN );
        setValveAirTrap( STATE_CLOSED );

        setBloodPumpTargetFlowRate( BLOOD_PUMP_FLOW_RATE_CIRC_BLOOD_CIRCUIT, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
        noAirDetectedStartTime = getMSTimerCount();
        state = HD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE;
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeCircBloodCircuitState function checks for air trap level and
 * return to purge air state if air is detected at lower sensor. If no air
 * detected for a period of time, the blood pump is stopped.
 * @details Inputs: air trap levels
 * @details Outputs: stop blood pump, control valves to purge air
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeCircBloodCircuitState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE;

    if ( AIR_TRAP_LEVEL_AIR == getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_LOWER ) )
    {
        purgeAirValvesBloodPumpControl();
        purgeAirTimeOutStartTime = getMSTimerCount();
        state = HD_PRIME_SALINE_PURGE_AIR_STATE;
    }

    if ( TRUE == didTimeout( noAirDetectedStartTime, NO_AIR_DETECTED_COUNT ) )
    {
        signalBloodPumpHardStop();
        state = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE;
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeReservoirOneFillCompleteState function waits for DG to finish
 * filling reservoir 1 before moving to priming dialyzer.
 * @details Inputs: reservoirFilledStatus[]
 * @details Outputs: update valves and pumps configuration on state change
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeReservoirOneFillCompleteState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE;

    if ( TRUE == getReservoirFillStatus( DG_RESERVOIR_1 ) )
    {
        cmdSetDGActiveReservoir( DG_RESERVOIR_1 );

        if ( TRUE == hasDGCompletedReservoirSwitch() )
        {
            setValvePosition( VDI, VALVE_POSITION_B_OPEN );
            setValvePosition( VDO, VALVE_POSITION_B_OPEN );
            setValvePosition( VBA, VALVE_POSITION_C_CLOSE );
            setValvePosition( VBV, VALVE_POSITION_C_CLOSE );
            setValveAirTrap( STATE_CLOSED );

            setDialInPumpTargetFlowRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            setDialOutPumpTargetRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );

            previousLoadCellReading = 0;
            loadcellSteadyVolumeStartTime = getMSTimerCount();
            primeDialysateDialyzerStartTime = getMSTimerCount();

    #ifdef SKIP_PRIMING
            state = HD_PRIME_WET_SELF_TESTS_STATE;
    #else
            state = HD_PRIME_DIALYSATE_DIALYZER_STATE;
    #endif
        }
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeDialysateDialyzerState function handles priming for
 * dialysate dialyzer fluid path.
 * @details Inputs: reservoir 1 filtered weight
 * @details Outputs: primed dialysate dialyzer fluid path
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeDialysateDialyzerState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_DIALYSATE_DIALYZER_STATE;

    F32 const loadcellWeight = getLoadCellWeight( LOAD_CELL_RESERVOIR_1_PRIMARY );
    F32 const weightChange = fabs( 1.0 - ( previousLoadCellReading / loadcellWeight ) );

    if ( weightChange < LOAD_CELL_VOLUME_NOISE_TOLERANCE )
    {
        if ( TRUE == didTimeout( loadcellSteadyVolumeStartTime, MIN_LOAD_CELL_STEADY_VOLUME_TIME ) )
        {
            if ( TRUE == runBloodCircuitPrimeAgain )
            {
                runBloodCircuitPrimeAgain = FALSE;
                state = HD_PRIME_SALINE_SETUP_STATE;
            }
            else
            {
                state = HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE;
            }
        }
    }
    else
    {
        previousLoadCellReading = loadcellWeight;
        loadcellSteadyVolumeStartTime = getMSTimerCount();
    }

    if ( TRUE == didTimeout( primeDialysateDialyzerStartTime, PRIME_DIALYSATE_DIALYZER_TIME_LIMIT ) )
    {
        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRIME_DIALYSATE_DIALYZER_TIME_OUT, PRIME_DIALYSATE_DIALYZER_TIME_LIMIT );
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeReservoirTwoFillCompleteState function waits for DG to finish
 * filling reservoir 2 before moving to pre-treatment re-circulation.
 * @details Inputs: reservoirFilledStatus[]
 * @details Outputs: update valves and pumps configuration on state change
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeReservoirTwoFillCompleteState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE;

    if ( TRUE == getReservoirFillStatus( DG_RESERVOIR_2 ) )
    {
        cmdSetDGActiveReservoir( DG_RESERVOIR_2 );

        if ( TRUE == hasDGCompletedReservoirSwitch() )
        {
            signalDialOutPumpHardStop();
            setDialInPumpTargetFlowRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );

            setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
            setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
            setValvePosition( VBA, VALVE_POSITION_C_CLOSE );
            setValvePosition( VBV, VALVE_POSITION_C_CLOSE );
            setValveAirTrap( STATE_CLOSED );

            previousLoadCellReading = 0;
            primeDialysateBypassStartTime = getMSTimerCount();
            loadcellSteadyVolumeStartTime = getMSTimerCount();
            state = HD_PRIME_DIALYSATE_BYPASS_STATE;
        }
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeDialysateDialyzerState function handles priming for
 * dialysate dialyzer fluid path.
 * @details Inputs: reservoir 2 filtered weight
 * @details Outputs: primed dialysate bypass fluid path
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeDialysateBypassState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_DIALYSATE_BYPASS_STATE;
    F32 const loadcellWeight = getLoadCellWeight( LOAD_CELL_RESERVOIR_2_PRIMARY );
    F32 const weightChange = fabs( 1.0 - ( previousLoadCellReading / loadcellWeight ) );

    if ( weightChange < LOAD_CELL_VOLUME_NOISE_TOLERANCE )
    {
        if ( TRUE == didTimeout( loadcellSteadyVolumeStartTime, MIN_LOAD_CELL_STEADY_VOLUME_TIME ) )
        {
            transitionToWetSelfTests();
            state = HD_PRIME_WET_SELF_TESTS_STATE;
        }
    }
    else
    {
        previousLoadCellReading = loadcellWeight;
        loadcellSteadyVolumeStartTime = getMSTimerCount();
    }

    if ( TRUE == didTimeout( primeDialysateBypassStartTime, PRIME_DIALYSATE_BYPASS_TIME_LIMIT ) )
    {
        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRIME_DIALYSATE_BYPASS_TIME_OUT, PRIME_DIALYSATE_BYPASS_TIME_LIMIT );
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeWetSelfTestsState function perform wet self-tests after
 * priming is completed and collect the result.
 * @details Inputs: none
 * @details Outputs: isWetSelfTestsPassed
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeWetSelfTestsState( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_WET_SELF_TESTS_STATE;

    if ( TRUE == primeResumeRequested )
    {
        signalResumeSelfTests();
    }

#ifndef SKIP_WET_SELF_TESTS
    execWetSelfTests();

    if ( TRUE == isWetSelfTestsPassed() )
#endif
    {
        state = HD_PRIME_COMPLETE;
    }

    if ( TRUE == doesAlarmStatusIndicateStop() )
    {
        setupForPrimePause();
        state = HD_PRIME_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimePause function handles prime pause state.
 * @details Inputs: previousPrimeState
 * @details Outputs: primeStartTime, primeResumeReqReceived
 * @return current state
 *************************************************************************/
static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimePause( void )
{
    HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_PAUSE;

    if ( TRUE == primeResumeRequested )
    {
        primeResumeRequested = FALSE;
        primeStartTime += calcTimeSince( primePauseStartTime );

        switch ( previousPrimeState )
        {
            case HD_PRIME_SALINE_SETUP_STATE:
            case HD_PRIME_SALINE_PURGE_AIR_STATE:
            case HD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE:
                state = HD_PRIME_SALINE_SETUP_STATE;
                break;

            case HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE:
            case HD_PRIME_DIALYSATE_DIALYZER_STATE:
                state = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE;
                break;

            case HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE:
            case HD_PRIME_DIALYSATE_BYPASS_STATE:
                state = HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE;
                break;

            case HD_PRIME_WET_SELF_TESTS_STATE:
                signalResumeSelfTests();
                state = HD_PRIME_WET_SELF_TESTS_STATE;
                break;

            default:
                SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_PRE_TREATMENT_PRIME_INVALID_STATE, (U32)previousPrimeState );
                break;
        }
    }

    return state;
}

/**@}*/