/*!
 *
 * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
 * \copyright
 *          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    messageinterpreter.cpp
 * \date    12/11/2019
 * \author  Behrouz NematiPour
 *
 */
#include "messageinterpreter.h"

// Qt
#include <QDateTime>

// Project
#include "logger.h"
#include "format.h"

using namespace Can;

#define EMIT_RECEIVE_SIGNAL(vID, vMODEL)            \
{                                                   \
    vMODEL mModel;                                  \
    ok = prepareData(vMessage, vID, mModel, vData); \
    if (ok) emit didActionReceive(mModel.data());   \
}                                                   \
break;

/*!
 * \brief MessageInterpreter::MessageInterpreter
 * \details Constructor
 * \param   parent - QObject parent owner object.
 *          Qt handles the children destruction by their parent objects life-cycle.
 */
MessageInterpreter::MessageInterpreter(QObject *parent) : QObject(parent) { }

/*!
 * \brief   MessageInterpreter::isType
 * \details Checks if this is the message intended to be
 * \param   vMessage - The message
 * \param   vType    - The type of the message to be checked against
 * \return  true on correct type
 */
bool MessageInterpreter::isType(const Message &vMessage, Gui::GuiActionType vType) const
{
    if ( vMessage.actionId != vType ) {
        return false;
    }
    return true;
}

/*!
 * \brief   MessageInterpreter::isPayloadLenValid
 * \details Checks if the Data length has been defined for this type od messsage
 *          if not logs Undefind Data Length error
 *          if defined checks if the correct length of data is provided for this type of message.
 *          if not logs Incorrect Data Length error
 *          otherwise returns true
 * \param   vMessage - The message
 * \param   vType    - The type of the message to be checked against
 * \return  true on correct data length for the type vType
 */
bool MessageInterpreter::isPayloadLenValid(const Message &vMessage, Gui::GuiActionType vType) const
{
    QString mActionIdHexString = Format::toHexString(vMessage.actionId);
    if ( ! payloadLen.contains(vType) ) {
        LOG_ERROR(tr("Undefined data length for received Message with ID '%1'").arg(mActionIdHexString));
        return false;
    }
    if ( vMessage.data.length() < payloadLen[vType] ) {
        LOG_ERROR(tr("Incorrect data length for received Message with ID '%1'").arg(mActionIdHexString));
        return false;
    }
    return true;
}

/*!
 * \brief   MessageInterpreter::validateMessage
 * \details Validate the messgae by checking its type and data
 * \param   vMessage - The message
 * \param   vType    - The type of the message to be checked against
 * \return  true on valid massage
 */
bool MessageInterpreter::isValidMessage(const Message &vMessage, Gui::GuiActionType vType) const
{
    if ( ! isType           (vMessage, vType) ) return false;
    if ( ! isPayloadLenValid(vMessage, vType) ) return false;
    return true;
}

/*!
 * \brief   MessageInterpreter::printUnhandled
 * \details Prints out the formatted string of the vMessage of type Message
 *          In case the Message ID of received CANBUS message
 *          is known to the interpreter but has not been handled/implemented.
 * \param   vMessage - The message contains Unhandled Message ID
 */
void MessageInterpreter::printUnhandled(const Message &vMessage) const
{
    if ( gDisableHunhandledReport  ) return;
    QString mActionIdHexString = Format::toHexString(vMessage.actionId, false, eLenMessageIDDigits);
    QString logMessage = tr("Unhandled Message ID (HD)") + '\n' +
                         QString("%1 # %2   %3")
                             .arg(int(vMessage.can_id), 3, 16, QChar('0'))
                             .arg(mActionIdHexString)
                             .arg(QString(vMessage.data.toHex('.')));
    LOG_ERROR(logMessage);
}

/*!
 * \brief   MessageInterpreter::prepareData
 * \details Checks and Prepaires the model with the Message Data
 * \param   vMessage - The Denali message
 * \param   vID      - The Message ID to be checked against
 * \param   vModel   - The appropriate model for the Message Data
 * \param   vData    - A QVariant list of the Message Data which will be used for debugging if needed.
 * \return  true on successful check and prepare.
 */
