/*!
 *
 * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
 * \copyright                                                       \n
 *          THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM,  \n
 *          IN PART OR IN WHOLE,                                    \n
 *          WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. \n
 *
 * \file    applicationcontroller.cpp
 * \date    2019/09/30
 * \author  Behrouz NematiPour
 *
 */
#include "applicationcontroller.h"

// Qt

// Project
#include "guiglobals.h"
#include "maintimer.h"
#include "guicontroller.h"
#include "messagedispatcher.h"
#include "logger.h"
#include "usbwatcher.h"
#include "filehandler.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)
{
    _applicationPost = new ApplicationPost(this);
}

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

    initConnections();
    if (!_applicationPost->init()) return false;

    LOG_EVENT(QObject::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();
}
// 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(&_GuiController , SIGNAL(didUSBDriveUmount()),
            this            ,   SLOT( onUSBDriveUmount()));
    connect(&_USBWatcher    , SIGNAL(didUSBDriveMount ()),
            this            ,   SLOT( onUSBDriveMount ()));
    connect(&_USBWatcher    , SIGNAL(didUSBDriveRemove()),
            this            ,   SLOT( onUSBDriveRemove()));

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

    connect(&_Logger        , SIGNAL(didExport()),
            this            ,   SLOT( onExport()));
}

/*!
 * \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());
}
// coco end

/*!
 * \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
 * \param vData
 */
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 _USBWatcher didUSBDriveMount signal
 *          and notifies the other classes (GuiController) by emitting its signal didUSBDriveMount
 */
void ApplicationController::onUSBDriveMount ()
{
    emit didUSBDriveMount();
}

/*!
 * \brief   ApplicationController::onUSBDriveRemove
 * \details This is the slot which connects to the _GuiController didUSBDriveUmount signal
 *          and notifies the other classes (USBWatcher) by emitting its signal didUSBDriveUmount
 */
void ApplicationController::onUSBDriveUmount()
{
    emit didUSBDriveUmount();
}

/*!
 * \brief   ApplicationController::onUSBDriveRemove
 * \details This is the slot which connects to the _USBWatcher didUSBDriveRemove signal
 *          and notifies the other classes (GuiController) by emitting its signal didUSBDriveRemove
 */
void ApplicationController::onUSBDriveRemove()
{
    emit didUSBDriveRemove();
}

/*!
 * \brief   ApplicationController::onExportLog
 * \details the slot which will be called by UI to so the log export.
 */
void ApplicationController::onExportLog()
{
    LOG_EXPORT;
}

/*!
 * \brief   ApplicationController::onExport
 * \details the slot which will be called by logger is done exporting.
 */
void ApplicationController::onExport()
{
    emit didExport();
}

/*!
 * \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;
    mData += static_cast<quint8>(GuiActionData::NoData);
    onActionTransmit(GuiActionType::KeepAlive, mData);
#endif
}