/*!
 *
 * Copyright (c) 2020-2024 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    ApplicationController.cpp
 * \author  (last)      Dara Navaei
 * \date    (last)      26-Mar-2024
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  26-Aug-2020
 *
 */
#include "ApplicationController.h"

// Qt
#include <QtConcurrent/QtConcurrent>

// Project
#include "MainTimer.h"
#include "MessageDispatcher.h"
#include "Logger.h"
//#include "FileHandler.h"
#include "Settings.h"
#include "MSettings.h"
#include "StateController.h"


// TODO: Clean up APPLICATION CONTROLLER

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

/*!
 * \brief ApplicationController initializer
 */
bool ApplicationController::init()
{
    if ( _init ) return false;
    _init = true;

    initConnections();
    LOG_DEBUG(QString("%1 Initialized").arg(metaObject()->className()));

    return true;
}

/*!
 * \brief   ApplicationController::init
 * \details Initialized the Class by calling the init() method first
 *          And initializes the thread vThread by calling initThread
 *          on success init().
 * \param   vThread - the thread
 * \return  returns the return value of the init() method
 */
bool ApplicationController::init(QThread &vThread)
{
    if ( ! init() ) return false;
    initThread(vThread);
    return true;
}

/*!
 * \brief   ApplicationController::quit
 * \details quits the class
 *          Calls quitThread
 */
void ApplicationController::quit()
{
    // disabled coco begin validated: Application termination is not correctly done in coco!!!
    // it has been tested and works perfectly fine in normal run.
    quitThread(); // validated
}

void ApplicationController::doUnhandledMsgAppController(const QVariantList &msg)
{
    qDebug() << "Test Slot" << msg;
    emit didUnhandledMsgAppController(msg);
}
// disabled coco end

/*!
 * \brief   ApplicationController::initConnections
 * \details Initializes the required signal/slot connection between this class and other objects
 *          to be able to communicate.
 */
void ApplicationController::initConnections()
{   connect(&_MainTimer        , SIGNAL(        didTimeout()),
            this               ,   SLOT(onMainTimerTimeout()));

    // From HD/DG
    connect(&_MessageDispatcher, SIGNAL(didFailedTransmit(Sequence)),
            this               ,   SLOT( onFailedTransmit(Sequence)));

    connect(&_Logger        , SIGNAL(didExportLogs      ()),
            this            ,   SLOT( onExport          ()));
    connect(&_Logger        , SIGNAL(didExportStat      (quint32, const QString &, quint8)),
            this            ,   SLOT( onExportStat      (quint32, const QString &, quint8)));
    connect(&_Logger        , SIGNAL(didLogIOFail         ()),
            this            ,   SLOT( onLogIOFail         ()));

    connect(&_post  , SIGNAL(   didDone (bool               )),
            this    , SLOT  (onPOSTDone (bool               )));

    connect(&_settingsWatcher, SIGNAL(finished        ()),
            this             ,   SLOT(onSettingsUpdate()));

    connect(&_MessageDispatcher, SIGNAL(didUnhandledMsgDispatcher(const QVariantList &)),
            this               ,   SLOT(doUnhandledMsgAppController(const QVariantList &)));
}

/*!
 * \brief   ApplicationController::initThread
 * \details Moves this object into the thread vThread.
 *          And checks that this method is called from main thread.
 *          Also connects quitThread to application aboutToQuit.
 * \param   vThread - the thread
 */
void ApplicationController::initThread(QThread &vThread)
{
    // runs in main thread
    Q_ASSERT_X(QThread::currentThread() == qApp->thread(), __func__, "The Class initialization must be done in Main Thread" );
    _thread = &vThread;
    _thread->setObjectName(QString("%1_Thread").arg(metaObject()->className()));
    connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(quit()));
    _thread->start();
    moveToThread(_thread);
}

/*!
 * \brief   ApplicationController::quitThread
 * \details Moves this object to main thread to be handled by QApplication
 *          And to be destroyed there.
 */
void ApplicationController::quitThread()
{
    // disabled coco begin validated: Application termination is not correctly done in coco!!!
    // it has been tested and works perfectly fine in normal run.

    if ( ! _thread ) return;

    // runs in thread
    moveToThread(qApp->thread()); // validated
}
// disabled coco end

/*!
 * \brief   ApplicationController::onFailedTransmit
 * \details Called when failed to get a response back from the HD
 * \param   seq - The sequence that failed to send to the HD.
 */
