#pragma once


#include <QObject>
#include <QHash>
#include <QRandomGenerator>

#include "DryDemoDefines.h"
#include "LeahiDryDemoXMLStates.h"
#include "main.h"
#include "MessageGlobals.h"

#define _StateController StateController::I()

// TODO check illegal state transition

class StateController : public QObject
{
    Q_OBJECT
    SINGLETON(StateController)

public:
    void init(); // TODO move these in slots
    void quit();

public slots:
    void doStateControllerUnhandledMsgReceived(const QVariantList &msg);

protected:
    void timerEvent(QTimerEvent *) override;

private:
    struct Treatment_Status_Vars {
        bool hasTxParamsBeenInitialized;
        User_Command_ID userCmd;
        QString stateTransitionEvent;
        bool requestTreatmentReset;
        // Treatment time variable(s)
        quint32 treatmentElapsedTimeMS;
        // Fluid bolus
        Fluid_Bolus_States fluidBolusState;
        float accumFluidBolusDeliveredML;
        float totalFluidBolusDeliveredML;
        // Treatment states
        Treatment_States txState;
        Dialysis_States dialysisSubState;
        // UF variables
        float presUFRateMLPM;
        float ufVolDeliveredL;
        bool validateUFVolReceived;
        float validateUFVolGoalL;
        float validateUFRateLHR;
        // Treatment duration variables
        bool validateTxDurReceived;
        quint32 validateTxDurMin;
        quint32 validateHepDurMin;
        // Alarm variables
        Alarm_List activeAlarm;
        // Rinseback variables
        Rinseback_States rinsebackStates;
        quint32 rinsebackFlowMLPM;
        float accumRinsebackVolML;
        float additionalRinsebackVolML;
        bool isRinsebackComplete;
        quint32 rinsebackTimerCounter;
    };

    struct Treatment_Params {
        bool    finalConfirmation;
        quint32 treatmentModality;
        quint32 hdfDilution;
        quint32 bloodFlowRateMLPM;
        quint32 dialysateFlowRateMLPM;
        quint32 treatmentDurationMin;
        quint32 heparinDeliveryDurationMin;
        quint32 heparinType;
        quint32 dryBicarbCartSize;
        quint32 sodiumMEQL;
        quint32 bicarbobateMEQL;
        quint32 dialyzerType;
        quint32 fluidBlousVolumeML;
        quint32 bloodPressureIntervalMin;
        quint32 rinsebackVolumeML;
        quint32 hepatitisBStatus;
        quint32 acidConcentrate;
        float   substitutionFluidVolumeL;
        float   heparinBolusVolumeML;
        float   heparinDeliveryRateMLHR;
        float   dialysateTemperatureC;
        float   acidKConcentrateConversionFactor;
        float   ufPreWeightKG;
        float   ufEstimatedTargetWeightKG;
        float   ufVolumeL;
    };

    QHash<User_Command_ID, QVariantList> _transitionEventsFromStandby;
    QHash<Alarm_List, QVariantList> _alarmTriggerSpecs;
    QList<QVariantList> _broadcastMessages;
    QList<QVariantList> _sendMessages;
    QHash<Can::MessageID, QVariant> _treatmentRcvdMessages;
    QRandomGenerator _randNumGenerator;
    Treatment_Params _treatmentParams;
    Treatment_Status_Vars _treatmentStatus;
    bool _isBroadcastListReady;  // TODO use a mutex?
    bool _isSendListReady;       // Todo use a mutex?
    drydemoXMLStates _dryDemo;

    // CAN function(s)
    void sendMessages(bool isBroadcast);
    bool handleDryDemoMenuRequestMessage();

    // State handlers
    void onStandbyStateChange(bool active);
    void onPretreatmentStateChange(bool active);
    void onBloodPrimeStateChange(bool active);
    void onTreatmentStateChange(bool active);
    void onTreatmentPauseStateChange(bool active);
    void onTreatmentRinsebackStateChange(bool active);
    void onTreatmentRecriculateStateChange(bool active);
    void onTreatmentEndStateChange(bool active);

    // Helper methods
    void handleTDOpModeTransitionBroadcastData(const Can::TD_OP_MODE mode, const quint32 subMode, const Broadcast_Type BCType);
    void setTreatmentParametersFromUI(const QVariant &payload); // TODO move the implementation to pretx cpp
    void handleUIResponseMessage(const Can::Message_ID_Enum msgID, const quint32 acceptReject, const QVariantList &rejectReasons = {});
    void resetDryDemoVariables();
    void handleBackToStandbyEvent(State_Status &status);
    quint32 extractU32DataFromReceivedMessage(const Can::Message_ID_Enum msgID, qint32 index);
    float extractF32DataFromReceivedMessage(const Can::Message_ID_Enum msgID, qint32 index);
    void triggerAnAlarm(Alarm_List alarmID);
    void handleAlarmUserAction(State_Status &status);

    // Standby methods
    void handleInitiateTreatmentRequestMessage(State_Status &status);
    void handleSendUIConfirmationMessage(const Generic_Confirm_Id confirmID, const Generic_Confirm_Command confirmCmd, const Reject_Reasons rejectReason = REQUEST_REJECT_REASON_NONE);

    // Blood prime methods
    float getBloodPrimeRampStepML();
    void handleBloodPrimeBroadcastData(const float accumulatedVolML, const quint32 primeTimeOutS, const quint32 pauseCountDownS, const Broadcast_Type BCType);
    void handleBloodPrimeVolML(const bool resume, const float rampStepML, const bool hasFlowChanged, quint32 &currBloodFlowMLPM, float &accumBloodVolML);

    // Treatment methods
    void setTreatmentParametersToDefault();
    void initializeTreatmentTimeAndUltrafiltration();
    void handleTreatmentSetpointsBroadcastData(const quint32 bloodFlowMLPM, const quint32 dialFlowMLPM, const float dialTempC, const Broadcast_Type BCType);
    void handleTreatmentStatesBroadcastData(const QList<quint32> &txStates, const Broadcast_Type BCType);
    void handleFluidBolusRequestMessage();
    void handleFluidBolusFluidDelivery(const quint32 bloodFlowMLPM);
    void handleFluidBolusBroadcastData(const Broadcast_Type BCType);
    void handleTDPressureProcessAndBroadcastData(const Broadcast_Type BCType);
    void handleTreatmentTimeProcessAndBroadcastData(const Broadcast_Type BCType);
    void handleTreatmentPrescriptionEditRequestMessage();
    void handleSetPointBloodFlowChange(quint32 &bloodFlowMLPM, bool &hasBloodFlowChanged);
    void handleDDGenDialysateModeBroadcastData(const Broadcast_Type BCType);
    void handleSetPointDialysateFlowChange();
    void handleDDConductivityBroadcastData(const Broadcast_Type BCType);
    void handleTDBloodPressureBroadcastData(const Broadcast_Type BCType);
    void handleUltrafiltrationBroadcastData(const Broadcast_Type BCType);
    void handleSetPointDialysateTemperatureChange();
    void handleUltrafiltrationPauseResume();
    void handleUltrafiltrationVolumeChangeValidation();
    void handleTreatmentSettingBroadcastData(const Broadcast_Type BCType);
    void handleUltrafiltrationVolumeChangeConfirm();
    void handleTreatmentTimeChangeValidation();
    void handleTreatmentTimeChangeConfirm();

    // Treatment rinseback methods
    void initializeRinseback();
    void handleRinsebackRequestMessage();
    void handleRinsebackDelivery();
    void handleRinsebackBroadcastData(const Broadcast_Type BCType);

    // Treatment end methods

};