bool MessageInterpreter::prepareData(const Message &vMessage, Gui::GuiActionType vID, Model::MAbstract &vModel, QVariantList &vData)
{
    bool ok = false;
    if ( ! isValidMessage(vMessage, vID) ) return ok;

    ok = vModel.fromByteArray(vMessage.data);
    LOG_DATUM(vModel.toString());

    vModel.toVariantList(vData);
    return ok;
}

/*!
 * \brief   MessageInterpreter::interpretMessage
 * \details This method will be called
 *          to interpret messages from UI regarding vActionId.
 * \param   vActionId - The ActionID of type GuiActionType
 *          to be interpreted to hex representation of Message ID.
 * \param   vData     - The data which has to be sent over the CANBUS.
 * \param   vPayload  - The Payload of the frame of Type QByteArray of hex values
 *                      Which has been interpreted from vData of Type QVariantList
 * \return  true if the vActionId is valid.
 *          This return value will be used later for error handling.
 */
bool MessageInterpreter::interpretMessage(const Gui::GuiActionType &vActionId, const QVariantList &vData, QByteArray &vPayload)
{
    bool ok = true;
    QString mSenderID = "UI,";

    vPayload.clear();
    int count = vData.count();
    switch (vActionId) { // notice we are in transmit mode
    case Gui::GuiActionType::ID_PowerOff:
        if (count) {
            vPayload += vData[0].toUInt();
        } else {
            QString mActionIdHexString = Format::toHexString(vActionId);
            LOG_ERROR(tr("Incorrect data for transmit Message with ID '%1'").arg(mActionIdHexString));
            ok = false;
        }
        LOG_EVENT(mSenderID + QString("PowerOff," + QVariant(vData).toStringList().join(',')));
        break;

    case Gui::GuiActionType::ID_KeepAlive:
        // Nothing needs to be done.
        // KeepAlive has No data.
        // Mentioned in the switch/case to be registered as a valid message.
        //
        // Note : added this line to be able to do the Fake Test
        if (count) {
            vPayload = Format::fromVariant(vData[0]);
        }
        LOG_EVENT(mSenderID + QString("CheckIn"));
        break;

    case Gui::GuiActionType::ID_Acknow:
        // Nothing needs to be done.
        // Acknow has No data.
        // Mentioned in the switch/case to be registered as a valid message.
        break;

    case Gui::GuiActionType::ID_RawData:
        if (count) {
            vPayload = Format::fromVariant(vData[0]);
        }
        break;

    case Gui::GuiActionType::ID_AdjustBloodDialysateReq:
        if (count) {
            vPayload = Format::fromVariant(vData);
        }
        LOG_EVENT(mSenderID + AdjustBloodDialysateRequestData::toString(vData));
        break;

    case Gui::GuiActionType::ID_AdjustDurationReq:
        if (count) {
            vPayload = Format::fromVariant(vData);
        }
        LOG_EVENT(mSenderID + AdjustDurationRequestData::toString(vData));
        break;

    case Gui::GuiActionType::ID_AdjustUltrafiltrationStateReq:
        if (count) {
            vPayload = Format::fromVariant(vData);
        }
        LOG_EVENT(mSenderID + AdjustUltrafiltrationStateRequestData::toString(vData));
        break;

    case Gui::GuiActionType::ID_AdjustUltrafiltrationEditReq:
        if (count) {
            vPayload = Format::fromVariant(vData);
        }
        LOG_EVENT(mSenderID + AdjustUltrafiltrationEditRequestData::toString(vData));
        break;

    case Gui::GuiActionType::ID_AdjustUltrafiltrationConfirmReq:
        if (count) {
            vPayload = Format::fromVariant(vData);
        }
        LOG_EVENT(mSenderID + AdjustUltrafiltrationConfirmRequestData::toString(vData));
        break;

    default:
        QString mActionIdHexString = Format::toHexString(vActionId);
        LOG_ERROR(mSenderID + tr("Unknown transmit Message with ID '%1'").arg(mActionIdHexString));
        ok = false;
        break;

    }
    return ok;
}

