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


void StateController::initializeRinseback()
{
    _treatmentStatus.rinsebackFlowMLPM          = DEF_TX_PARAM_RINSEBACK_FLOW_RATE_MLPM;
    _treatmentStatus.accumFluidBolusDeliveredML = 0.0;
    _treatmentStatus.additionalRinsebackVolML   = _treatmentParams.rinsebackVolumeML;
    _treatmentStatus.isRinsebackComplete        = false;
    _treatmentStatus.rinsebackTimerCounter      = 0;
}

void StateController::handleRinsebackRequestMessage()
{
    // TODO should we check if an alarm is active?
    if (_treatmentRcvdMessages[ID_UI_RINSEBACK_CMD_RQST].isNull()) { return; }
    QVariantList reason;
    quint32 acceptReject = REJECT_VALUE;
    quint32 rinsebackCmd = extractU32DataFromReceivedMessage(ID_UI_RINSEBACK_CMD_RQST, 0);

    switch (rinsebackCmd) {
        case REQUESTED_USER_ACTION_RINSEBACK_CONFIRM_START:
            if (_treatmentStatus.rinsebackStates == RINSEBACK_STOP_INIT_STATE) {
                acceptReject                     = ACCEPT_VALUE;
                _treatmentStatus.rinsebackStates = RINSEBACK_RUN_STATE;
            }
            else { reason.append(REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE); }
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_INCREASE_RATE:
            if ((_treatmentStatus.rinsebackFlowMLPM + RINSEBACK_ADJ_FLOW_RATE_MLPM) <= RINSEBACK_MAX_RLOW_RATE_MLPM) {
                if (_treatmentStatus.rinsebackStates == RINSEBACK_RUN_STATE) {
                    acceptReject                        = ACCEPT_VALUE;
                    _treatmentStatus.rinsebackFlowMLPM += RINSEBACK_ADJ_FLOW_RATE_MLPM;
                }
                else { reason.append(REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE); }
            }
            else { reason.append(REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE); }
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_DECREASE_RATE:
            if ((_treatmentStatus.rinsebackFlowMLPM - RINSEBACK_ADJ_FLOW_RATE_MLPM) >= RINSEBACK_MIN_FLOW_RATE_MLPM) {
                if (_treatmentStatus.rinsebackStates == RINSEBACK_RUN_STATE) {
                    acceptReject                        = ACCEPT_VALUE;
                    _treatmentStatus.rinsebackFlowMLPM -= RINSEBACK_ADJ_FLOW_RATE_MLPM;
                }
                else { reason.append(REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE); }
            }
            else { reason.append(REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE); }
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_PAUSE:
            if (_treatmentStatus.rinsebackStates == RINSEBACK_RUN_STATE) {
                acceptReject                     = ACCEPT_VALUE;
                _treatmentStatus.rinsebackStates = RINSEBACK_PAUSED_STATE;
            }
            else { reason.append(REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE); }
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_RESUME:
            if (_treatmentStatus.rinsebackStates == RINSEBACK_PAUSED_STATE) {
                acceptReject                     = ACCEPT_VALUE;
                _treatmentStatus.rinsebackStates = RINSEBACK_RUN_STATE;
            }
            else { reason.append(REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE); }
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_ADDITIONAL:
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_CONFIRM_RECIRCULATE:
            break;

        case REQUESTED_USER_ACTION_RINSEBACK_END_TREATMENT:
            handleSendUIConfirmationMessage(GENERIC_CONFIRM_ID_TREATMENT_END, GENERIC_CONFIRM_CMD_REQUEST_OPEN);
            break;
    }

    handleUIResponseMessage(ID_TD_RINSEBACK_CMD_RESP, acceptReject, reason);
    _treatmentRcvdMessages[ID_UI_RINSEBACK_CMD_RQST].clear();
}

void StateController::handleRinsebackDelivery()
{
    _treatmentStatus.rinsebackTimerCounter++;

    if (_treatmentStatus.rinsebackStates == RINSEBACK_RUN_STATE) {
        _treatmentStatus.accumRinsebackVolML += _treatmentStatus.rinsebackFlowMLPM * RINSEBACK_FLOW_INTEGRATOR;
    }

    if (_treatmentStatus.accumRinsebackVolML >= _treatmentParams.rinsebackVolumeML) {
        _treatmentStatus.rinsebackStates          = RINSEBACK_STOP_STATE;
        _treatmentStatus.additionalRinsebackVolML = _treatmentStatus.accumRinsebackVolML;
    }
}

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

    quint32 rinsebackTimeoutS       = RINSEBACK_BACK_MAX_TIME_MS / MILLISECONDS_PER_SECOND;
    quint32 rinsebackTimerCounterMS = _treatmentStatus.rinsebackTimerCounter * QOBJECT_TIMER_TIMEOUT_MS;
    quint32 countdownS              = ( rinsebackTimerCounterMS <= RINSEBACK_BACK_MAX_TIME_MS ? RINSEBACK_BACK_MAX_TIME_MS - rinsebackTimerCounterMS : 0) / MILLISECONDS_PER_SECOND;
    bool isRecircAllowed            = true;

    if (_treatmentStatus.isRinsebackComplete || (_treatmentStatus.rinsebackTimerCounter == 0)) {
        countdownS        = 0;
        rinsebackTimeoutS = 0;
    }

    QVariantList msg;
    msg.append(static_cast<quint16>(ID_TD_RINSEBACK_DATA));
    msg.append(Can_Id::eChlid_TD_Sync);
    msg.append(_treatmentStatus.additionalRinsebackVolML);
    msg.append(_treatmentStatus.accumRinsebackVolML);
    msg.append(_treatmentStatus.rinsebackFlowMLPM);
    msg.append(rinsebackTimeoutS);
    msg.append(countdownS);
    msg.append(static_cast<quint32>(_treatmentStatus.isRinsebackComplete));
    msg.append(static_cast<quint32>(isRecircAllowed)); // Is recirculation allowed? TODO check this
    _isBroadcastListReady = false;
    _broadcastMessages.append(msg);
    _isBroadcastListReady = true;
}