/*!
 *
 * 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    messagehandler.cpp
 * date    10/26/2019
 * author  Behrouz NematiPour
 *
 */
#include "messagehandler.h"

// Qt
#include <QDebug>
#include <QTimerEvent>

// Project
#include "maintimer.h"
#include "messagedispatcher.h"
#include "caninterface.h"

// namespace
using namespace Can;

// Singleton
SINGLETON_INIT(MessageHandler)

/*!
 * \brief MessageHandler Constructor
 * \param parent
 */
MessageHandler::MessageHandler(QObject *parent) : QObject(parent) { }

/*!
 * \brief Message Handler initializer
 */
void MessageHandler::init()
{
    initConnections();
}

/*!
 * \brief Message Handler connections definition
 * \details Initializes the required signal/slot connection between this class and other objects\n
 * to be able to communicate.
 */
void MessageHandler::initConnections()
{
    // From GUI
    connect(_MessageDispatcher, SIGNAL(didFrameTransmit(Can_Id, const QByteArray   &)),
            this              ,   SLOT( onFrameTransmit(Can_Id, const QByteArray   &)));

    // From CAN
    connect(_CanInterface     , SIGNAL( didFrameReceive(        const QCanBusFrame &)),
            this              ,   SLOT(  onFrameReceive(        const QCanBusFrame &)));
}

void MessageHandler::transmitFrame(Can_Id vFrameId, const QByteArray &vData)
{
    QCanBusFrame mFrame;
    mFrame.setFrameId(vFrameId);
    if (vData.length() > Can::eLenCanFrame) {
        qDebug() << "Error :" << tr("Payload can't be larger than %1 bytes").arg(Can::eLenCanFrame);
        return;
    }
    mFrame.setPayload(vData);
    emit didFrameTransmit(mFrame);
}

MessageHandler::ChannelGroup MessageHandler::checkChannel(quint32 vFrameId, bool *vOK)
{
    bool ok = true;
    MessageHandler::ChannelGroup channelGroup = ChannelGroup::eChannel_Unknown;
    switch (vFrameId) {
    case eChlid_HD_DG    :
    case eChlid_DG_HD    :
        channelGroup = ChannelGroup::eChannel_Ignores;
        break;

    case eChlid_HD       :
    case eChlid_HD_Alarm :
    case eChlid_DG_Alarm :
    case eChlid_HD_Sync  :
    case eChlid_DG_Sync  :
    //case eChlid_DG_UI    : // has duplicate value as eChlid_DG_Alarm
    //case eChlid_UI_DG    : // has duplicate value as eChlid_UI_Sync
        channelGroup = ChannelGroup::eChannel_Listens;
        break;

    case eChlid_UI_Alarm :
    case eChlid_UI_Sync  :
    case eChlid_UI       :
        channelGroup = ChannelGroup::eChannel_Outputs;
        break;

    default:
        ok = false;
        break;
    }

    if (vOK) *vOK = ok;
    return channelGroup;
}

void MessageHandler::onFrameTransmit(Can_Id vCan_ID, const QByteArray &vData)
{
    transmitFrame(vCan_ID, vData);
}

/*!
 * \brief MessageHandler::onRead
 * \param vFrame
 */
void MessageHandler::onFrameReceive(const QCanBusFrame &vFrame)
{
    bool ok = false;
    quint32 mFrameId = vFrame.frameId();
    ChannelGroup channelGroup = checkChannel(mFrameId, &ok);

    if (!ok){
        qDebug() << "ERROR : " << "Unexpected Channel";
        return;
    }

    if ( channelGroup != ChannelGroup::eChannel_Listens) {
        return;
    }

    Can_Id mCanId = static_cast<Can_Id>(mFrameId);
    emit didFrameReceive(mCanId, vFrame.payload());
}