/**************************************************************************
*
* Copyright (c) 2024-2025 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    Ultrafilteration.c
*
* @author  (last)      Vinayakam Mani
* @date    (last)      23-Jul-2025
*
* @author  (original)  Vinayakam Mani
* @date    (original)  23-Jul-2025
*
***************************************************************************/

#include "ConcentratePumps.h"
#include "Messaging.h"
#include "OperationModes.h"
#include "TaskGeneral.h"
#include "TDInterface.h"
#include "TestSupport.h"
#include "Ultrafilteration.h"


/**
 *  @addtogroup Ultrafilteration
 *  @{
 */

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

#define UF_DATA_PUBLISH_INTERVAL            ( 1000 / TASK_GENERAL_INTERVAL )                    ///< Interval (ms/task time) at which the ultrafilteration data published.
#define UF_RUN_PERIOD                       ( 5 * MS_PER_SECOND )                               ///< Interval at which the ultrafilteration initiated.
#define ZERO_RATE                           0.0F                                                ///< Zero value.
#define UF_RUN_INTERVAL                     ( UF_RUN_PERIOD / TASK_GENERAL_INTERVAL )           ///< Interval (ms/task time) at which the peroidic ultrafilteration initiated .

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

static UF_EXEC_STATE_T ufExecState;                                                             ///< Current ultrafilteration executive state.
static BOOL isUltrafilterationRequested;                                                        ///< Flag indicating ultrafilteration request.
static U32 currentUFRunningCounter;                                                             ///< Counter (in task interval) to initiate the periodic ultrafilteration
static F32 ufVolumeperIteration;                                                                ///< ultrafilteration volume per defined interval
static U32 ufDataPublicationTimerCounter;                                                       ///< Used to schedule ultrafilteration data publication to CAN bus.
static OVERRIDE_U32_T ufDataPublishInterval;                                                    ///< Ultrafilteration data publish interval.

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

static UF_EXEC_STATE_T handleUFRunningState( void );
static UF_EXEC_STATE_T handleUFPausedState( void );
static void updateUFRequest( void );
static void publishUltrafiltrationData( void );
static U32 getUFDataPublishInterval( void );

/*********************************************************************//**
 * @brief
 * The initUltrafilteration function initializes the ultrafilteration unit.
 * @details \b Inputs: none
 * @details \b Outputs: unit variables initialized
 * @return none
 *************************************************************************/
void initUltrafilteration( void )
{
    ufExecState                             = DD_UF_PAUSED;
    ufDataPublishInterval.data              = UF_DATA_PUBLISH_INTERVAL;
    ufDataPublishInterval.ovData            = UF_DATA_PUBLISH_INTERVAL;
    ufDataPublishInterval.ovInitData        = 0;
    ufDataPublishInterval.override          = OVERRIDE_RESET;
    isUltrafilterationRequested             = FALSE;
    currentUFRunningCounter                 = 0;
    ufVolumeperIteration                    = 0.0F;
    ufDataPublicationTimerCounter           = 0;
}

/*********************************************************************//**
 * @brief
 * The transitionToUltrafilteration function prepares for transition to
 * ultrafilteration.
 * @details \b Inputs: none
 * @details \b Outputs: isUltrafilterationRequested,ufDataPublicationTimerCounter
 * @return none
 *************************************************************************/
void transitionToUltrafilteration( void )
{
    initUltrafilteration();
}

/*********************************************************************//**
 * @brief
 * The execUFControl function executes the ultrafilteration state machine.
 * @details \b Inputs: ufExecState
 * @details \b Outputs: ufExecState
 * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when wrong ultrafilteration
 * state invoked.
 * @return current state.
 *************************************************************************/
U32 execUFControl( void )
{
    // Calculate UF volume and determine UF pause/run
    updateUFRequest();

    // execute current ultrafilteration exec state
    switch ( ufExecState )
    {
        case DD_UF_PAUSED:
            ufExecState = handleUFPausedState();
            break;

        case DD_UF_RUNNING:
            ufExecState = handleUFRunningState();
            break;

        default:
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_UF_INVALID_EXEC_STATE, ufExecState )
            ufExecState = DD_UF_PAUSED;
            break;
    }

    //Publish ultrafilteration data
    publishUltrafiltrationData();

    return ufExecState;
}

/*********************************************************************//**
 * @brief
 * The handleUFPausedState function handles the ultrafilteration
 * paused state.
 * @details \b Inputs:isUltrafilterationRequested
 * @details \b Outputs: UF state
 * @return next UF state.
 *************************************************************************/
