/*!
 *
 * 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    ApplicationController.cpp
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      29-Mar-2021
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  29-Mar-2021
 *
 */
#include "ApplicationController.h"

// Qt
#include <QtConcurrent/QtConcurrent>

// Project
#include "ApplicationPost.h"
#include "MainTimer.h"
#include "MessageDispatcher.h"
#include "Logger.h"
#include "DeviceController.h"
#include "FileHandler.h"
#include "GuiController.h"
#include "Settings.h"
#include "MSettings.h"


/*!
 * \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) { }

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

    initConnections();
    LOG_DEBUG("UI," + tr("%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()
{
    // coco begin validated: Application termination is not correctly done in coco!!!
    // it has been tested and works perfectly fine in normal run.
    quitThread(); // validated
}
// 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 GUI
    connect(&_GuiController , SIGNAL(didActionTransmit(GuiActionType, const QVariantList &)),
            this            ,   SLOT( onActionTransmit(GuiActionType, const QVariantList &)));

    // From HD/DG
    connect(&_MessageDispatcher, SIGNAL(didActionReceive(GuiActionType, const QVariantList &)),
            this               ,   SLOT( onActionReceive(GuiActionType, const QVariantList &)));

    connect(&_MessageDispatcher, SIGNAL(didFailedTransmit(Sequence)),
            this               ,   SLOT( onFailedTransmit(Sequence)));

    // USB drive
    connect(&_GuiController , SIGNAL(didUSBDriveUmount()),
            this            ,   SLOT( onUSBDriveUmount()));
    connect(&_DeviceController  , SIGNAL(didUSBDriveMount ()),
            this                ,   SLOT( onUSBDriveMount ()));
    connect(&_DeviceController  , SIGNAL(didUSBDriveRemove()),
            this                ,   SLOT( onUSBDriveRemove()));

    // SD Card
    connect(&_DeviceController  , SIGNAL(didSDCardStateChange(bool, bool)),
            this                ,   SLOT( onSDCardStateChange(bool, bool)));
    connect(&_DeviceController  , SIGNAL(didSDCardSpaceTooLow(quint8)),
            this                ,   SLOT( onSDCardSpaceTooLow(quint8)));

    connect(&_GuiController , SIGNAL(didExportLog()),
            this            ,   SLOT( onExportLog()));

    connect(&_Logger        , SIGNAL(didExportLogs()),
            this            ,   SLOT( onExport    ()));

    // Settings - move to application thread
    connect(this, SIGNAL(didSettingsInit()),
            this,   SLOT( onSettingsInit()));
    connect(&_settingsWatcher, SIGNAL(finished        ()),
            this             ,   SLOT(onSettingsUpdate()));


    // Device Signal/Slots
    DEVICE_APP_INIT_CONNECTIONS_LIST

    // ---- Signal/Slots
    ADJUST_TRANSMT_MODEL_BRIDGE_CONNECTIONS(_GuiController    )
    ACTION_RECEIVE_MODEL_BRIDGE_CONNECTIONS(_MessageDispatcher)
}

/*!
 * \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 QApplicaiton
 *          And to be destroyed there.
 */