/*!
 * \brief   MessageInterpreter::interpretMessage
 * \details This method will call appropriate message interpreter
 *          for received messages from HD or DG regarding the Can_Id.
 * \param   vCan_Id   - The Channel Id of the CANBUS frame.
 * \param   vMessage  - The complete message of type Message which needs to be interpreted.
 * \param   vActionId - The ActionId of GuiActionType which will be extracted from vMessage.
 * \param   vData     - The values of QVariantList which is understandable for UI
 *                      and has been extracted from hex values of the CANBUS Message Payload
 *                      regarding each Message Id definition.
 * \return  true if the message channel is in the range which can be interpreted, false otherwise.
 *          This return value will be used later to emit MessageDispatcher::didActionReceive signal or not
 */
bool MessageInterpreter::interpretMessage(const Message &vMessage, QVariantList &vData)
{
    bool ok = false;
    switch (vMessage.can_id) {
    case eChlid_HD_UI   :
    case eChlid_HD_Alarm:
    case eChlid_HD_Sync : ok = interpretMessage_HD(vMessage, vData); break;

    // coco-begin-validated: Is a placeholder and There is no definition/implementation of DG communication with UI.
    case eChlid_DG_UI   :
    //case eChlid_DG_Alarm:
    case eChlid_DG_Sync :   ok = interpretMessage_DG(vMessage, vData); break;

    default:
        break;
    // coco-end
    }
    return ok;
}

/*!
 * \brief   MessageInterpreter::interpretMessage_HD
 * \details This method will be called
 *          for received messages from HD to interpret the vMessage of type Message
 *          to vData of type QVariantList which UI understands regarding the Can_Id.
 * \param   vMessage  - The complete message of type Message which needs to be interpreted.
 * \param   vActionId - The ActionId of GuiActionType which will be extracted from vMessage.
 * \param   vData     - The values of QVariantList which is understandable for UI
 *                      and has been extracted from hex values of the CANBUS Message Payload
 *                      in vMessage of type Message regarding each Message Id definition.
 * \return  true if the message CANBUS channel is in the range which can be interpreted, false otherwise.
 *          This return value will be used later to emit MessageDispatcher::didActionReceive signal or not
 */
bool MessageInterpreter::interpretMessage_HD(const Message &vMessage, QVariantList &vData)
{
    bool    ok = false;
    vData.clear();
    //qDebug() << vMessage.actionId;
    switch (vMessage.actionId) { // notice we are in receive mode
    // ----- Debug
    case Gui::GuiActionType::ID_CANBusFaultCount               : ok = canbusFaultCountData         (vMessage, vData); break;

    // ----- Datum
    case Gui::GuiActionType::ID_TreatmentTime                  : ok = treatmentTimeData            (vMessage, vData); break;
    case Gui::GuiActionType::ID_BloodFlow                      : ok = bloodFlowData                (vMessage, vData); break;
    case Gui::GuiActionType::ID_DialysateInletFlow             : ok = dialysateInletFlowData       (vMessage, vData); break;
    case Gui::GuiActionType::ID_DialysateOutletFlow            : ok = dialysateOutletFlowData      (vMessage, vData); break;
    case Gui::GuiActionType::ID_TreatmentRanges                : ok = treatmentRangesData          (vMessage, vData); break;
    case Gui::GuiActionType::ID_PressureOcclusion              : ok = pressureOcclusionData        (vMessage, vData); break;
    case Gui::GuiActionType::ID_TreatmentState                 : ok = treatmentStateData           (vMessage, vData); break;

    // ----- Events
    case Gui::GuiActionType::ID_Acknow                         : ok = true;                                           break;
    case Gui::GuiActionType::ID_PowerOff                       : ok = powerOff                     (vMessage, vData); break;
    case Gui::GuiActionType::ID_PowerOffBroadcast              : ok = true; LOG_EVENT("HD,PowerOff Warning");         break;
    case Gui::GuiActionType::ID_AlarmStatus                    : ok = alarmStatus                  (vMessage, vData); break;
    case Gui::GuiActionType::ID_AlarmTriggered                 : ok = alarmTriggered               (vMessage, vData); break;
    case Gui::GuiActionType::ID_AlarmCleared                   : ok = alarmCleared                 (vMessage, vData); break;

    // Adjustment Response Messages
    case Gui::GuiActionType::ID_AdjustDurationRsp              : ok = adjustDuration               (vMessage, vData); break;
    case Gui::GuiActionType::ID_AdjustBloodDialysateRsp        : ok = adjustBloodDialysate         (vMessage, vData); break;
    case Gui::GuiActionType::ID_AdjustUltrafiltrationStateReq  : ok = adjustUltrafiltrationState   (vMessage, vData); break;
    case Gui::GuiActionType::ID_AdjustUltrafiltrationEditRsp   : ok = adjustUltrafiltrationEdit    (vMessage, vData); break;
    case Gui::GuiActionType::ID_AdjustUltrafiltrationConfirmRsp: ok = adjustUltrafiltrationConfirm (vMessage, vData); break;

    // unhandles messages: these will only be logged as received message
    // there has nothing been defined for these messages.
    default                                                 :      printUnhandled               (vMessage       ); break;
    }

    return ok;
}

