/**************************************************************************
*
* Copyright (c) 2019-2021 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 ModePreTreat.c
*
* @author (last) Sean Nash
* @date (last) 06-Oct-2020
*
* @author (original) Dara Navaei
* @date (original) 05-Nov-2019
*
***************************************************************************/

#include "AlarmMgmt.h"
#include "ConsumableSelfTest.h"
#include "FPGA.h"
#include "ModePreTreat.h"
#include "OperationModes.h"
#include "PreTreatmentRecirc.h"
#include "Prime.h"
#include "SelfTests.h"
#include "SampleWater.h"
#include "SystemCommMessages.h"
#include "TaskGeneral.h"

/**
 *  @addtogroup HDPreTreatmentMode
 *  @{
 */

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

///< Interval (ms/task time) at which the pre-treatment state data is published on the CAN bus.
#define PRE_TREATMENT_DATA_PUB_INTERVAL        ( MS_PER_SECOND / TASK_GENERAL_INTERVAL )

#define DIP_PATIENT_CONNECTION_FLOW_RATE_ML_MIN     100                 ///< Patient connection sub-mode dialysate inlet pump flow rate in mL/min.

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

static BOOL confirmInstallRequested = FALSE;                            ///< Flag indicates user confirms disposable installation.
static BOOL continueToTreatmentRequested = FALSE;                       ///< Flag indicates user requests to continue to treatment from re-circ.
static BOOL setUFVolStatus;                                             ///< The status of set UF volume operation.
static BOOL patientConnectionConfirm;                                   ///< Flag indicates user has confirmed patient connection complete.
static BOOL treatmentStartRequested = FALSE;                            ///< Flag indicates user requests treatment begin.

static BOOL alarmActionResumeReceived = FALSE;                          ///< Flag indicates alarm action resume received.

static HD_PRE_TREATMENT_MODE_STATE_T currentPreTreatmentState;          ///< Current state of pre-treatment mode state machine.
static U32 preTreatmentPublishTimerCounter;                             ///< Pre-treatment data broadcast timer counter used to schedule when to transmit data.

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

static void publishPreTreatmentState( void );
static void resetSignalFlags( void );
static void transitionToCartridgeInstallation( void );
static void transitionToPatientConnection( void );

static HD_PRE_TREATMENT_MODE_STATE_T handleWaterSampleState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestConsumableState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestNoCartState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handleInstallState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestDryState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handlePrimeState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handleRecirculateState( void );
static HD_PRE_TREATMENT_MODE_STATE_T handlePatientConnectionState( void );

/*********************************************************************//**
 * @brief
 * The initPreTreatmentMode function initializes the Pre-Treatment Mode module.
 * @details Inputs: none
 * @details Outputs: Pre-Treatment Mode module initialized.
 * @return none
*************************************************************************/
void initPreTreatmentMode( void )
{
    currentPreTreatmentState = HD_PRE_TREATMENT_START_STATE;
    setUFVolStatus = FALSE;
    patientConnectionConfirm = FALSE;

    initSampleWater();
    initConsumableSelfTest();
    initPrime();
    initSelfTests();

    resetSignalFlags();
}

/*********************************************************************//**
 * @brief
 * The transitionToPreTreatmentMode function prepares for transition to
 * pre-treatment mode.
 * @details Inputs: none
 * @details Outputs: none
 * @return none
*************************************************************************/
void transitionToPreTreatmentMode( void )
{
    // Set user alarm recovery actions allowed in this mode
    setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, TRUE );
    setAlarmUserActionEnabled( ALARM_USER_ACTION_RINSEBACK, FALSE );
    setAlarmUserActionEnabled( ALARM_USER_ACTION_END_TREATMENT, TRUE );

    initPreTreatmentMode();
    cmdStopDGTrimmerHeater();
}