void ApplicationController::quitThread()
{
    // 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
}
// 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(GuiActionType vAction, const QVariantList &vData)
{
    emit didActionTransmit(vAction, 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 (GuiActionType vAction, const QVariantList &vData)
{
    emit didActionReceive (vAction, 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::onUSBDriveMount
 * \details This is the slot which connects to the _DeviceController didUSBDriveMount signal
 *          and notifies the other classes (GuiController) by emitting its signal didUSBDriveMount
 */
void ApplicationController::onUSBDriveMount ()
{
    // coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    emit didUSBDriveMount();
}
// coco end

/*!
 * \brief   ApplicationController::onUSBDriveRemove
 * \details This is the slot which connects to the _GuiController didUSBDriveUmount signal
 *          and notifies the other classes (DeviceController) by emitting its signal didUSBDriveUmount
 */
void ApplicationController::onUSBDriveUmount()
{
    // coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    emit didUSBDriveUmount();
}
// coco end

/*!
 * \brief   ApplicationController::onUSBDriveRemove
 * \details This is the slot which connects to the _DeviceController didUSBDriveRemove signal
 *          and notifies the other classes (GuiController) by emitting its signal didUSBDriveRemove
 */
void ApplicationController::onUSBDriveRemove()
{
    // coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    emit didUSBDriveRemove();
}
// coco end

/*!
 * \brief   ApplicationController::onSDCardStateChange
 * \details This is the slot which connects to the _DeviceController didSDCardStateChange signal
 *          and notifies the other classes (GuiController) by emitting its signal didSDCardStateChange
 * \param   vIsReady    - SDCard is Ready
 * \param   vIsReadOnly - SDCard is ReadOnly
 */
void ApplicationController::onSDCardStateChange(bool vIsReady, bool vIsReadOnly)
{
    // coco begin validated: This needs user interaction to plug-in SD Card
    // has been tested manually
    /// DEBUG: qDebug() << " ***** ApplicationController " << Storage::SDCard_Base_Path_Name << vIsReady;
    emit didSDCardStateChange(vIsReady, vIsReadOnly);
}
// coco end

/*!
 * \brief   ApplicationController::onSDCardSpaceTooLow
 * \details The handler slot for the didSDCardSpaceTooLow signal comes form DeviceController
 * \param   vAvailablePercent - the minimum limit of available storage space
 */
void ApplicationController::onSDCardSpaceTooLow(quint8 vAvailablePercent)
{
    // coco begin validated: This needs user interaction to plug-in SD Card
    // has been tested manually
    emit didSDCardSpaceTooLow(vAvailablePercent);
}
// coco end

/*!
 * \brief   ApplicationController::onExportLog
 * \details the slot which will be called by UI to so the log export.
 */
void ApplicationController::onExportLog()
{
    // coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    LOG_EXPORT;
}
// coco end

/*!
 * \brief   ApplicationController::onExport
 * \details the slot which will be called by logger is done exporting.
 */
void ApplicationController::onExport()
{
    // coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    emit didExport();
}
// 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()
{
#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);
        }
    }
    // coco end
    else {
        mData += static_cast<quint8>(GuiActionData::NoData);
    }
    onActionTransmit(GuiActionType::ID_KeepAlive, 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)
{
    // 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;
    }
}
// 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)
{
    // 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;
    }
}
// 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()
{
    // this emit guaranties that the slot will be called in the application thread
    // also the signal is private so it will be used internally only.
    emit didSettingsInit({});
}

/*!
 * \brief   ApplicationController::onSettingsInit
 * \details The slot which will be called to start the settings initialization in Application thread.
 *          This method also initializes the Settings model singleton object to let it live in the Application thread.
 *          To start the setting initialization QConcurrent is used with QFuture to signal the Application when it's done.
 */
void ApplicationController::onSettingsInit()
{
    // That is enough to call to the I function here to create the object in the thread that Settings is leaving in,
    // which currently is Application_Thread, since the Settings is created in that thread.
    _Settings;

    QFuture<void> mFuture = QtConcurrent::run(this, &ApplicationController::settingsInit);
    _settingsWatcher.setFuture(mFuture);
}

/*!
 * \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()
{
    onActionReceive(SettingsData());
}

/*!
 * \brief   ApplicationController::settingsInit
 * \details The Settings read function is called in this method.
 *          This callback function for the QCuncurrnent run.
 */
void ApplicationController::settingsInit()
{
    Storage::Settings settings;
    settings.read();
}

/*!
 * \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() {
    emit didActionTransmit(GuiActionType::ID_KeepAlive, {});
    ApplicationPost post;
    connect(&post, &ApplicationPost::didPOSTFail, [=] (Gui::GuiAlarmID vAlarmID) {
        emit didActionTransmit(GuiActionType::ID_AlarmTriggered, { vAlarmID });
    });
    connect(&post, &ApplicationPost::didPOSTDone, [=] (bool vResult) {
        AdjustUIPostFinalResultRequestData data;
        data.mResult = vResult;
        emit didAdjustment(data);
    });
    post.start();
}