/*!
 * \brief   MessageInterpreter::interpretMessage_DG
 * \details This method will be called
 *          for received messages from DG to interpret the vMessage of type Message
 *          to vData of type QVariantList which UI understands regarding the Can_Id.
 * \param   vMessage  - The complete message of type Message which needs to be interpreted.
 * \param   vActionId - The ActionId of GuiActionType which will be extracted from vMessage.
 * \param   vData     - The values of QVariantList which is understandable for UI
 *                      and has been extracted from hex values of the CANBUS Message Payload
 *                      in vMessage of type Message regarding each Message Id definition.
 * \return  true if the message CANBUS channel is in the range which can be interpreted, false otherwise.
 *          This return value will be used later to emit MessageDispatcher::didActionReceive signal or not
 */
bool MessageInterpreter::interpretMessage_DG(const Message &vMessage, QVariantList &vData)
{
    bool    ok = false;
    QString mSenderID = "DG,";
    vData.clear();

    switch (vMessage.actionId) { // notice we are in receive mode
    case Gui::GuiActionType::ID_DGCheckIn:
        ok = true;
        LOG_EVENT(mSenderID + QString("DG,CheckIn," + QVariant(vData).toStringList().join(',')));
        break;

    case Gui::GuiActionType::ID_DGROPumpData           : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGROPumpData           , Model::MDGROPump             )
    case Gui::GuiActionType::ID_DGPressuresData        : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGPressuresData        , Model::MDGPressures          )
    case Gui::GuiActionType::ID_DGDrainPumpData        : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGDrainPumpData        , Model::MDGDrainPump          )
    case Gui::GuiActionType::ID_DGOperationModeData    : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGOperationModeData    , Model::MDGOperationMode      )
    case Gui::GuiActionType::ID_DGReservoirData        : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGReservoirData        , Model::MDGReservoir          )
    case Gui::GuiActionType::ID_DGValvesStatesData     : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGValvesStatesData     , Model::MDGValvesStates       )
    case Gui::GuiActionType::ID_DGHeatersData          : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGHeatersData          , Model::MDGHeaters            )
    case Gui::GuiActionType::ID_DGLoadCellReadingsData : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGLoadCellReadingsData , Model::MDGLoadCellReadings   )
    case Gui::GuiActionType::ID_DGTemperaturesData     : EMIT_RECEIVE_SIGNAL(Gui::GuiActionType::ID_DGTemperaturesData     , Model::MDGTemperatures       )

    // unhandles messages: these will only be logged as received message
    // there has nothing been defined for these messages.
    default                                     :
        printUnhandled           (vMessage);
        break;

    }

    return ok;
}

// ---------- ---------- Message handlers ---------- ---------- //

// ---------- ---------- ---------- ---------- ---------- Debug ---------- ---------- ---------- ---------- ---------- //
/*!
 * \brief   MessageInterpreter::canbusFaultCountData
 * \details This method interprets Fault Count message data
 *          in vMessage of type Message. This message is only used for debugging purposes.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Fault Count data
 * \return  true if the data can be extracted as defined for Fault Count Message ID
 */