/*********************************************************************//**
 * @brief
 * The execPreTreatmentMode function executes the Pre-Treatment Mode state machine.
 * @details Inputs: none
 * @details Outputs: none
 * @return current state (sub-mode)
*************************************************************************/
U32 execPreTreatmentMode( void )
{
    // execute mode state machine
    switch ( currentPreTreatmentState )
    {
        case HD_PRE_TREATMENT_START_STATE:
            transitionToSampleWater();
            currentPreTreatmentState = HD_PRE_TREATMENT_WATER_SAMPLE_STATE;
            break;

        case HD_PRE_TREATMENT_WATER_SAMPLE_STATE:
            currentPreTreatmentState = handleWaterSampleState();
            break;

        case HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE:
            currentPreTreatmentState = handleSelfTestConsumableState();
            break;

        case HD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE:
            currentPreTreatmentState = handleSelfTestNoCartState();
            break;

        case HD_PRE_TREATMENT_CART_INSTALL_STATE:
            currentPreTreatmentState = handleInstallState();
            break;

        case HD_PRE_TREATMENT_SELF_TEST_DRY_STATE:
            currentPreTreatmentState = handleSelfTestDryState();
            break;

        case HD_PRE_TREATMENT_PRIME_STATE:
            currentPreTreatmentState = handlePrimeState();
            break;

        case HD_PRE_TREATMENT_RECIRCULATE_STATE:
            currentPreTreatmentState = handleRecirculateState();
            break;

        case HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE:
            currentPreTreatmentState = handlePatientConnectionState();
            break;

        default:
            currentPreTreatmentState = HD_PRE_TREATMENT_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE, (U32)currentPreTreatmentState );
            break;
    }

    // Alarm response request flags should be handled at this point, reset in case not handled in current state
    resetSignalFlags();

    // Broadcast pre-treatment data
    publishPreTreatmentState();

    return (U32)currentPreTreatmentState;
}

/*********************************************************************//**
 * @brief
 * The signalUserConfirmInstallation function handles user confirmation of
 * disposable installation.
 * @details Inputs: none
 * @details Outputs: confirmInstallRequested
 * @return TRUE if signal accepted, FALSE if not
 *************************************************************************/
void signalUserConfirmInstallation( void )
{
    if ( ( MODE_PRET == getCurrentOperationMode() ) && ( HD_PRE_TREATMENT_CART_INSTALL_STATE == currentPreTreatmentState ) )
    {
        confirmInstallRequested = TRUE;
    }
}

/*********************************************************************//**
 * @brief
 * The signalUserContinueToTreatment function handles user request to continue
 * to treatment.
 * @details Inputs: none
 * @details Outputs: handled and send response to continue to treatment request
 * @return none
 *************************************************************************/
void signalUserContinueToTreatment( void )
{
    BOOL accepted = FALSE;
    REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NOT_ALLOWED_IN_CURRENT_MODE;

    if ( HD_PRE_TREATMENT_RECIRCULATE_STATE == currentPreTreatmentState )
    {
        continueToTreatmentRequested = TRUE;
        accepted = TRUE;
        rejReason = REQUEST_REJECT_REASON_NONE;
    }

    sendContinueToTreatmentCmdResponse( accepted, rejReason );
}

/*********************************************************************//**
 * @brief
 * The setUserSetUFVolumeStatus function sets the status for user sets UF
 * volume operation.
 * @details Inputs: set UF volume operation status
 * @details Outputs: setUFVolStatus
 * @return none
 *************************************************************************/
void setUserSetUFVolumeStatus( BOOL status )
{
    setUFVolStatus = status;
}

/*********************************************************************//**
 * @brief
 * The signalUserConfirmPatientConnection function handles user confirms
 * patient connection message.
 * @details Inputs: none
 * @details Outputs: handled and send response to patient connection confirmation
 * @return none
 *************************************************************************/
void signalUserConfirmPatientConnection( void )
{
    BOOL accepted = FALSE;
    REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_UF_VOLUME_NOT_SET;

    if ( TRUE == setUFVolStatus )
    {
        if ( HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE == currentPreTreatmentState )
        {
            patientConnectionConfirm = TRUE;
            accepted = TRUE;
            rejReason = REQUEST_REJECT_REASON_NONE;
        }
        else
        {
            rejReason = REQUEST_REJECT_REASON_NOT_ALLOWED_IN_CURRENT_MODE;
        }
    }

    sendPatientConnectionConfirmCmdResponse( accepted, rejReason );
}

/*********************************************************************//**
 * @brief
 * The signalUserStartTreatment function handles user requests to start treatment.
 * @details Inputs: patientConnectionConfirm, currentPreTreatmentState
 * @details Outputs: handled and send response to treatment start request
 * @return TRUE if signal accepted, FALSE if not
 *************************************************************************/
BOOL signalUserStartTreatment( void )
{
    BOOL accepted = FALSE;
    REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NO_PATIENT_CONNECTION_CONFIRM;

    if ( TRUE == patientConnectionConfirm )
    {
        if ( ( MODE_PRET == getCurrentOperationMode() ) && ( HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE == currentPreTreatmentState ) )
        {
            treatmentStartRequested = TRUE;
            accepted = TRUE;
            rejReason = REQUEST_REJECT_REASON_NONE;
        }
        else
        {
            rejReason = REQUEST_REJECT_REASON_NOT_ALLOWED_IN_CURRENT_MODE;
        }
    }

    sendTreatmentStartResponseMsg( accepted, rejReason );

    return accepted;
}

