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

void StateController::handleBloodPrimeBroadcastData(const float accumulatedVolML, const quint32 primeTimeOutS, const quint32 pauseCountDownS, const Broadcast_Type BCType)
{
    static quint32 broadcastCounter = 0;
    if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }

    // Broadcast
    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_BLOOD_PRIME_PROGRESS_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(BLOOD_PRIME_VOLUME_ML);
    msg.append(accumulatedVolML);
    msg.append(primeTimeOutS);
    msg.append(pauseCountDownS);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

void StateController::handleTreatmentSetpointsBroadcastData(const quint32 bloodFlowMLPM, const quint32 dialFlowMLPM, const float dialTempC,
                                                            const Broadcast_Type BCType)
{
    static quint32 broadcastCounter = 3;
    if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_TREATMENT_SET_POINTS));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(bloodFlowMLPM); msg.append(dialFlowMLPM);  msg.append(dialTempC);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

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

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_TREATMENT_STATE_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(_treatmentSubStates.txState);
    msg.append(_treatmentSubStates.bloodPrimeState);
    msg.append(_treatmentSubStates.dialysisSubState);
    msg.append(0); // TODO add ISO UF
    msg.append(0); // TODO add treatment paused
    msg.append(_treatmentSubStates.rinsebackState);
    msg.append(_treatmentSubStates.recircState);
    msg.append(_treatmentSubStates.txEndState);
    msg.append(_treatmentSubStates.fluidBolusState);
    msg.append(0); // Heparin state
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

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

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_FLUID_BOLUS_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(_treatmentParams.fluidBlousVolumeML);
    msg.append(_treatmentStatus.accumFluidBolusDeliveredML);
    msg.append(_treatmentStatus.totalFluidBolusDeliveredML);
    msg.append(ENABLE_BOLUS);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

void StateController::handleTDPressureBroadcastData(const Broadcast_Type BCType)
{
    static quint32 broadcastCounter = 10;
    // Arterial calculations
    float arterialRandomMMHG = _randNumGenerator.generateDouble() * (_pressureVars.arterialMinLimitMMHG - _pressureVars.arterialMaxLimitMMHG) +
                               _pressureVars.arterialMaxLimitMMHG;
    float arterialPevMMHG    = _pressureVars.arterialRawMMHG[_pressureVars.arterialIndex];

    _pressureVars.arterialRawMMHG[_pressureVars.arterialIndex] = arterialRandomMMHG;
    _pressureVars.arterialRunningSumMMHG                       = _pressureVars.arterialRunningSumMMHG - arterialPevMMHG + arterialRandomMMHG;
    _pressureVars.arterialIndex                                = (_pressureVars.arterialIndex < SHORT_MOVING_AVG_SIZE - 1 ? _pressureVars.arterialIndex + 1 : 0);
    // Venous calculations
    float venousRandomMMHG = _randNumGenerator.generateDouble() * (_pressureVars.venousMinLimitMMHG - _pressureVars.venousMaxLimitMMHG) +
                             _pressureVars.venousMaxLimitMMHG;
    float venousPevMMHG    = _pressureVars.venousRawMMHG[_pressureVars.venousIndex];

    _pressureVars.venousRawMMHG[_pressureVars.venousIndex] = venousRandomMMHG;
    _pressureVars.venousRunningSumMMHG                     = _pressureVars.venousRunningSumMMHG - venousPevMMHG + venousRandomMMHG;
    _pressureVars.venousIndex                              = (_pressureVars.venousIndex < SHORT_MOVING_AVG_SIZE - 1 ? _pressureVars.venousIndex + 1 : 0);
    // TMP calculations
    float tmpRandomMMHG = _randNumGenerator.generateDouble() * (_pressureVars.tmpMinLimitMMHG - _pressureVars.tmpMaxLimitMMHG) +
                          _pressureVars.tmpMaxLimitMMHG;
    float tmpPevMMHG    = _pressureVars.tmpRawMMHG[_pressureVars.tmpIndex];

    _pressureVars.tmpRawMMHG[_pressureVars.tmpIndex] = tmpRandomMMHG;
    _pressureVars.tmpRunningSumMMHG                  = _pressureVars.tmpRunningSumMMHG - tmpPevMMHG + tmpRandomMMHG;
    _pressureVars.tmpIndex                           = (_pressureVars.tmpIndex < SHORT_MOVING_AVG_SIZE - 1 ? _pressureVars.tmpIndex + 1 : 0);

    if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }

    _pressureVars.arterialFilteredMMHG = _pressureVars.arterialRunningSumMMHG / static_cast<float>(SHORT_MOVING_AVG_SIZE);
    _pressureVars.venousFilteredMMHG   = _pressureVars.venousRunningSumMMHG   / static_cast<float>(SHORT_MOVING_AVG_SIZE);
    _pressureVars.tmpFilteredMMHG      = _pressureVars.tmpRunningSumMMHG      / static_cast<float>(SHORT_MOVING_AVG_SIZE);

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_PRESSURE_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(_pressureVars.arterialFilteredMMHG);
    msg.append(_pressureVars.venousFilteredMMHG);
    msg.append(_pressureVars.presLimitState);
    msg.append(_pressureVars.arterialMinLimitMMHG);
    msg.append(_pressureVars.arterialMaxLimitMMHG);
    msg.append(_pressureVars.venousMinLimitMMHG);
    msg.append(_pressureVars.venousMaxLimitMMHG);
    msg.append(DEF_ART_LONG_FILT_PRES_MMHG);
    msg.append(DEF_VEN_LONG_FILT_PRES_MMHG);
    msg.append(_pressureVars.tmpFilteredMMHG);
    msg.append(DEF_TMP_LONG_FILT_PRES_MMHG);
    msg.append(_pressureVars.tmpMinLimitMMHG);
    msg.append(_pressureVars.tmpMaxLimitMMHG);
    msg.append(DEF_BARO_PRES_PSI);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