bool MessageInterpreter::canbusFaultCountData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_CANBusFaultCount) ) return ok;

    QVariantList mData;
    int index = 0;
    Types::U32 mCanBUSFaultCount;
    ok = GetValue(vMessage.data, index, mCanBUSFaultCount);
    // coco begin validated : developer safety if for any reason length of CanBUSFaultCount set to 0
    if (ok) {
        // coco end
        vData += mCanBUSFaultCount.value;
    }
    return ok;
}

// ---------- ---------- ---------- ---------- ---------- Data ---------- ---------- ---------- ---------- ---------- //
// ---------- ---------- ---------- ---------- ---------- - HD ---------- ---------- ---------- ---------- ---------- //

/*!
 * \brief   MessageInterpreter::treatmentTimeData
 * \details This method interprets Treatment Time message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment Time data
 * \return  true if the data can be extracted as defined for Treatment Time Message ID
 */
bool MessageInterpreter::treatmentTimeData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_TreatmentTime) ) return ok;

    Model::MTreatmentTime mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::bloodFlowData
 * \details This method interprets Blood Flow message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Blood Flow data
 * \return  true if the data can be extracted as defined for Blood Flow Message ID
 */
bool MessageInterpreter::bloodFlowData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_BloodFlow)) return ok;

    Model::MBloodFlow mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::dialysateInletFlowData
 * \details This method interprets Dialysate Inlet Flow message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Dialysate Inlet Flow data
 * \return  true if the data can be extracted as defined for Dialysate Inlet Flow Message ID
 */
bool MessageInterpreter::dialysateInletFlowData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_DialysateInletFlow) ) return ok;

    Model::MDialysateFlow mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::dialysateOutletFlowData
 * \details This method interprets Dialysate Outlet Flow message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Dialysate Outlet Flow data
 * \return  true if the data can be extracted as defined for Dialysate Outlet Flow Message ID
 */
bool MessageInterpreter::dialysateOutletFlowData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_DialysateOutletFlow) ) return ok;

    Model::MOutletFlow mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::treatmentRangesData
 * \details This method interprets Treatment Ranges message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment Ranges data
 * \return  true if the data can be extracted as defined for Treatment Ranges Message ID
 */
bool MessageInterpreter::treatmentRangesData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_TreatmentRanges) ) return ok;

    Model::MTreatmentRanges mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::pressureOcclusionData
 * \details This method interprets Pressure/Occlusion message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Pressure/Occlusion data
 * \return  true if the data can be extracted as defined for Pressure/Occlusion Message ID
 */
bool MessageInterpreter::pressureOcclusionData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_PressureOcclusion) ) return ok;

    Model::MPressureOcclusion mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::treatmentStateData
 * \details This method interprets Treatment State message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment State data
 * \return  true if the data can be extracted as defined for Treatment State Message ID
 */
bool MessageInterpreter::treatmentStateData(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_TreatmentState) ) return ok;

    Model::MTreatmentState mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_DATUM("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

// ---------- ---------- ---------- ---------- ---------- - DG   ---------- ---------- ---------- ---------- ---------- //


// ---------- ---------- ---------- ---------- ---------- Events ---------- ---------- ---------- ---------- ---------- //
// ---------- ---------- ---------- ---------- ---------- - HD   ---------- ---------- ---------- ---------- ---------- //

/*!
 * \brief   MessageInterpreter::powerOff
 * \details This method interprets Power Off message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Power Off data
 * \return  true if the data can be extracted as defined for Power Off Message ID
 */
bool MessageInterpreter::powerOff(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_PowerOff) ) return ok;

    Model::MPowerOff mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::alarmStatus
 * \details This method interprets Alarm Status message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Alarm Status data
 * \return  true if the data can be extracted as defined for Alarm Status Message ID
 */
bool MessageInterpreter::alarmStatus(const Message &vMessage, QVariantList &vData) {
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AlarmStatus) ) return ok;

    Model::MAlarmStatus mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;

    // --- an example of unit test --- //
    // Types::Flags flag;
    // int i = 0;
    // QByteArray ba;
    // ba += 0x83; ba += 0xf8; ba += 0x28; ba += 0xa1;
    // Types::getBits(ba, i, flag, 32);
    // qDebug() << '@' << flag << flag.toString() << ba;
}

