/**************************************************************************
*
* 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 SelfTests.c
*
* @author (last) Quang Nguyen
* @date (last) 28-Jan-2021
*
* @author (original) Quang Nguyen
* @date (original) 28-Jan-2021s
*
***************************************************************************/

#include "AirTrap.h"
#include "BloodFlow.h"
#include "DialInFlow.h"
#include "DialOutFlow.h"
#include "FPGA.h"
#include "PresOccl.h"
#include "SelfTests.h"
#include "Timers.h"
#include "Valves.h"

/**
 *  @addtogroup SelfTests
 *  @{
 */

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

#define PUMP_RUN_SELF_TEST_TIME                 ( 15 * MS_PER_SECOND )     ///< Self-test time to run pumps in ms.
#define PUMP_SELF_TEST_FLOW_RATE                100                        ///< Self-test pump flow rate.

/// No cartridge self-tests state machine.
typedef enum No_Cart_Self_Tests_State
{
    NO_CART_SELF_TESTS_START_STATE = 0,                     ///< No cartridge self-tests starting state.
    NO_CART_SELF_TESTS_OCCLUSION_SENSORS_STATE,             ///< No cartridge occlusion sensors self-test state.
    NO_CART_SELF_TESTS_BLOOD_FLOW_METERS_STATE,             ///< No cartridge blood flow meter self-test state.
    NO_CART_SELF_TESTS_DIALYSATE_FLOW_METERS_STATE,         ///< No cartridge dialysate flow meter self-test state.
    NO_CART_SELF_TESTS_PUMPS_START_STATE,                   ///< Start running blood pump, dialysate in pump, dialysate out pump state.
    NO_CART_SELF_TESTS_PUMPS_STATE,                         ///< No cartridge self-test for blood pump, dialysate in pump, dialysate out pump state.
    NO_CART_SELF_TESTS_LEAK_DETECTORS_STATE,                ///< No cartridge leak detectors self-test state.
    NO_CART_SELF_TESTS_BOARD_TEMPERATURE_STATE,             ///< No cartridge board temperature self-test state.
    NO_CART_SELF_TESTS_DOOR_SWITCH_STATE,                   ///< No cartridge door switch self-test state.
    NO_CART_SELF_TESTS_HOME_VALVES_STATE,                   ///< No cartridge home valves self-test state.
    NO_CART_SELF_TESTS_HOME_PUMPS_STATE,                    ///< No cartridge home pumps self-test state.
    NO_CART_SELF_TESTS_HOME_IDLE_STATE,                     ///< Wait for valves and pumps finish homing state.
    NO_CART_SELF_TESTS_COMPLETE,                            ///< No cartridge self-test complete state.
    NUM_OF_NO_CART_SELF_TESTS_STATES                        ///< Number of no cartridge self-tests states.
} NO_CART_SELF_TESTS_STATE_T;

/// Dry self-tests state machine.
typedef enum Dry_Self_Tests_state
{
    DRY_SELF_TESTS_START_STATE = 0,                         ///< Dry self-tests starting state.
    DRY_SELF_TESTS_BUBBLE_DETECTOR_STATE,                   ///< Bubble detectors dry self-tests state.
    DRY_SELF_TESTS_AIR_TRAP_STATE,                          ///< Air trap fill level ultrasonic sensor dry self-tests state.
    DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE,                 ///< Occlusion sensors dry self-tests state.
    DRY_SELF_TESTS_COMPLETE,                                ///< Dry self-test complete state.
    NUM_OF_DRY_SELF_TESTS_STATES                            ///< Number of no cartridge self-tests states.
} DRY_SELF_TESTS_STATE_T;

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

static BOOL noCartSelfTestsResult;
static NO_CART_SELF_TESTS_STATE_T currentNoCartSelfTestsState;
static U32 runPumpStartTime;

static BOOL drySelfTestsResult;
static DRY_SELF_TESTS_STATE_T currentDrySelfTestsState;

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

