/*!
 *
 * Copyright (c) 2019-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    main.cpp
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      01-Aug-2024
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  24-Sep-2019
 *
 */

/*!
 * \mainpage UI Software Design Description
 * \details  Detailed Description.\n
 * This document has been generated by Doxygen.\n
 * This document describes the detail description of the UI Application Software design.\n
 * UI Application starts by Application Initialization which happens in \ref main() "Application Initialization".\n
 * For information please see :
 *  - \ref     main()
 *  - \subpage CommandLineSwitches
 *  - \subpage DenaliMessageStructure
 *  - \subpage MessageFlow
 *  - \subpage GeneralModelsDescription
 *  - \subpage MessageView
 */

// Qt
#include <QDebug>
#include <QString>
#include <QApplication>
#include <QFont>
#include <QCommandLineParser>
#include <QDateTime>

// FW
#include "Compatible.h"

// Project
#include "FileHandler.h"
#include "MainTimer.h"
#include "CanInterface.h"
#include "FrameInterface.h"
#include "MessageAcknowModel.h"
#include "MessageDispatcher.h"
#include "ApplicationController.h"
#include "GuiController.h"
#include "Logger.h"
#include "DeviceController.h"
#include "BluetoothInterface.h"
#include "CloudSyncController.h"
//AMIR
#include "Settings.h"

#include "Threads.h"

// kernel
#include <signal.h>


/*!
 * \brief   signalhandler
 * \details When application terminates it quits gracefully.
 * \param   sig - The Linux signal causes the termination.
 */
void signalhandler(int sig)
{
    if (sig == SIGINT)
    {
        qDebug() << QObject::tr("Application terminated by SIGINT");
        qApp->quit();
    }
    else if (sig == SIGTERM)
    {
        qDebug() << QObject::tr("Application terminated by SIGTERM");
        qApp->quit();
    }
}

int         gFakeInterval               = 0     ;
QByteArray  gFakeData                   = ""    ;
const char *gFakeData_default           = "00"  ;
bool        gSendEmptyKeepAwake         = false ;
bool        gFakeSeqAtBegin             = false ;
bool        gDisableUnhandledReport     = false ;
bool        gDisableDialinUnhandled     = false ;
bool        gDisableTimeout             = false ;
bool        gDisableAlarmNoMinimize     = false ;
bool        gDisableSDCFailLogStop      = false ;
bool        gDisableCloudSyncFailStop   = false ;

bool        gDisableCheckInLog          = false ;
bool        gDisableAcknowLog           = false ;

bool        gConsoleoutLogs             = false ;
bool        gConsoleoutFrameInterface   = false ;
bool        gConsoleoutCanInterface     = false ;

bool        gEnableDryDemo              = false ;
QString     gActiveCANBus               = "can0";

bool        gEnableManufacturing        = false ;
bool        gEnableUpdating             = false ;
bool        gUseRootHome                = false ;

bool        gLogLongName                = false ;
bool        gLogUpload                  = false ;
bool        gLogCompress                = false ;
bool        gLogUnhandledOnly           = false ;

QString     gParserErrorText            = "";
QString     gStandard_tmp               = QString("/%1/").arg("tmp");



