/*!
 *
 * Copyright (c) 2020-2025 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    GuiView.cpp
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      10-Jul-2024
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  26-Aug-2020
 *
 */

// Project
#include "GuiView.h"
#include "GuiController.h"
#include "DeviceController.h"
#include "FileHandler.h"

#include "qrcodegen.h"

// namespace
using namespace Gui;

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

/*!
 * \brief GuiView::initConnections
 * \details Initializes the required signal/slot connection between this class and other objects
 *          to be able to communicate.
 */
void GuiView::initConnections()
{
    connect(&_GuiController, SIGNAL(didActionReceive (GuiActionType, const QVariantList &)),
            this           ,   SLOT( onActionReceive (GuiActionType, const QVariantList &)));

    // since we do not have access to this object because it is created in QML.
    // Connection to the GuiController made here
    // It should be defined in the class which wants to connect to signal.
    connect(this           , SIGNAL(didActionTransmit(GuiActionType,const QVariantList &)),
            &_GuiController,   SLOT( doActionTransmit(GuiActionType,const QVariantList &)));
    connect(this           , SIGNAL(didQuitApplication()),
            &_GuiController,   SLOT( doQuitApplication()));

    // From UI : USB drive umount
    connect(this           , SIGNAL(didUSBDriveUmount()),
            &_GuiController,   SLOT( doUSBDriveUmount()));
    // From OS : USB drive removed
    connect(&_GuiController, SIGNAL(didUSBDriveMount ()),
            this           ,   SLOT( onUSBDriveMount ()));
    connect(&_GuiController, SIGNAL(didUSBDriveRemove()),
            this           ,   SLOT( onUSBDriveRemove()));
    connect(&_GuiController, SIGNAL(didUSBSpaceChange(bool, qint64, qint64, quint8)),
            this           ,   SLOT( onUSBSpaceChange(bool, qint64, qint64, quint8)));

    // SD Card
    connect(&_GuiController     , SIGNAL(didSDCardStateChange(bool,bool)),
            this                ,   SLOT( onSDCardStateChange(bool,bool)));
    connect(&_GuiController     , SIGNAL(didSDCardSpaceChange(bool, qint64, qint64, quint8)),
            this                ,   SLOT( onSDCardSpaceChange(bool, qint64, qint64, quint8)));
    connect(&_GuiController     , SIGNAL(didExport()),
            this                ,   SLOT( onExport()));
    connect(&_GuiController     , SIGNAL(didExportStat      (quint32, const QString &, quint8)),
            this                ,   SLOT( onExportStat      (quint32, const QString &, quint8)));

    // From UI : Export Log
    connect(this           , SIGNAL(didExportLog        (const GuiStringIndexMap &)),
            &_GuiController,   SLOT( doExportLog        (const GuiStringIndexMap &)));
    connect(this           , SIGNAL(didExportService    (const GuiStringIndexMap &)),
            &_GuiController,   SLOT( doExportService    (const GuiStringIndexMap &)));
    connect(this           , SIGNAL(didExportTreatment  (const GuiStringIndexMap &)),
            &_GuiController,   SLOT( doExportTreatment  (const GuiStringIndexMap &)));

    connect(&_GuiController, SIGNAL(didPOSTPass (bool)),
            this           ,   SLOT( onPOSTPass (bool)));
}

/*!
 * \brief   GuiView::onActionReceive
 * \details emits didActionReceive signal to notify other classes (Gui)
 *          , an action has been received.
 * \param   vAction -  the action
 * \param   vData   -  the action data
 */
void GuiView::onActionReceive (GuiActionType vAction, const QVariantList &vData)
{
    // process the evaluation and notify GUI
    emit didActionReceive (vAction, vData);
}

/*!
 * \brief   GuiView::doActionTransmit
 * \details emits didActionTransmit signal to notify other classes (GuiController)
 *          , an action has been required to be transmitted.
 * \param   vAction - the action
 * \param   vData   - the action data
 */
void GuiView::doActionTransmit(GuiActionType vAction, const QVariantList &vData)
{
    // TODO : Remove this code later when Investigated thoroughly.
    // disabled coco begin validated: This code later needs to be removed when Investigated thoroughly.
    // has been tested manually
    emit didActionTransmit(vAction, vData);
}
// disabled coco end

/*!
 * \brief   GuiView::doActionTransmit
 * \details emits didActionTransmit signal to notify other classes (GuiController)
 *          , an action has been required to be transmitted.
 * \note    The overloaded method with only one data parameter, for easier use in qml.
 * \param   vAction - the action
 * \param   vData   - the action data
 */

void GuiView::doActionTransmit(GuiActionType vAction, const QVariant &vData)
{
    // TODO : Remove this code later when Investigated thoroughly.
    // disabled coco begin validated: This code later needs to be removed when Investigated thoroughly.
    // has been tested manually
    QVariantList mData;
    mData += vData;
    emit didActionTransmit(vAction, mData);
}
// disabled coco end