/*!
 * \brief   MessageInterpreter::alarmTriggered
 * \details This method interprets Alarm Triggered message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Alarm Triggered data
 * \return  true if the data can be extracted as defined for Alarm Triggered Message ID
 */
bool MessageInterpreter::alarmTriggered(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AlarmTriggered) ) return ok;

    Model::MAlarmTriggered mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::alarmCleared
 * \details This method interprets Alarm Cleared message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Alarm Cleared data
 * \return  true if the data can be extracted as defined for Alarm Cleared Message ID
 */
bool MessageInterpreter::alarmCleared(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AlarmCleared) ) return ok;

    Model::MAlarmCleared mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

// ---------- ---------- ---------- ---------- ---------- Adjustments ---------- ---------- ---------- ---------- ---------- //

/*!
 * \brief   MessageInterpreter::adjustDurationData
 * \details This method interprets Treatment Duration Adjustment Response message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment Duration Adjustment Response data
 * \return  true if the data can be extracted as defined for Treatment Duration Adjustment Response Message ID
 */
bool MessageInterpreter::adjustDuration(const Message &vMessage, QVariantList &vData)
{
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AdjustDurationRsp) ) return ok;

    Model::MAdjustDurationResponse mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::adjustBloodDialysateData
 * \details This method interprets AdjustBlood Dialysate Response message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - AdjustBlood Dialysate Response data
 * \return  true if the data can be extracted as defined for AdjustBlood Dialysate Response Message ID
 */
bool MessageInterpreter::adjustBloodDialysate(const Message &vMessage, QVariantList &vData)
{
    // TODO : review other methods
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AdjustBloodDialysateRsp) ) return ok;

    Model::MAdjustBloodDialysateResponse mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::ultrafiltrationState
 * \details This method interprets Treatment Ultrafiltration State Adjustment Response message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment Ultrafiltration State Adjustment Response data
 * \return  true if the data can be extracted as defined for Treatment Ultrafiltration State Adjustment Response Message ID
 */
bool MessageInterpreter::adjustUltrafiltrationState(const Message &vMessage, QVariantList &vData)
{
    bool ok = false;
    // TODO : In HD the Ultrafiltration State change shall have the rejection reason like other responses.
    if ( ! isType           (vMessage, Gui::GuiActionType::ID_AdjustUltrafiltrationStateReq) ) return ok;
    if ( ! isPayloadLenValid(vMessage, Gui::GuiActionType::ID_AcknowGeneric                ) ) return ok;

    Model::MAdjustUltrafiltrationStateResponse mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::adjustUltrafiltrationEditData
 * \details This method interprets Treatment Ultrafiltration Volume Adjustment Response message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment Ultrafiltration Volume Adjustment Response data
 * \return  true if the data can be extracted as defined for Treatment Ultrafiltration Volume Adjustment Response Message ID
 */
bool MessageInterpreter::adjustUltrafiltrationEdit(const Message &vMessage, QVariantList &vData)
{
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AdjustUltrafiltrationEditRsp) ) return ok;

    Model::MAdjustUltrafiltrationEditResponse mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}

/*!
 * \brief   MessageInterpreter::adjustUltrafiltrationConfirmData
 * \details This method interprets Treatment Ultrafiltration Volume Adjustment Confirm Response message data
 *          in vMessage of type Message.
 * \param   vMessage    - The vMessage of type Message which contains all the data,
 *                        require to be interpreted.
 * \param   vData       - Treatment Ultrafiltration Volume Adjustment Confirm Response data
 * \return  true if the data can be extracted as defined for Treatment Ultrafiltration Volume Adjustment Confirm Response Message ID
 */
bool MessageInterpreter::adjustUltrafiltrationConfirm(const Message &vMessage, QVariantList &vData)
{
    bool ok = false;
    if ( ! isValidMessage(vMessage, Gui::GuiActionType::ID_AdjustUltrafiltrationConfirmRsp) ) return ok;

    Model::MAdjustUltrafiltrationConfirmResponse mData;
    ok = mData.fromByteArray(vMessage.data);
    LOG_EVENT("HD," + mData.toString());

    mData.toVariantList(vData);
    emit didActionReceive(mData.data());

    return ok;
}