/*********************************************************************//**
 * @brief
 * The signalAlarmActionToPreTreatmentMode function executes the given alarm action
 * as appropriate while in PreTreatment Mode.
 * @details Inputs: none
 * @details Outputs: given alarm action executed
 * @param action ID of alarm action to execute
 * @return none
 *************************************************************************/
void signalAlarmActionToPreTreatmentMode( ALARM_ACTION_T action )
{
    switch( action )
    {
        case ALARM_ACTION_STOP:
            // Stop signal actively polled by mode/sub-mode/state
            break;

        case ALARM_ACTION_RESUME:
            alarmActionResumeReceived = TRUE;
            break;

        case ALARM_ACTION_END_TREATMENT:
            if ( HD_PRE_TREATMENT_PRIME_STATE > currentPreTreatmentState )
            {
                requestNewOperationMode( MODE_STAN );
            }
            else
            {
                requestNewOperationMode( MODE_POST );
            }
            break;

        case ALARM_ACTION_ACK:
            // Nothing to be done here
            break;

        default:
            // Ignore
            break;
    }
}

/*********************************************************************//**
 * @brief
 * The publishPreTreatmentState function broadcasts pre-treatment sub-mode
 * and current sub-mode state.
 * @details Inputs: pre-treatment sub-mode, state
 * @details Outputs: pre-treatment sub-mode, state messages sent on interval
 * @return none
 *************************************************************************/
static void publishPreTreatmentState( void )
{
    // Broadcast treatment time and state data at interval
    if ( ++preTreatmentPublishTimerCounter >= PRE_TREATMENT_DATA_PUB_INTERVAL )
    {
        PRE_TREATMENT_STATE_DATA_T preTreatmentData;

        preTreatmentData.preTreatmentSubMode = currentPreTreatmentState;
        preTreatmentData.sampleWaterState = getSampleWaterState();
        preTreatmentData.consumableSelfTestsState = getConsumableSelfTestState();
        preTreatmentData.noCartSelfTestsState = getNoCartSelfTestsState();
        preTreatmentData.installState = 0;
        preTreatmentData.drySelfTestsState = getDrySelfTestsState();
        preTreatmentData.primeState = getPrimeState();
        preTreatmentData.recircState = getPreTreatmentRecircState();
        preTreatmentData.patientConnectionState = 0;

        broadcastPreTreatmentState( &preTreatmentData );
        preTreatmentPublishTimerCounter = 0;
    }
}

/*********************************************************************//**
 * @brief
 * The resetSignalFlags function resets all signal flags.
 * @details Inputs: none
 * @details Outputs: signal flags set to FALSE
 * @return none
 *************************************************************************/
static void resetSignalFlags( void )
{
    treatmentStartRequested = FALSE;
    confirmInstallRequested = FALSE;
    continueToTreatmentRequested = FALSE;

    alarmActionResumeReceived = FALSE;
}

/*********************************************************************//**
 * @brief
 * The transitionToCartridgeInstallation function prepares actuators before
 * transition to pre-treatment install state.
 * @details Inputs: none
 * @details Outputs: valves are in insert position
 * @return none
 *************************************************************************/
static void transitionToCartridgeInstallation( void )
{
    VALVE_T valve;

    for ( valve = VDI; valve < NUM_OF_VALVES; ++valve )
    {
        setValvePosition( valve, VALVE_POSITION_A_INSERT_EJECT );
    }

    setValveAirTrap( STATE_CLOSED );
}

/*********************************************************************//**
 * @brief
 * The transitionToPatientConnection function prepares actuators before
 * transition to pre-treatment patient connection state.
 * @details Inputs: none
 * @details Outputs: Stopped pumps
 * @return none
 *************************************************************************/