void StateController::handleTreatmentTimeProcessAndBroadcastData(const Broadcast_Type BCType)
{
    static quint32 broadcastCounter = 12;
    if (_treatmentSubStates.fluidBolusState == FLUID_BOLUS_IDLE_STATE) {
       _treatmentStatus.treatmentElapsedTimeMS += QOBJECT_TIMER_TIMEOUT_MS;
    }

    if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }

    quint32 prescribedTimeS = _treatmentParams.treatmentDurationMin * SECONDS_PER_MINUTE;
    quint32 elapsedTimeS    = _treatmentStatus.treatmentElapsedTimeMS / MILLISECONDS_PER_SECOND;
    quint32 remainingTimeS  = prescribedTimeS - elapsedTimeS;

    //qDebug() << "Times" << prescribedTimeS << elapsedTimeS << remainingTimeS;

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_TREATMENT_TIME_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(prescribedTimeS);
    msg.append(elapsedTimeS);
    msg.append(remainingTimeS);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

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

    quint32 dummyData  = 1;
    float   dummyFloat = 150.2;
    quint32 dialBypass = (_treatmentSubStates.fluidBolusState == FLUID_BOLUS_SALINE_IN_PROGRESS_STATE ? BYPASS_DIALYSATE_DELIVER : ALLOW_DIALYSATE_DELIVER);

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_DD_GEN_DIALYSATE_MODE_DATA));
    msg.append(Can_Id::eChlid_DD_Sync);
    msg.append(dummyData);
    msg.append(dummyData);
    msg.append(dialBypass);
    msg.append(dummyFloat);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

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

    float d27Cond = 250.63;

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_DD_CONDUCTIVITY_DATA));
    msg.append(Can_Id::eChlid_DD_Sync);
    msg.append(0.0);
    msg.append(d27Cond);
    msg.append(0.0);
    msg.append(0.0);
    msg.append(0.0);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

void StateController::handleTDBloodPressureBroadcastData(const Broadcast_Type BCType)
{
    static quint32 broadcastCounter = 22;
    if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }
     // TODO copmlete
}

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

    float presUFVolL      = _treatmentParams.ufVolumeL;
    float targetUFRateLHR = (_treatmentStatus.presUFRateMLPM * static_cast<float>(MINUTES_PER_HOUR)) / static_cast<float>(MILLILITERS_PER_LITER);
    float UFVolLMS        = targetUFRateLHR / (static_cast<float>(MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND));

    // Only count for UF when the dialysis state is in UF
    if (_treatmentSubStates.dialysisSubState == DIALYSIS_UF_STATE) {
        _treatmentStatus.ufVolDeliveredL += UFVolLMS * PROGRESS_TIME_BC_INTERVAL_MS;
    }

    //qDebug() << "UF Broadcast" << _treatmentStatus.presUFRateMLPM << presUFVolL << targetUFRateLHR << UFVolLMS << _treatmentStatus.ufVolDeliveredL;

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_ULTRAFILTRATION_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(presUFVolL);
    msg.append(targetUFRateLHR);
    msg.append(_treatmentStatus.ufVolDeliveredL);
    msg.append(static_cast<quint32>(_treatmentSubStates.dialysisSubState));
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}

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

    quint32 elapsedTimeMin  = _treatmentStatus.treatmentElapsedTimeMS / static_cast<float>(SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND);
    // NOTE: min tx time macro was converted to quint32 to prevent compilation error in qMax
    quint32 minTxTimeMin    = qMax(elapsedTimeMin + 2, static_cast<quint32>(MIN_TX_TIME_MINS));
    // TOOD fix maxTime once firmware is done
    quint32 maxTxTime1Min   = minTxTimeMin; // TODO add the UF to it
    quint32 maxTxTime2Min   = MAX_TX_TIME_MINS;
    quint32 maxTxTimeMin    = qMax(maxTxTime1Min, maxTxTime2Min);

    float minUFVolML  = 0.0; // TODO check with firmware for min
    float maxUFVol1ML = minUFVolML + (static_cast<float>(_treatmentParams.treatmentDurationMin - elapsedTimeMin) * MAX_UF_RATE_MLPM);
    float maxUFVol2ML = (_treatmentStatus.presUFRateMLPM > 0.0 ? minUFVolML + static_cast<float>(MAX_TX_TIME_MINS - elapsedTimeMin - 1) : minUFVolML);
    float maxUFVolML  = qMax(maxUFVol1ML, maxUFVol2ML);
    //qDebug() << "TIME settings" << elapsedTimeMin << minTxTimeMin << maxTxTime1Min << maxTxTime2Min << maxTxTimeMin
    //                            << maxUFVol1ML << maxUFVol2ML << maxUFVolML;

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_TREATMENT_PARAM_RANGES_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(minTxTimeMin);
    msg.append(maxTxTimeMin);
    msg.append(minUFVolML);
    msg.append(maxUFVolML);
    msg.append(MIN_DIAL_RATE_MLPM);
    msg.append(MAX_DIAL_RATE_MLPM);
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}