/*!
 * \page    CommandLineSwitches Denali Command Line Switches
 * \verbatim
 * Usage: ./denali [options]
 * Denali
 *
 * Options:
 *   -h, --help                           Displays help on commandline options.
 *   --help-all                           Displays help including Qt specific
 *                                        options.
 *   -v, --version                        Displays version information.
 *   -c, --canOut                         Show the Can Frame Output
 *   -m, --msgOut                         Show the Message Output
 *   -l, --logOut                         Show the Logs Output
 *   -0, --enable-keep-awake              Enable send low priority, empty message
 *                                        on the CANBus just to keep UI board CAN
 *                                        driver awake
 *   -i, --fake-interval <interval>       Test fake message interval(ms)
 *   -f, --fake-message <data>            Test fake message data
 *                                        will use default sequenced long fake
 *                                        message if set to 00(default)
 *                                        will used only if correct integer value
 *                                        assigned for interval option
 *   -b, --fake-message-seq-at-begin      Test fake message sequence at the
 *                                        beginning of the frame
 *   -u, --disable-unhandled-report       Disable unhandled messages report as an
 *                                        error in the log
 *   -d, --disable-dialin-unhandled       Disable the Dialin messages logged as
 *                                        unhandled
 *   -q, --disable-timeout                Disables communication timeout
 *   -a, --disable-alarm-no-minimize      Disables alarm no minimize
 *   -S, --disable-sd-card-fail-log-stop  disable-sd-card-fail-log-stop
 *   -C, --disable-cloudsync-fail-stop    disable-cloudsync-fail-stop
 *   -k, --disable-check-in-log           Disables Check-In Log
 *   -K, --disable-acknow-log             Disables Acknowledgment Log
 *   -D, --enable-dry-demo                Enables Dry-Demo Mode
 *   -A, --active-can-bus <CANBus>        Sets the Active CANBus [Shall start with
 *                                        'can' or 'vcan]
 *   -E, --enable-manufacturing           Enables the manufacturing mode to
 *                                        configure the system for the first time.
 *   -R, --use-root-home                  In case the application is not in
 *                                        Manufacturing Setup but needs to use root
 *                                        home folder for configurations.
 *   -U, --enable-update-mode             Enables the update mode to update only
 *                                        necessary files during the update and
 *                                        keep the rest.
 *   -x, --use-log-long-name              Use the log long file name format
 *                                        <date>_<time>_<serial>_<mode>
 *   -y, --use-log-cloud-upload           Use the log cloud upload
 *   -z, --use-log-compression            Use the log compression
 *   -L, --use-log-unhandled-only         Use the unhandled messages only to log
 *
 * \endverbatim
 */
/*!
 *  \brief   commandlineParse
 *  \details parses the command line arguments
 *  \ref     CommandLineSwitches
 */