/*!
 * \brief GuiView::doUSBDriveMount
 * \details emits didUSBDriveMount signal to notify other classes (UI)
 *          , the USB drive has been mounted.
 */
void GuiView::onUSBDriveMount ()
{
    // disabled coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    usbIsReady  (true );
    usbIsRemoved(false);
    emit didUSBDriveMount ();
}
// disabled coco end

/*!
 * \brief   GuiView::doUSBDriveUmount
 * \details emits didUSBDriveRemove signal to notify other classes (GuiController)
 *          , the USB drive has been removed.
 */
void GuiView::doUSBDriveUmount()
{
    // disabled coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    usbIsReady  (false);
    usbIsRemoved(false);
    exportRunning(false);
    emit didUSBDriveUmount();
}
// disabled coco end

/*!
 * \brief GuiView::doUSBDriveRemove
 * \details emits didUSBDriveRemove signal to notify other classes (UI)
 *          , the USB drive has been removed.
 */
void GuiView::onUSBDriveRemove()
{
    // disabled coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    usbIsReady  (false);
    usbIsRemoved(true );
    exportRunning(false);
    emit didUSBDriveRemove();
}
// disabled coco end

/*!
 * \brief GuiView::onSDCardStateChange
 * \details emits didSDCardStateChange signal to notify other classes (UI)
 *          , the SD Card State has been changed.
 * \param   vIsReady    - SDCard is Ready
 * \param   vIsReadOnly - SDCard is ReadOnly
 */
void GuiView::onSDCardStateChange(bool vIsReady, bool vIsReadOnly)
{
    // disabled coco begin validated: This needs user interaction to plug-in USB device
    // has been tested manually
    //DEBUG:0: qDebug() << " ***** GuiView " << Storage::SDCard_Base_Path_Name << vIsReady;
    sdIsReady   (vIsReady   );
    sdIsReadOnly(vIsReadOnly);
    if (! vIsReady || vIsReadOnly) exportRunning(false);

    //DEBUG:0: qDebug() << __FUNCTION__ << _sdIsReady << _sdIsReadOnly;
}
// disabled coco end

/*!
 * \brief   GuiController::doSDCardSpaceTooLow
 * \details The handler slot for the didSDCardSpaceTooLow signal comes form GuiController.
 * \param   vAvailablePercent - the minimum limit of available storage space
 */
void GuiView::onSDCardSpaceTooLow(quint8 vAvailablePercent)
{
    // disabled coco begin validated: This needs to fill up the SD-Card and test with human interactions.
    // has been tested manually
    sdTooLowPecent(vAvailablePercent);
}
// disabled coco end

/*!
 * \brief   GuiView::onExport
 * \details The slot which will be called to notify the export is done
 *          by emitting the didExport signal.
 */
void GuiView::onExport()
{
    doExportListRemove();
    exportRunning(false);
    emit didExport();
    //DEBUG:0: qDebug() << " ~~~~~ " << "GuiView::onExport" << _exportRunning;
}

/*!
 * \brief   GuiView::onExportStat
 * \details handler slot of the signal didExportStat, which is emitted when a state of the selected item is changed.
 * \param   vIndex      - selected item index
 * \param   vFileName   - selected item file name
 * \param   vPercent    - selected item export percentage.
 */
void GuiView::onExportStat(quint32 vIndex, const QString &vFileName, quint8 vPercent)
{
    //DEBUG: qDebug() << "3" << vIndex << vFileName << vPercent;

    _exportListPercent      [vIndex] = vPercent;
    exportIndex             (vIndex     );
    exportFile              (vFileName  );
    exportPercent           (vPercent   );
    if ( vPercent == 100 )
        doExportListDelete(vIndex);
    emit didExportStat      (vIndex, vFileName, vPercent);
}

/*!
 * \brief   GuiView::doExportListInsert
 * \details invocable slot from UI to insert an item in the selection list.
 * \param   vIndex      - selected item index
 * \param   vFileName   - selected item file name
 */
void GuiView::doExportListInsert(quint32 vIndex, const QString &vFilename)
{
    _exportList             [vIndex] = vFilename     ;
    _exportListPercent      [vIndex] = 100           ;
    exportIndex             ( vIndex                );
    exportFile              ( vFilename             );
    exportCount             ( _exportList.count()   );
    emit exportListChanged  (_exportList            );
}

/*!
 * \brief   GuiView::doExportListDelete
 * \details invocable slot from UI to delete a selected item from the list.
 * \param   vIndex      - deselected item index
 */
void GuiView::doExportListDelete(quint32 vIndex)
{
    _exportList.remove      (vIndex);
    _exportListPercent      [vIndex] = 0             ;
    exportIndex             ( vIndex                );
    exportFile              ( ""                    );
    exportCount             ( _exportList.count()   );
    emit exportListChanged  (_exportList            );
}

/*!
 * \brief   GuiView::doExportListSelect
 * \details invocable slot from UI to identify if the item with the index vIndex is selected.
 * \param   vIndex      - item index
 * \return  true if the item with index vIndex is selected.
 */