void ApplicationController::onFailedTransmit(Sequence seq)
{
    emit didFailedTransmit(seq);
}

/*!
 * \brief   Process the requested action
 * \details Processes the requested action
 * \param   vAction - User requested Action
 * \param   vData   - Action data to be transmitted.
 */
void ApplicationController::onActionTransmit(const QVariantList &vData)
{
    emit didActionTransmit(vData);
}

/*!
 * \brief   An action has been confirmed
 * \details GUI requested an action.
 *          In response HD confirmed the action.
 * \param   vAction - Received action
 * \param   vData   - data of the action
 */
void ApplicationController::onActionReceive (const QVariantList &vData)
{
    emit didActionReceive(vData);
}

/*!
 * \brief   ApplicationController::onMainTimerTimeout
 * \details This slot is called by MainTimer::didTimeout each second
 *          to call required methods like keepAlive
 */
void ApplicationController::onMainTimerTimeout()
{
    keepAlive();
}

/*!
 * \brief   ApplicationController::onExport
 * \details the slot which will be called by logger is done exporting.
 */
void ApplicationController::onExport()
{
    // disabled coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    emit didExport();
}

void ApplicationController::onExportStat(quint32 vIndex, const QString &vFileName, quint8 vPercent)
{
    // DEBUG: qDebug() << "1" << vIndex << vFileName << vPercent;
    emit didExportStat(vIndex, vFileName, vPercent);
}
// disabled coco end

/*!
 * \brief   ApplicationController::keepAlive
 * \details This is the message which has to be send over the CANBus
 *          as an monitor for other nodes on the bus to notify UI is alive
 */
void ApplicationController::keepAlive()
{
    // DEBUG: return;
#ifndef DISABLE_KEEP_ALIVE
    QVariantList mData;
    int mFakeDataLen = gFakeData.length();
    // coco begin validated: This is a fake data generator for CANBus missing/swapped frames Testing
    // will never be executed on the product
    // has been tested manually
    if (mFakeDataLen) {
        if (gFakeSeqAtBegin) {
            createFakeSeqAtBeginLongMessage(mData, mFakeDataLen);
        }
        else {
            createFakeSequencedLongMessage (mData, mFakeDataLen);
        }
    }
    // disabled coco end
    else {
        mData += 0;
    }
    onActionTransmit(mData);
#endif
}

/*!
 * \brief   ApplicationController::createFakeSequencedLongMessage
 * \details This method is creating the fake message with frame sequence
 *          which we use for Denali Message test
 * \param   vFakeDataLen
 */
void ApplicationController::createFakeSequencedLongMessage(QVariantList &vData, const int vFakeDataLen)
{
    // disabled coco begin validated: This is a fake data generator for CANBus missing/swapped frames Testing
    // will never be executed on the product
    // has been tested manually
    QByteArray data;
    if (vFakeDataLen == 1 && gFakeData == QByteArray::fromHex(gFakeData_default)) {
        static quint16 txCount = 0;
        Types::U16 seq;
        quint8 dataBytesLeft = 0;
        const quint8 crcBytesLen   = 2;
        for (int i = 0; i < 13; i++) {
            switch (i) {
            case 0: // First frame : HEAD
                seq.value = txCount;
                data += seq.bytes[0];
                data += seq.bytes[1];
                break;

            case 12: // Last frame with CRC
                dataBytesLeft = 8 - sizeof(seq) - crcBytesLen;
                for (int j = 0; j < dataBytesLeft; j++) {
                    data += (char)(0);
                }
                seq.value = txCount;
                data += seq.bytes[0];
                data += seq.bytes[1];
                break;

            default:  // Middle Frames
                dataBytesLeft = 8 - sizeof(seq);
                for (int j = 0; j < dataBytesLeft; j++) {
                    data += (char)(0);
                }
                seq.value = txCount;
                data += seq.bytes[0];
                data += seq.bytes[1];
                break;

            }
            Types::safeIncrement(txCount);
        }
        vData += QByteArray::fromHex(data.toHex());
    }
    else {
        vData += gFakeData;
    }
}
// disabled coco end

/*!
 * \brief   ApplicationController::createFakeSequencedAtBeginLongMessage
 * \details This method is creating the fake message with frame sequence
 *          which we use for Denali Message test
 * \param   vFakeDataLen
 */