void commandlineParse() {
    QCommandLineParser parser;
    parser.setApplicationDescription(QApplication::applicationName());
    parser.addHelpOption();
    parser.addVersionOption();

    // --- -c : canOut
    QCommandLineOption optionConsoleoutCanInterface(
                QStringList() << "c" << "canOut",
                QCoreApplication::translate("main", "Show the Can Frame Output"));
    parser.addOption(optionConsoleoutCanInterface);

    // --- -m : msgOut
    QCommandLineOption optionConsoleoutFrameInterface(
                QStringList() << "m" << "msgOut",
                QCoreApplication::translate("main", "Show the Message Output"));
    parser.addOption(optionConsoleoutFrameInterface);

    // --- -l : logOut
    QCommandLineOption optionConsoleoutLogs(
                QStringList() << "l" << "logOut",
                QCoreApplication::translate("main", "Show the Logs Output"));
    parser.addOption(optionConsoleoutLogs);

    // --- -0 : enable-keep-awake (the fast mode)
    QCommandLineOption optionSendEmptyKeepAwake(QStringList() << "0" << "enable-keep-awake",
                                                QCoreApplication::translate("main", "Enable send low priority, empty message on the CANBus just to keep UI board CAN driver awake"));
    parser.addOption(optionSendEmptyKeepAwake);

    // --- -i : fake-interval
    QCommandLineOption optionFakeInterval(
                QStringList() << "i" << "fake-interval",
                QCoreApplication::translate("main", "Test fake message interval(ms)"),
                QCoreApplication::translate("main", "interval"));
    parser.addOption(optionFakeInterval);

    // --- -f : fake-message
    QCommandLineOption optionFakeData(
                QStringList() << "f" << "fake-message",
                QCoreApplication::translate("main", "Test fake message data\n"
                                                    "will use default sequenced long fake message if set to 00(default)\n"
                                                    "will used only if correct integer value assigned for interval option"),
                QCoreApplication::translate("main", "data"));
    parser.addOption(optionFakeData);

    // --- -b : fake-message-seq-at-begin
    QCommandLineOption optionFakeSeqAtBegin(
                QStringList() << "b" << "fake-message-seq-at-begin",
                QCoreApplication::translate("main", "Test fake message sequence at the beginning of the frame"));
    parser.addOption(optionFakeSeqAtBegin);

    // --- -u : disable-unhandled-report
    QCommandLineOption optionDisableUnhandledReport(
                QStringList() << "u" << "disable-unhandled-report",
                QCoreApplication::translate("main", "Disable unhandled messages report as an error in the log"));
    parser.addOption(optionDisableUnhandledReport);

    // --- -d : disable-dialin-unhandled
    QCommandLineOption optionDisableDialinUnhandled(
                QStringList() << "d" << "disable-dialin-unhandled",
                QCoreApplication::translate("main", "Disable the Dialin messages logged as unhandled"));
    parser.addOption(optionDisableDialinUnhandled);

    // --- -q : disable-timeout
    QCommandLineOption optionDisableTimeout(
                QStringList() << "q" << "disable-timeout",
                QCoreApplication::translate("main", "Disables communication timeout"));
    parser.addOption(optionDisableTimeout);

    // --- -a : disable-alarm-no-minimize
    QCommandLineOption optionDisableAlarmMoMinimize(
                QStringList() << "a" << "disable-alarm-no-minimize",
                QCoreApplication::translate("main", "Disables alarm no minimize"));
    parser.addOption(optionDisableAlarmMoMinimize);

    // --- -S : disable-sd-card-fail-log-stop
    QCommandLineOption optionDisableSDCardFailLogStop(
                QStringList() << "S" << "disable-sd-card-fail-log-stop",
                QCoreApplication::translate("main", "disable-sd-card-fail-log-stop"));
    parser.addOption(optionDisableSDCardFailLogStop);

    // --- -C : disable-cloudsync-fail-stop
    QCommandLineOption optionDisableCloudSyncFailStop(
                QStringList() << "C" << "disable-cloudsync-fail-stop",
                QCoreApplication::translate("main", "disable-cloudsync-fail-stop"));
    parser.addOption(optionDisableCloudSyncFailStop);

    // --- -k : disable-Check-in-log (keep-alive)
    QCommandLineOption optionDisableCheckInLog(
                QStringList() << "k" << "disable-check-in-log",
                QCoreApplication::translate("main", "Disables Check-In Log"));
    parser.addOption(optionDisableCheckInLog);

    // --- -K : disable-acknow-log (Acknowledge)
    QCommandLineOption optionDisableAcknowLog(
                QStringList() << "K" << "disable-acknow-log",
                QCoreApplication::translate("main", "Disables Acknowledgment Log"));
    parser.addOption(optionDisableAcknowLog);

    // --- -D : enable-dry-demo
    QCommandLineOption optionEnableDryDemo(
                QStringList() << "D" << "enable-dry-demo",
                QCoreApplication::translate("main", "Enables Dry-Demo Mode"));
    parser.addOption(optionEnableDryDemo);

    // --- -A : active-can-bus
    QCommandLineOption optionActiveCANBus(
                QStringList() << "A" << "active-can-bus",
                QCoreApplication::translate("main", "Sets the Active CANBus [Shall start with 'can' or 'vcan]"),
                QCoreApplication::translate("main", "CANBus"));
    parser.addOption(optionActiveCANBus);

    // --- -E : enable-manufacturing
    QCommandLineOption optionEnableManufacturing(
        QStringList() << "E" << "enable-manufacturing",
        QCoreApplication::translate("main", "Enables the manufacturing mode to configure the system for the first time."));
    parser.addOption(optionEnableManufacturing);

    // --- -R : use-root-home
    QCommandLineOption optionUseRootHome(
        QStringList() << "R" << "use-root-home",
        QCoreApplication::translate("main", "In case the application is not in Manufacturing Setup but needs to use root home folder for configurations."));
    parser.addOption(optionUseRootHome);

    // --- -U : Update mode
    QCommandLineOption optionEnableUpdating(
        QStringList() << "U" << "enable-update-mode",
        QCoreApplication::translate("main", "Enables the update mode to update only necessary files during the update and keep the rest."));
    parser.addOption(optionEnableUpdating);

    // --- -x : use-log-long-name
    QCommandLineOption optionLogLongName(
                QStringList() << "x" << "use-log-long-name",
                QCoreApplication::translate("main", "Use the log long file name format\n<date>_<time>_<serial>_<mode>"));
    parser.addOption(optionLogLongName);

    // --- -y : use-log-cloud-upload
    QCommandLineOption optionLogUpload(
                QStringList() << "y" << "use-log-cloud-upload",
                QCoreApplication::translate("main", "Use the log cloud upload"));
    parser.addOption(optionLogUpload);

    // --- -z : use-log-compression
    QCommandLineOption optionLogCompress(
                QStringList() << "z" << "use-log-compression",
                QCoreApplication::translate("main", "Use the log compression"));
    parser.addOption(optionLogCompress);

    // --- -L : use-log-unhandled-only
    QCommandLineOption optionLogUnhandledOnly(
        QStringList() << "L" << "use-log-unhandled-only",
        QCoreApplication::translate("main", "Use the unhandled messages only to log"));
    parser.addOption(optionLogUnhandledOnly);

    // --- parse command lines
    if ( ! parser.parse(qApp->arguments()) ) {
        gParserErrorText = parser.errorText();
        qDebug().noquote().nospace()
                << "------------------------------" << "\n"
                << gParserErrorText                 << "\n"
                << "Command Line Parser failed !!!" << "\n"
                << qApp->arguments().join(" ")      << "\n"
                << "------------------------------" ;
        return;
    }
    parser.process(*qApp);

    gConsoleoutCanInterface     = parser.isSet(optionConsoleoutCanInterface     );
    gConsoleoutFrameInterface   = parser.isSet(optionConsoleoutFrameInterface   );
    gConsoleoutLogs             = parser.isSet(optionConsoleoutLogs             );
    gDisableUnhandledReport     = parser.isSet(optionDisableUnhandledReport     );
    gDisableDialinUnhandled     = parser.isSet(optionDisableDialinUnhandled     );
    gDisableTimeout             = parser.isSet(optionDisableTimeout             );
    gDisableAlarmNoMinimize     = parser.isSet(optionDisableAlarmMoMinimize     );
    gDisableSDCFailLogStop      = parser.isSet(optionDisableSDCardFailLogStop   );
    gDisableCloudSyncFailStop   = parser.isSet(optionDisableCloudSyncFailStop   );

    gDisableCheckInLog          = parser.isSet(optionDisableCheckInLog          );
    gDisableAcknowLog           = parser.isSet(optionDisableAcknowLog           );

    gEnableDryDemo              = parser.isSet(optionEnableDryDemo              );

    gEnableManufacturing        = parser.isSet(optionEnableManufacturing        );
    gEnableUpdating             = parser.isSet(optionEnableUpdating             );
    gUseRootHome                = parser.isSet(optionUseRootHome                );

    gLogLongName                = parser.isSet(optionLogLongName                );
    gLogUpload                  = parser.isSet(optionLogUpload                  );
    gLogCompress                = parser.isSet(optionLogCompress                );
    gLogUnhandledOnly           = parser.isSet(optionLogUnhandledOnly           );

    //DEBUG:
    qDebug() << "\n"
             << "---------- x:" << gLogLongName << "\n"
             << "---------- y:" << gLogUpload   << "\n"
             << "---------- z:" << gLogCompress << "\n";

    if ( gLogUnhandledOnly ) {
        qDebug() << "\n"
                 << "**********************************************************"  << "\n"
                 << "********** SYSTEM IS IN UNHANDLED LOG ONLY MODE **********"  << "\n"
                 << "**********************************************************"  << "\n";
    }

    if (                          parser.isSet(optionActiveCANBus               ) ) {
        QString value = parser.value(optionActiveCANBus);
        if ( ! value.startsWith("-") &&                                     //  if a value is not given for the switch then the next switch becomes the value of the previous one
             ( value.startsWith("can") || value.startsWith("vcan") ) ) {    // to be more precise
            gActiveCANBus = value;
        }
    }

    if (parser.isSet(optionSendEmptyKeepAwake)) gSendEmptyKeepAwake = true;
    bool ok = false;

    if (parser.isSet(optionFakeInterval)) {
        int interval = parser.value(optionFakeInterval).toInt(&ok);
        if (ok) {
            gFakeInterval = interval;
            if (parser.isSet(optionFakeData)) {
                gFakeData = parser.value(optionFakeData).toLatin1();
            } else {
                gFakeData = gFakeData_default;
            }
            if (parser.isSet(optionFakeSeqAtBegin)) {
                gFakeSeqAtBegin = true;
            }
            gFakeData = QByteArray::fromHex(gFakeData);
        }
    }
}