bool GuiView::doExportListSelect(quint32 vIndex)
{
    bool contains = _exportList.contains(vIndex);
    return contains;
}

/*!
 * \brief   GuiView::doExportListPercent
 * \details invocable slot from UI to get the exported/copied percent of the item with the index vIndex.
 * \param   vIndex      - item index
 * \return  the exported/copied percent
 */
quint8 GuiView::doExportListPercent(quint32 vIndex)
{
    exportIndex             ( vIndex );
    return _exportListPercent[vIndex];
}

/*!
 * \brief   GuiView::doExportListRemove
 * \details invocable slot from UI to clear the selection list, and reset related values/properties..
 */
void GuiView::doExportListRemove()
{
    exportIndex             (  0 );
    exportFile              ( "" );
    exportPercent           (  0 );
    exportCount             (  0 );
    _exportList.clear       (    );
    emit exportListChanged  (_exportList);
}

/*!
 * \brief   GuiView::doExportLog
 * \details emits didExportLog signal to notify other classes (GuiController)
 *          , the User requested to export the log.
 */
void GuiView::doExportLog()
{
    exportRunning(true);
    emit didExportLog(_exportList);
}

/*!
 * \brief   GuiView::doExportService
 * \details emits didExportService signal to notify other classes (GuiController)
 *          , the User requested to export the log.
 */
void GuiView::doExportService()
{
    exportRunning(true);
    emit didExportService(_exportList);
}

/*!
 * \brief   GuiView::doExportTreatment
 * \details emits didExportTreatment signal to notify other classes (GuiController)
 *          , the User requested to export the log.
 */
void GuiView::doExportTreatment()
{
    exportRunning(true);
    emit didExportTreatment(_exportList);
}

/*!
 * \brief   GuiView::onSDCardSpaceChange
 * \details SD Card storage space parameter change slot.
 *          This slot when called is calling the function concurrentRemoveLogs,
 *          if percent of available space vPercent is less than Storage::Available_Space_Percent,
 *          if the SD Card is ready (vReady is true)
 * \param   vReady      - The SD Card is Ready
 * \param   vTotal      - Total storage space on the SD Card
 * \param   vAvailable  - Available storage space on the SD Card
 * \param   vPercent    - Percent of available storage space on the SD Card
 */
void GuiView::onSDCardSpaceChange(bool vReady, qint64 vTotal, qint64 vAvailable, quint8 vPercent)
{
    /// DEBUG: qDebug() << vReady << vTotal << vAvailable << vPercent << Storage::Available_Space_Percent;
    Q_UNUSED(vReady)
    sdTotal     ( vTotal                                                    );
    sdAvail     ( vAvailable                                                );
    sdPercent   ( vPercent                                                  );
    sdIsLow     ( Storage::Log_Min_Available_Total_Space_IsLow(vPercent)    );
}

void GuiView::onUSBSpaceChange(bool vReady, qint64 vTotal, qint64 vAvailable, quint8 vPercent)
{
    // DEBUG: qDebug() << "GuiView::onUSBSpaceChange" << vReady << vTotal << vAvailable << vPercent;
    usbTotal    ( vTotal                                        );
    usbAvail    ( vAvailable                                    );
    usbPercent  ( vPercent                                      );
    usbIsReady  ( vReady                                        );
    // TODO : the space check should also be done for the USB as destination but needs calculation and will be done later.
    // usbIsLow     ( vPercent <= Storage::Available_Space_Percent  );
}

/*!
 * \brief   GuiView::isPathSymLink
 * \details Determines if the path passed is a symlink
 * \param   vFilePath  - the targeted filepath to check
 * \return  true if path is a symbolic link, false otherwise
*/
bool GuiView::isPathSymLink(const QString vFilePath )
{
    // TODO to be removed when model added for export log
    return Storage::FileHandler::isPathSymLink(vFilePath);
}

void GuiView::onPOSTPass(bool vPassed)
{
#if BUILD_FOR_DESKTOP // ignore the POST fails on Desktop/VM builds for testing.
    vPassed = true;
#endif
    manufactMode( gEnableManufacturing && vPassed );
    updateMode  ( gEnableUpdating      && vPassed );
    postPass(vPassed);
}

/*!
 * \brief   GuiView::doQuitApplication
 * \details emit the didQuitApplication signal to ask ApplicationController to Quit the application gracefully.
 */
void GuiView::doQuitApplication() {
    emit didQuitApplication();
}

/*!
 * \brief   doGenerateQRImage
 * \details should be called with the given vText to update the qrImageSource property for an image source.
 * \param   vText - the given text for the QR Code
 */
void GuiView::doGenerateQRImage(const QString &vText)
{
    const uint border = 1;
    qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(vText.toLatin1().constData(), qrcodegen::QrCode::Ecc::MEDIUM);
    std::string svg = qrcodegen::QrCode::toSvgString(qr, border);
    QString svgSource = QString("").fromStdString(svg);
    qrImageSource(svgSource);
}