static UF_EXEC_STATE_T handleUFPausedState( void )
{
    UF_EXEC_STATE_T state = DD_UF_PAUSED;

    if ( TRUE == isUltrafilterationRequested )
    {
        setConcentratePumpTargetSpeed( D76_PUMP, UF_PUMP_SPEED, ufVolumeperIteration );
        requestConcentratePumpOn( D76_PUMP );

        //Tranistion to run state
        state = DD_UF_RUNNING;
    }
    else
    {
        requestConcentratePumpOff( D76_PUMP, FALSE );
    }

    //Reset counter
    currentUFRunningCounter = 0;

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleUFPausedState function handles the ultrafilteration
 * running state.
 * @details \b Inputs:isUltrafilterationRequested, currentUFRunningCounter
 * @details \b Outputs: UF state, currentUFRunningCounter
 * @return next UF state.
 *************************************************************************/
static UF_EXEC_STATE_T handleUFRunningState( void )
{
    UF_EXEC_STATE_T state = DD_UF_RUNNING;

    if ( TRUE != isUltrafilterationRequested )
    {
        state = DD_UF_PAUSED;
    }
    else if ( ++currentUFRunningCounter >= UF_RUN_INTERVAL )
    {
        setConcentratePumpTargetSpeed( D76_PUMP, UF_PUMP_SPEED, ufVolumeperIteration );
        requestConcentratePumpOn( D76_PUMP );

        currentUFRunningCounter = 0;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The updateUFRequest function updates the ultrafilteration rate per iteration
 * and of the ultrafilteration.
 * @details \b Inputs: TD Uf rate, TD Dialysate flow rate and bypass flag
 * @details \b Outputs: ufVolumeperIteration , isUltrafilterationRequested
 * @return none.
 *************************************************************************/
static void updateUFRequest( void )
{
    // Calculate UF volume per iteration ( ml/ second) based on TD UF rate ( ml/minute)
    ufVolumeperIteration = ( getTDUFRate() / SEC_PER_MIN ) * ( UF_RUN_PERIOD / MS_PER_SECOND );

    // update latest UF run/pause request
    if ( ( getTDUFRate() > ZERO_RATE ) && ( TRUE != getTDDialyzerBypass() ) &&
         ( getTDDialysateFlowrate() > ZERO_RATE ) )
    {
        isUltrafilterationRequested = TRUE;
    }
    else
    {
        isUltrafilterationRequested = FALSE;
    }
}

/*********************************************************************//**
 * @brief
 * The getCurrentUFExecState function returns the current state
 * of the ultrafilteration.
 * @details \b Inputs: ufExecState
 * @details \b Outputs: none
 * @return the current state of UF execution state.
 *************************************************************************/
UF_EXEC_STATE_T getCurrentUFExecState( void )
{
    return ufExecState;
}

/*********************************************************************//**
 * @brief
 * The getUFDataPublishInterval function gets the ultrafilteration
 * data publish interval.
 * @details \b Inputs: balChamberDataPublishInterval
 * @details \b Outputs: none
 * @return the interval at UF data being published.
 *************************************************************************/
static U32 getUFDataPublishInterval( void )
{
    U32 result = ufDataPublishInterval.data;

    if ( OVERRIDE_KEY == ufDataPublishInterval.override )
    {
        result = ufDataPublishInterval.ovData;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The publishUltrafiltrationData function broadcasts the ultrafilteration
 * data at defined interval.
 * @details \b Inputs: ufDataPublicationTimerCounter
 * @details \b Outputs: DD ultrafilteration data broadcast message sent
 * @details \b Message \Sent: MSG_ID_DD_UF_DATA to publish the ultrafilteration
 * data.
 * @return none
 *************************************************************************/
static void publishUltrafiltrationData( void )
{
    if ( ++ufDataPublicationTimerCounter >= getUFDataPublishInterval() )
    {
        UF_DATA_T data;

        data.ufExecState                = (U32)ufExecState;
        data.ufRate                     = getTDUFRate();
        data.isUFRequested              = (U32)isUltrafilterationRequested;
        data.ufVolumeperIteration       = ufVolumeperIteration;

        broadcastData( MSG_ID_DD_UF_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( UF_DATA_T ) );

        ufDataPublicationTimerCounter = 0;
    }
}


/*************************************************************************
 *                       TEST SUPPORT FUNCTIONS
 *************************************************************************/


/*********************************************************************//**
 * @brief
 * The testDDUFDataPublishIntervalOverride function overrides the
 * DD ultrafilteration data publish interval.
 * @details \b Inputs: ufDataPublishInterval
 * @details \b Outputs: ufDataPublishInterval
 * @param Override message from Dialin which includes the interval
 * (in ms) to override the DD ultrafilteration data publish interval to.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testDDUFDataPublishIntervalOverride( MESSAGE_T *message )
{
    BOOL result = u32BroadcastIntervalOverride( message, &ufDataPublishInterval, TASK_GENERAL_INTERVAL );

    return result;
}

/**@}*/