/*!
 * \brief   setApplicationVersion
 * \details sets up the application version regarding the environment variables
 *          which are set by bamboo and if those are not set value of 0 will be used
 *          and revision(build) version will be set to current date/time.
 */
void setApplicationVersion() {
    const char sepRels   = '-';
    const char sepVers   = '.';
    const char sepComp   = '-';


    bool    isOnServer  = true;
    QString ver_major   = QString("%1").arg(VER_MAJOR               );
    QString ver_minor   = QString("%1").arg(VER_MINOR               );
    QString ver_micro   = QString("%1").arg(VER_MICRO               );
    QString ver_revis   = QString("%1").arg(VER_REVIS               );
    QString ver_branch  = QString("%1").arg(VER_BRANCH              );
    QString ver_comp    = QString("%1").arg(SW_COMPATIBILITY_REV    );
    QString ver_branchx = "";

    if (ver_revis.isEmpty())  {
        ver_revis = VER_REVIS_DEV;
        isOnServer  = false;
    }

    //DEBUG: On Server
    // isOnServer = true;
    // ver_branch = "release/p1";
    // ver_branch = "release/p1_staging";
    // ver_branch = "release/p1_develop";
    // ver_branch = "release/p1b/master";
    // ver_branch = "release/p1/staging";
    // ver_branch = "release/p1/develop";
    // ver_branch = "master";
    // ver_branch = "staging";
    // ver_branch = "develop";

    bool isRelease  = ver_branch.startsWith("release/");
    bool isOnMaster = ver_branch == "master";
    bool isNotStory = isRelease                 ||
                      isOnMaster                ||
                      ver_branch == "staging"   ||
                      ver_branch == "develop"   ;
    if (isNotStory) {
        if (isOnServer) {
            if (isOnMaster ) {
                ver_branch = ""; // if only is built on server master branch do not show branch
            }
            if ( isRelease ) {
                ver_branch = ver_branch.remove(0,QString("release/").length());
                QStringList ver_branch_sections = ver_branch.split("/");
                if ( ver_branch_sections.count() >= 2 ) {
                    ver_branch  = ver_branch_sections[0].toUpper();
                    ver_branchx = ver_branch_sections[1];
                    if ( ver_branchx == "master" ) {
                        ver_branchx = "";
                    } else {
                        ver_branchx = "-" + ver_branchx;
                    }
                }
            }
            ver_major   += sepVers;
            ver_minor   += sepVers;
            ver_micro   += sepVers;
        }
    }

    if ( ! ver_branch.isEmpty()) ver_branch += sepRels;
    ver_comp = sepComp + ver_comp;

    QString version = "";
    version += ver_branch   ;
    version += ver_major    ;
    version += ver_minor    ;
    version += ver_micro    ;
    version += ver_revis    ; // build number
    version += ver_comp     ;
    version += ver_branchx  ;
    QCoreApplication::setApplicationVersion(version);
}