/*********************************************************************//**
 * @brief
 * The initSelfTests function initializes the SelfTests module.
 * @details Inputs: none
 * @details Outputs: SelfTests module initialized.
 * @return none
 *************************************************************************/
void initSelfTests( void )
{
}

/*********************************************************************//**
 * @brief
 * The transitionToNoCartSelfTests function resets anything required before
 * the start of no cartridge self-tests.
 * @details Inputs: none
 * @details Outputs: No cartridge self-tests re-initialized.
 * @return none
 *************************************************************************/
void transitionToNoCartSelfTests( void )
{
    noCartSelfTestsResult = FALSE;
    currentNoCartSelfTestsState = NO_CART_SELF_TESTS_START_STATE;

    runPumpStartTime = 0;
}

/*********************************************************************//**
 * @brief
 * The execNoCartSelfTests function executes the no cartridge self-tests
 * state machine.
 * @details Inputs: currentNoCartSelfTestsState
 * @details Outputs: currentNoCartSelfTestsState, noCartSelfTestsResult
 * @return none
 *************************************************************************/
void execNoCartSelfTests( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_PASSED;
    VALVE_T valve;

    // execute no cartridge self-tests state machine
    switch ( currentNoCartSelfTestsState )
    {
        case NO_CART_SELF_TESTS_START_STATE:
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_OCCLUSION_SENSORS_STATE;
            break;

        case NO_CART_SELF_TESTS_OCCLUSION_SENSORS_STATE:
            result = execPresOcclTest();
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_BLOOD_FLOW_METERS_STATE;
            break;

        case NO_CART_SELF_TESTS_BLOOD_FLOW_METERS_STATE:
            result = execBloodFlowTest();
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_DIALYSATE_FLOW_METERS_STATE;
            break;

        case NO_CART_SELF_TESTS_DIALYSATE_FLOW_METERS_STATE:
            result = execDialInFlowTest();
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_PUMPS_START_STATE;
            break;

        case NO_CART_SELF_TESTS_PUMPS_START_STATE:
            setBloodPumpTargetFlowRate( PUMP_SELF_TEST_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            setDialInPumpTargetFlowRate( PUMP_SELF_TEST_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            setDialOutPumpTargetRate( PUMP_SELF_TEST_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            runPumpStartTime = getMSTimerCount();
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_PUMPS_STATE;
            break;

        case NO_CART_SELF_TESTS_PUMPS_STATE:
            if ( TRUE == didTimeout( runPumpStartTime, PUMP_RUN_SELF_TEST_TIME ) )
            {
                signalBloodPumpHardStop();
                signalDialInPumpHardStop();
                signalDialOutPumpHardStop();
                currentNoCartSelfTestsState = NO_CART_SELF_TESTS_LEAK_DETECTORS_STATE;
            }
            break;

        case NO_CART_SELF_TESTS_LEAK_DETECTORS_STATE:
            // TODO: Implement self tests
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_BOARD_TEMPERATURE_STATE;
            break;

        case NO_CART_SELF_TESTS_BOARD_TEMPERATURE_STATE:
            // TODO: Implement self tests
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_DOOR_SWITCH_STATE;
            break;

        case NO_CART_SELF_TESTS_DOOR_SWITCH_STATE:
            // TODO: Implement self tests
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_HOME_VALVES_STATE;
            break;

        case NO_CART_SELF_TESTS_HOME_VALVES_STATE:
            for ( valve = VDI; valve < NUM_OF_VALVES; ++valve )
            {
                homeValve( valve );
            }
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_HOME_PUMPS_STATE;
            break;

        case NO_CART_SELF_TESTS_HOME_PUMPS_STATE:
            homeBloodPump();
            homeDialInPump();
            homeDialOutPump();
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_HOME_IDLE_STATE;
            break;

        case NO_CART_SELF_TESTS_HOME_IDLE_STATE:
            if ( ( FALSE == isDialInPumpRunning() ) && ( FALSE == isDialOutPumpRunning() ) && ( FALSE == isBloodPumpRunning() ) )
            {
                currentNoCartSelfTestsState = NO_CART_SELF_TESTS_COMPLETE;
            }
            break;

        case NO_CART_SELF_TESTS_COMPLETE:
            noCartSelfTestsResult = TRUE;
            break;

        default:
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_NO_CARTRIDGE_SELF_TEST_STATE, (U32)currentNoCartSelfTestsState );
            break;
    }

    if ( SELF_TEST_STATUS_FAILED == result )
    {
        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRE_TREATMENT_SELF_TEST_FAILURE, currentNoCartSelfTestsState );
    }
}

/*********************************************************************//**
 * @brief
 * The isNoCartSelfTestsPassed function returns the status of no cartridge self-tests.
 * @details Inputs: none
 * @details Outputs: none
 * @return TRUE if no cartridge self-tests passed, otherwise FALSE
 *************************************************************************/
BOOL isNoCartSelfTestsPassed( void )
{
    return noCartSelfTestsResult;
}

/*********************************************************************//**
 * @brief
 * The transitionToDrySelfTests function resets anything required before
 * the start of dry self-tests.
 * @details Inputs: none
 * @details Outputs: Dry self-tests re-initialized.
 * @return none
 *************************************************************************/
void transitionToDrySelfTests()
{
    drySelfTestsResult = FALSE;
    currentDrySelfTestsState = DRY_SELF_TESTS_START_STATE;
}

/*********************************************************************//**
 * @brief
 * The execDrySelfTests function executes the dry self-tests state machine.
 * @details Inputs: currentDrySelfTestsState
 * @details Outputs: currentDrySelfTestsState, drySelfTestsResult
 * @return none
 *************************************************************************/
void execDrySelfTests( void )
{
    // execute dry self-tests state machine
    switch ( currentDrySelfTestsState )
    {
        case DRY_SELF_TESTS_START_STATE:
            currentDrySelfTestsState = DRY_SELF_TESTS_BUBBLE_DETECTOR_STATE;
            break;

        case DRY_SELF_TESTS_BUBBLE_DETECTOR_STATE:
            {
                BOOL const isADADetectedAir = getFPGAArterialAirBubbleStatus();
                BOOL const isADVDetectedAir = getFPGAVenousAirBubbleStatus();

                if ( ( TRUE == isADADetectedAir ) && ( TRUE == isADADetectedAir ) )
                {
                    currentDrySelfTestsState = DRY_SELF_TESTS_AIR_TRAP_STATE;
                }
                else
                {
                    activateAlarmNoData( ALARM_ID_INSTALL_NEW_CARTRIDGE );
                }
            }
            break;

        case DRY_SELF_TESTS_AIR_TRAP_STATE:
            if ( ( AIR_TRAP_LEVEL_AIR == getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_LOWER ) ) &&
                 ( AIR_TRAP_LEVEL_AIR == getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_UPPER ) ) )
            {
                currentDrySelfTestsState = DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE;
            }
            else
            {
                activateAlarmNoData( ALARM_ID_INSTALL_NEW_CARTRIDGE );
            }
            break;

        case DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE:
            {
                SELF_TEST_STATUS_T const result = execPresOcclDryTest();

                if ( SELF_TEST_STATUS_PASSED == result )
                {
                    currentDrySelfTestsState = DRY_SELF_TESTS_COMPLETE;
                }
                else
                {
                    activateAlarmNoData( ALARM_ID_CARTRIDGE_INSTALLED_IMPROPERLY );
                }
            }
            break;

        case DRY_SELF_TESTS_COMPLETE:
            drySelfTestsResult = TRUE;
            break;

        default:
            currentDrySelfTestsState = DRY_SELF_TESTS_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_DRY_SELF_TEST_STATE, (U32)currentDrySelfTestsState );
            break;
    }
}

/*********************************************************************//**
 * @brief
 * The isDrySelfTestsPassed function returns the status of dry self-tests.
 * @details Inputs: none
 * @details Outputs: none
 * @return TRUE if dry self-tests passed, otherwise FALSE
 *************************************************************************/
BOOL isDrySelfTestsPassed( void )
{
    return drySelfTestsResult;
}

/**@}*/