#include "StateController.h"
#include "ApplicationController.h"
#include "types.h"

void StateController::initializeTreatmentHDFVariables()
{
    _treatmentHDFVars.hdfCurrentVolumeML          = 0.0;
    _treatmentHDFVars.hdfManualRateMLPM           = 0.0; // TODO assuming manual rate is 0 for now
    _treatmentHDFVars.hdfControlState             = TD_HDF_PAUSED;
    _treatmentHDFVars.hdfMaxFiltrationFraction    = HDF_MAX_FILTRATION_FRACTION;
    _treatmentHDFVars.hdfCurrentRateMLPM          = 0.5;
    _treatmentHDFVars.hdfControlTimeCtr           = 0;
    _treatmentHDFVars.hdfHasMaxVolumeBeenReached  = false;
    _treatmentHDFVars.hdfIsRequested              = true;
}

float StateController::handleCheckHDFRate(const float proposedRateMLPM)
{
    float hdfMaxRateMLPM = (_treatmentHDFVars.hdfMaxFiltrationFraction * _treatmentParams.bloodFlowRateMLPM) - _treatmentStatus.presUFRateMLPM;

    if (hdfMaxRateMLPM > HDF_MAX_RATE) { hdfMaxRateMLPM = HDF_MAX_RATE; }

    float newRateMLPM = (_treatmentHDFVars.hdfCurrentRateMLPM > proposedRateMLPM ? hdfMaxRateMLPM : _treatmentHDFVars.hdfCurrentRateMLPM);
    qDebug() << "HDF rate" << hdfMaxRateMLPM << newRateMLPM;

    return newRateMLPM;
}

void StateController::handleTreatmentHDF()
{
    if (_treatmentParams.treatmentModality != TREATMENT_MODALITY_HDF_ONLINE_FLUID) { return; }
   // _treatmentSubStates.txState = TREATMENT_HDF_STATE; TODo fix when UI fixed it
   switch (_treatmentHDFVars.hdfControlState) {
       case TD_HDF_PAUSED:
           if (!_treatmentHDFVars.hdfHasMaxVolumeBeenReached && _treatmentHDFVars.hdfIsRequested) {
               _treatmentHDFVars.hdfControlState     = TD_HDF_RUNNING;
               _treatmentHDFVars.hdfCurrentRateMLPM  = handleCheckHDFRate(_treatmentHDFVars.hdfCurrentRateMLPM);
           }
           break;

       case TD_HDF_RUNNING:
           if (!_treatmentHDFVars.hdfIsRequested) {
               _treatmentHDFVars.hdfCurrentRateMLPM = 0.0;
               _treatmentHDFVars.hdfControlState    = TD_HDF_PAUSED;
           }
           else {
               if (++_treatmentHDFVars.hdfControlTimeCtr % static_cast<quint32>(HDF_CONTROL_INT_CTR) != 0 ) { return; }
               if (_treatmentHDFVars.hdfManualRateMLPM <= NEARLY_ZERO) {
                   _treatmentHDFVars.hdfCurrentRateMLPM = handleCheckHDFRate(_treatmentHDFVars.hdfCurrentRateMLPM);
               }

               _treatmentHDFVars.hdfCurrentVolumeML += (static_cast<float>(HDF_CONTROL_INT_CTR) / static_cast<float>(SECONDS_PER_MINUTE)) * _treatmentHDFVars.hdfCurrentRateMLPM;

               qDebug() << "ALL" << _treatmentHDFVars.hdfControlState <<  _treatmentHDFVars.hdfCurrentVolumeML <<
                           _treatmentHDFVars.hdfHasMaxVolumeBeenReached << _treatmentHDFVars.hdfIsRequested << HDF_CONTROL_INT_CTR;

               if (_treatmentHDFVars.hdfCurrentVolumeML > _treatmentParams.hdfSubstitutionFluidVolumeL * MILLILITERS_PER_LITER) {
                   qDebug() << "volume HDF" << _treatmentHDFVars.hdfCurrentVolumeML;
                   _treatmentHDFVars.hdfHasMaxVolumeBeenReached = true;
                   _treatmentHDFVars.hdfCurrentRateMLPM         = 0.0;
                   _treatmentHDFVars.hdfControlState            = TD_HDF_PAUSED;
               }
           }
           break;

       default:
           // Do nothing
           break;
   }
}

void StateController::handleHemodialfiltrationBroadcastData(const Broadcast_Type BCType)
{
    static quint32 broadcastCounter = 50;
    if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }

    quint32 autoSubState = (_treatmentHDFVars.hdfManualRateMLPM > 0.0 ? 0 : 1);

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_HEMODIAFILTRATION_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(_treatmentHDFVars.hdfControlState);
    msg.append(autoSubState);
    msg.append(_treatmentHDFVars.hdfManualRateMLPM);
    msg.append(5.2);

    msg.append(_treatmentHDFVars.hdfCurrentRateMLPM);
    msg.append(5.2);
    msg.append(_treatmentParams.hdfSubstitutionFluidVolumeL);
    msg.append(_treatmentHDFVars.hdfCurrentVolumeML / MILLILITERS_PER_LITER);
    msg.append(static_cast<quint32>(_treatmentHDFVars.hdfIsRequested));
    //qDebug() << "B" << msg;
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

void StateController::handleHDFAdjustmentRequestMessage()
{
    if (_treatmentRcvdMessages[ID_UI_HDF_ADJUSTMENT_RQST].isNull()) { return; }
    QVariantList reason;
    quint32 acceptReject = REJECT_VALUE;

    _treatmentParams.hdfDilution                 = extractU32DataFromReceivedMessage(ID_UI_HDF_ADJUSTMENT_RQST, 0);
    _treatmentParams.hdfSubstitutionFluidVolumeL = extractF32DataFromReceivedMessage(ID_UI_HDF_ADJUSTMENT_RQST, 4);

    acceptReject = ACCEPT_VALUE;
    reason.append(REQUEST_REJECT_REASON_NONE);
    reason.append(REQUEST_REJECT_REASON_NONE);

    _treatmentRcvdMessages[ID_UI_HDF_ADJUSTMENT_RQST].clear();

    // TODo check the reject reasons
    handleUIResponseMessage(ID_TD_HDF_ADJUSTMENT_RESP, acceptReject, reason);
}