/*!
 * \brief   lockdown
 * \details runs the lockdown shell script as a detached process
 *          and meant to be executed just before the application quits
 *          and only when application running in manufacturing or update mode.
 *          Must not stop application shutdown in any way.
 *          If any error happens it only logs.
 */
void lockdown() {
    // there are two setup scenarios:
    // only during setup mode which is -E (manufacturing setup) or -U -E (update setup) application is running under the root user permissions
    // and all the files are copied to the /home/root/ to later be copied to secured locations
    // and that will be done by lockdown.sh script running within application after the user is done with the setup and QUIT s the application.
    if ( gEnableManufacturing || gEnableUpdating ) {
        QString scriptName = Storage::Scripts_Device_Lockdown;
        quint16 errorCode;
        QString errorText;
        errorCode = Device::DeviceError::checkScript    (scriptName, Storage::Scripts_Device_Lockdown   );
        errorText = Device::DeviceError::deviceErrorText( static_cast<Device::DeviceError::Scripts_Error_Enum>(errorCode), 1);
        qDebug() << errorText;  // since we are in the manufacturing mode it is possible to probably take a look at the serial, if not that is being logged.
#ifdef BUILD_FOR_TARGET
        Storage::FileHandler::write("/home/root/lockdown.log"   , errorText, false);
#else
        Storage::FileHandler::write("/home/denali/lockdown.log" , errorText, false);
#endif
        if ( ! errorCode ) {
            QProcess::startDetached( scriptName, { qApp->applicationName() + ":" + QString::number(qApp->applicationPid()) });
        }
    }
}

#ifdef UNIT_TEST
#include TEST_CLASS_INCLUDE
QTEST_MAIN(TEST_CLASS_NAME)
#else
/*!
 * \brief   Application Initialization
 * \details Some part of the application need to be initialized out of any thread.
 *          So is initialized here to be initialized in the main thread.
 *          this section also includes:
 */