static void transitionToPatientConnection( void )
{
    setUFVolStatus = FALSE;
    patientConnectionConfirm = FALSE;
    treatmentStartRequested = FALSE;

    cmdStartDGTrimmerHeater();

    signalBloodPumpHardStop();
    signalDialOutPumpHardStop();
    setDialInPumpTargetFlowRate( DIP_PATIENT_CONNECTION_FLOW_RATE_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
}

/*********************************************************************//**
 * @brief
 * The handleWaterSampleState function handles sample water state during
 * pre-treatment mode.
 * @details Inputs: none
 * @details Outputs: executed sample water state machine
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handleWaterSampleState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_WATER_SAMPLE_STATE;

    execSampleWater();

    if ( TRUE == isSampleWaterPassed() )
    {
        state = HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE;
        cmdStartDG();
        cmdSetDGDialysateTargetTemps( 39.0, 37.0 );
        transitionToConsumableSelfTest();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleSelfTestConsumableState function handles consumable self-test state
 * during pre-treatment mode.
 * @details Inputs: none
 * @details Outputs: executed consumable self-test state machine
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestConsumableState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE;

    execConsumableSelfTest();

    if ( CONSUMABLE_SELF_TESTS_COMPLETE_STATE == getConsumableSelfTestState() )
    {
        state = HD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE;
        transitionToNoCartSelfTests();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleSelfTestNoCartState function handles self-test with no cartridge.
 * @details Inputs: none
 * @details Outputs: home blood pump and dialysate pumps
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestNoCartState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE;

    if ( STATE_OPEN == getFPGADoorState() )
    {
        activateAlarmNoData( ALARM_ID_CARTRIDGE_DOOR_OPENED );
    }

    if ( TRUE == alarmActionResumeReceived )
    {
        alarmActionResumeReceived = FALSE;
        signalResumeSelfTests();
    }

    execNoCartSelfTests();

    if ( TRUE == isNoCartSelfTestsPassed() )
    {
        state = HD_PRE_TREATMENT_CART_INSTALL_STATE;
        transitionToCartridgeInstallation();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleInstallState function handles disposable installation.
 * @details Inputs: none
 * @details Outputs: transition to prime sub-mode when blood pump finished homing
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handleInstallState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_CART_INSTALL_STATE;

    if ( TRUE == confirmInstallRequested )
    {
        confirmInstallRequested = FALSE;
        state = HD_PRE_TREATMENT_SELF_TEST_DRY_STATE;
        transitionToDrySelfTests();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleSelfTestDryState function performs dry self-test.
 * @details Inputs: none
 * @details Outputs: transition to prime state on user request
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestDryState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_SELF_TEST_DRY_STATE;

    if ( STATE_OPEN == getFPGADoorState() )
    {
        activateAlarmNoData( ALARM_ID_CARTRIDGE_DOOR_OPENED );
    }

    if ( TRUE == alarmActionResumeReceived )
    {
        alarmActionResumeReceived = FALSE;
        signalResumeSelfTests();
    }

    execDrySelfTests();

    if ( TRUE == isDrySelfTestsPassed() )
    {
        state = HD_PRE_TREATMENT_PRIME_STATE;
        transitionToPrime();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePrimeState function handles priming the blood and dialysate circuits.
 * @details Inputs: none
 * @details Outputs: transition to self test wet state after priming passed
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handlePrimeState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_PRIME_STATE;

    if ( STATE_OPEN == getFPGADoorState() )
    {
        activateAlarmNoData( ALARM_ID_CARTRIDGE_DOOR_OPENED );
    }

    if ( TRUE == alarmActionResumeReceived )
    {
        alarmActionResumeReceived = FALSE;
        signalResumePrime();
    }

    execPrime();

    if ( TRUE == isPrimeCompleted() )
    {
        state = HD_PRE_TREATMENT_RECIRCULATE_STATE;
        activateAlarmNoData( ALARM_ID_PRIME_COMPLETED_LOW_PRIORITY );
        transitionToPreTreatmentRecirc();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleRecirculateState function handles blood and dialysate circuits
 * recirculation state during pre-treatment mode.
 * @details Inputs: none
 * @details Outputs: controlled valves and pumps
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handleRecirculateState( void )
{
    HD_PRE_TREATMENT_MODE_STATE_T state = HD_PRE_TREATMENT_RECIRCULATE_STATE;

    if ( STATE_OPEN == getFPGADoorState() )
    {
        activateAlarmNoData( ALARM_ID_CARTRIDGE_DOOR_OPENED );
    }

    if ( TRUE == alarmActionResumeReceived )
    {
        alarmActionResumeReceived = FALSE;
        signalResumePreTreatmentRecirc();
    }

    execPreTreatmentRecirc();

    if ( TRUE == continueToTreatmentRequested )
    {
        continueToTreatmentRequested = FALSE;
        state = HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE;
        transitionToPatientConnection();
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handlePatientConnectionState function handles patient connection state
 * during pre-treatment mode.
 * @details Inputs: none
 * @details Outputs: requested mode transition to treatment mode
 * @return current state (sub-mode)
 *************************************************************************/
static HD_PRE_TREATMENT_MODE_STATE_T handlePatientConnectionState( void )
{
    if ( TRUE == treatmentStartRequested )
    {
        DG_RESERVOIR_ID_T const activeRes = getDGActiveReservoir();
        setStartReservoirVolume( activeRes );
        requestNewOperationMode( MODE_TREA );
    }

    return HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE;
}

/**@}*/