void ApplicationController::createFakeSeqAtBeginLongMessage(QVariantList &vData, const int vFakeDataLen)
{
    // disabled coco begin validated: This is a fake data generator for CANBus missing/swapped frames Testing
    // will never be executed on the product
    // has been tested manually
    QByteArray data;
    if (vFakeDataLen == 1 && gFakeData == QByteArray::fromHex(gFakeData_default)) {
        static quint32 txCount = 0;
        Types::U32 seq;
        quint8 dataBytesLeft = 0;
        const quint8 crcBytesLen   = 2;
        for (int i = 0; i < 13; i++) {
            switch (i) {
            case 0: // First frame : HEAD
                seq.value = txCount;
                data += seq.bytes[0];
                data += seq.bytes[1];
                //data += seq.bytes[3]; // Chopped off
                //data += seq.bytes[4]; // Chopped off
                break;

            case 12: // Last frame with CRC
                seq.value = txCount;
                data += seq.bytes[0];
                data += seq.bytes[1];
                data += seq.bytes[2];
                data += seq.bytes[3];
                dataBytesLeft = 8 - sizeof(seq) - crcBytesLen;
                for (int j = 0; j < dataBytesLeft; j++) {
                    data += (char)(0);
                }
                break;

            default: // Middle Frames
                dataBytesLeft = 8 - sizeof(seq);
                seq.value = txCount;
                data += seq.bytes[0];
                data += seq.bytes[1];
                data += seq.bytes[2];
                data += seq.bytes[3];
                for (int j = 0; j < dataBytesLeft; j++) {
                    data += (char)(0);
                }
                break;
            }
            Types::safeIncrement(txCount);
        }
        vData += QByteArray::fromHex(data.toHex());
    }
    else {
        vData += gFakeData;
    }
}
// disabled coco end

/*!
 * \brief   ApplicationController::initSettings
 * \details The external method available to request for initializing the settings
 *          To start the task in Application Tread, emits a signal which will call a slot to take care of the execution.
 */
void ApplicationController::initSettings()
{
    QFuture<int> mFuture = QtConcurrent::run( [=]() -> int { // made the call a lambda to make sure there is no function to accidentally being called, out of thread [developer safety].
        //TODO  The Settings shall be the Singleton SettingsController and modify the MSettings like the others.
        return Storage::Settings::readConfigurations();
    });
    _settingsWatcher.setFuture(mFuture);
}

/*!
 * \brief   ApplicationController::onPOSTDone
 * \details Sends the POST Final message
 */
void ApplicationController::onPOSTDone(bool /*vPass*/) {
    LOG_DEBUG("ApplicationPOST Done");
    qDebug() << "POST DONE";
    /// in manufacturing or update mode the configurations must reside in /root/home
    /// therefore the settings can be initialized after POST.
    initSettings();
}

/*!
 * \brief   ApplicationController::onstartPOST
 * \details The POST entry point
 *           - Sends the first async check-in to the HD to let HD know it can start it's POST and UI is ready to communicate.
 *           - Connects to the POST process to be able to trigger an alarm during the POST to be listed in the active alarms list.
 *           - Connects to the POST process to be able to send the final UI POST result.
 *           - Starts the UI POST
 * \return  void
 */
void ApplicationController::onstartPOST() {
    LOG_DEBUG("ApplicationPost Start");
    _post.start();
}

/*!
 * \brief   onSettingsUpdate
 * \details when the Settings reads the .conf files and fills the MSettings emits this finished signal
 *          then this slot is called to notify the GuiController about the settings that being ready.
 */
void ApplicationController::onSettingsUpdate()
{
    _settingsError = _settingsWatcher.result();
    emit didSettingsDone(); // MessageDispatcher -> MessageInterpreter   : updateUnhandledMessag
}

/*!
 * \brief   ApplicationController::onLogIOFail
 * \details This slot is when an SD I/O failure is indicated
 */
void ApplicationController::onLogIOFail()
{
    //DEBUG qDebug()<<"SENDING " << Gui::GuiAlarmID::ALARM_ID_HD_UI_SDCARD_FAILURE;
}


void ApplicationController::onQuitApplication()
{
    //DEBUG qDebug() << metaObject()->className() << __FUNCTION__ << QThread::currentThread();
    emit didQuitApplication();
    qApp->quit();
}