int main(int argc, char *argv[])
{
#ifndef SQUISH_COCO_BULD
    signal(SIGINT , signalhandler);
    signal(SIGTERM, signalhandler);
#endif

    // setting the environment for the keyboard.
    qputenv("QT_IM_MODULE"                  , QByteArray("qtvirtualkeyboard"                            ));
    qputenv("QT_VIRTUALKEYBOARD_STYLE"      , QByteArray("denali"                                       ));
    qputenv("QT_VIRTUALKEYBOARD_LAYOUT_PATH", QByteArray(":/plugins/QtQuick/VirtualKeyboard/Layouts"    ));

    //! - Qt Application initialization and parameters settings
    // Qt Core Application parameters settings
    QApplication::setApplicationName(QLatin1String("Leahi"));
    QApplication::setOrganizationName(QLatin1String("Diality Inc."));

    //! - Check the required font(s) present and can be loaded
    QApplication::setFont(QFont("Barlow"));

    // Qt Core Application Initialization
    QApplication app(argc, argv);
    app.thread()->setObjectName("Main Thread");

    //! - Setting the application version regarding the Bamboo build number.
    setApplicationVersion();

    //! - Parse the command line arguments
    commandlineParse();

    // SYSTEM TEST FOR INSTRUCTIONS WHEN THERE IS NO PORT AVAILABLE
    // Storage::FileHandler::copyFolder(QString(Storage::USB_Mount_Point) + "Instructions", QString(Storage::Settings_Path()));


    //! - Initializing required thread types
    Threads::registerTypes();

    //! - Initializing Logger
    if(_Logger.init(Threads::_Logger_Thread)) {
        _Logger.enableConsoleOut(gConsoleoutLogs);
    }
    _Logger.postInit();

    // 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;
    QTranslator translator;
    { // on-shot use of settings to load the translation only
        // Storage::Settings settings;
        //! - Reading localization
        if ( ! Storage::Settings::readLocale() ) {
            //! - Translation initialization
            Storage::Settings::loadTranslation(translator);
        }
    }

    //! - Starting the application interface
    bool guiStarted = startGui();

    if (gFakeInterval) {
        QString msg = "  ~~ !!!!! APPLICATION RUNNING IN THE TEST MODE !!!!! ~~ ";
        qDebug() <<  msg;
        LOG_APPED(" \n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ "
                  " \n " +                       msg                          +
                  " \n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ");
    }

    if ( ! gParserErrorText.isEmpty() ) {
        LOG_DEBUG(QString("Command-line arguments process failed:") + gParserErrorText);
    }

    //! - Initializing the Device Controller
    _DeviceController.init(Threads::_DeviceController_Thread);

    //! - Initializing the CANBus Interface
    if (_CanInterface.init(Threads::_CanFrame_Thread)) {
        _CanInterface.enableConsoleOut(gConsoleoutCanInterface);
    }

    //! - Initializing the CANBus Message Handler
    _FrameInterface.init(Threads::_CanFrame_Thread);

    //! - Initializing the CANBus Message Acknowledgment Model
    _MessageAcknowModel.init(Threads::_CanAcknow_Thread);

    //! - Initializing the CANBus Message Dispatcher
    if (_MessageDispatcher.init(Threads::_CanMessage_Thread)) {
        _MessageDispatcher.enableConsoleOut(gConsoleoutFrameInterface);
    }

    //! - Initializing Application Controller
    _ApplicationController.init(Threads::_Application_Thread);

    ////! - Initializing GUI Controller
    _GuiController.init(Threads::_Gui_Thread);

    //! - Initializing Main Timer
    _MainTimer.init();

    //! - Initializing Bluetooth Interface
    _BluetoothInterface.init(Threads::_Bluetooth_Thread);

    //! - Initializing the CloudSync controller
    _CloudSyncController.init(Threads::_CloudSync_Thread);

    //! - Initialize the QML Viewer and starts GUI
    int app_exec = -1;
    LOG_DEBUG("UI Initializing");
    if ( guiStarted /*startGui()*/ ) {
        LOG_DEBUG("UI Initialized");
        _ApplicationController  .startPOST();
        app_exec = app.exec();
    }

    // Due to Qt Error the CAN Device cannot be disable/enable from withing another thread
    // (other than main thread which is the owner of the CanDevice).
    // So it needs to be done here in main thread.
    _CanInterface.quitDevice();

    Threads::quitThreads();

    Gui::_viewer->deleteLater();

#ifdef BUILD_FOR_TARGET
    lockdown();
#endif

    return app_exec;
}
#endif