#ifndef WORKER_H_INCLUDED
#define WORKER_H_INCLUDED

#include <QObject>
#include <QString>
#include <QStringList>
#include <QTimer>
#include <QFile>
#include <QJsonObject>
#include <QHash>
#include <QMap>
#include <QDebug>

#include <optional>
#include <initializer_list>

#include "worker_thread.h"
#include "update.h"
#include "git/git_client.h"
#include "ismas/ismas_client.h"
#include "utils.h"

#ifdef PTU5
#define SERIAL_PORT "ttymxc2"
#else
#define SERIAL_PORT "ttyUSB0"
#endif

#define _STARTED                                (1)
#define _CHECK_REPOSITORY                       (2)
#define _CHECK_SANITY                           (3)
#define _CHECK_SANITY_SUCCESS                   (4)
#define _CHECK_SANITY_FAILURE                   (5)
#define _CLONE_REPOSITORY                       (6)
#define _CLONE_REPOSITORY_SUCCESS               (7)
#define _CLONE_REPOSITORY_FAILURE               (8)
#define _SWITCH_BRANCH                          (12)
#define _SWITCH_BRANCH_SUCCESS                  (13)
#define _SWITCH_BRANCH_FAILURE                  (14)
#define _CHECK_ISMAS_TRIGGER                    (15)
#define _CHECK_ISMAS_TRIGGER_SUCCESS            (23)
#define _CHECK_ISMAS_TRIGGER_FAILURE            (24)
#define _UPDATE_REPOSITORY                      (25)
#define _UPDATE_REPOSITORY_SUCCESS              (28)
#define _UPDATE_REPOSITORY_FAILURE              (29)
#define _CHECK_FOR_REPOSITORY_CHANGES           (30)
#define _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS   (38)
#define _CHECK_FOR_REPOSITORY_CHANGES_FAILURE   (39)
#define _APPLY_REPOSITORY_CHANGES               (40)
#define _DOWNLOAD_CONFIG_FILE                   (41)
#define _DOWNLOAD_CONFIG_FILE_SUCCESS           (63)
#define _DOWNLOAD_CONFIG_FILE_FAILURE           (64)
#define _DOWNLOAD_DEVICE_CONTROLLER             (65)
#define _DOWNLOAD_DEVICE_CONTROLLER_SUCCESS     (86)
#define _DOWNLOAD_DEVICE_CONTROLLER_FAILURE     (87)
#define _APPLY_REPOSITORY_CHANGES_SUCCESS       (88)
#define _APPLY_REPOSITORY_CHANGES_FAILURE       (89)
#define _SYNC_CUSTOMER_REPOSITORY               (90)
#define _SYNC_CUSTOMER_REPOSITORY_SUCCESS       (91)
#define _SYNC_CUSTOMER_REPOSITORY_FAILURE       (92)
#define _SAVE_LOGS                              (94)
#define _SAVE_LOGS_SUCCESS                      (95)
#define _SAVE_LOGS_FAILURE                      (96)
#define _SEND_LAST_VERSION                      (97)
#define _UPDATE_SUCCEEDED                       (98)
#define _UPDATE_FAILED                          (99)
#define _FINISHED                               (100)

enum class UPDATE_STATUS : quint8 {
    NOT_DEFINED,
    ISMAS_WAIT_STATE_CHECK_PENDING,
    ISMAS_WAIT_STATE_CHECK_FAILURE,
    ISMAS_RESPONSE_RECEIVED,
    BACKEND_CHECK,
    BACKEND_CHECK_FAILURE,
    BACKEND_NOT_CONNECTED,
    ISMAS_UPDATE_TRIGGER_SET,
    ISMAS_UPDATE_TRIGGER_NOT_SET_OR_WRONG,
    GIT_CLONE_AND_CHECKOUT_SUCCESS,
    GIT_CLONE_AND_CHECKOUT_FAILURE,
    GIT_CHECKOUT_BRANCH,
    GIT_CHECKOUT_BRANCH_FAILURE,
    GIT_FETCH_UPDATES,
    GIT_FETCH_UPDATES_REQUEST_FAILURE,
    EXEC_OPKG_COMMAND,
    EXEC_OPKG_COMMANDS,
    RSYNC_UPDATES_FAILURE,
    RSYNC_UPDATES_SUCCESS,
    RSYNC_FILE_SUCCESS,
    JSON_PARSE_FAILURE,
    UPDATE_PROCESS_SUCCESS,
    UPDATE_PROCESS_FAILURE,
    ISMAS_SANITY_CHECK_OK,
    ISMAS_UPDATE_TRIGGER_SET_FAILURE,
    PSA_UPDATE_FILES_FAILED,
    GIT_CHECK_FILES_TO_UPDATE_SUCCESS,
    ISMAS_SEND_LAST_VERSION_FAILED,
    SAVE_LOG_FILES_FAILED,
    REMOVE_GIT_REPOSITORY_FAILED
};

struct UpdateStatus {
    UPDATE_STATUS m_updateStatus;
    QString m_statusDescription;

    explicit UpdateStatus(UPDATE_STATUS s = UPDATE_STATUS::NOT_DEFINED,
                          QString const &d = QString(""))
        : m_updateStatus(s), m_statusDescription(d) {}
};


#define ISMAS_UPDATE_REQUESTS   (10)

class MainWindow;
class hwinf;
class Worker : public QObject {
    Q_OBJECT

    WorkerThread m_workerThread;
    int const m_customerNr;
    QString const m_customerNrStr;
    int const m_machineNr;
    int const m_zoneNr;
    QString const m_pluginName;
    QString const m_workingDirectory;
    QString const m_branchName;
    QString const m_customerRepositoryPath;
    QString const m_customerRepository;
    bool const m_dryRun;
    QObject *m_parent;
    QString const m_serialInterface;
    QString const m_baudrate;
    IsmasClient m_ismasClient;
    GitClient m_gc;
    QString const m_osVersion;
    QString const m_atbqtVersion;
    QString const m_atbUpdateToolVersion;
    QString const m_cpuSerial;
    QString const m_pluginVersionATBDeciceController;
    QString const m_pluginVersionIngenicoISelf;
    QString const m_pluginVersionMobilisisCalc;
    QString const m_pluginVersionMobilisisCalcConfig;
    QString const m_pluginVersionPrmCalc;
    QString const m_pluginVersionPrmCalcConfig;
    QString const m_pluginVersionTcpZvt;

    int m_ismasUpdateRequests;
    QTimer m_waitForNewUpdates;

    UpdateStatus m_updateStatus;

    QStringList m_filesToUpdate;
    QStringList m_filesToDownload;
    bool m_updateProcessRunning;
    int m_displayIndex;
    int m_returnCode;

    MainWindow *m_mainWindow;
    bool m_withoutIsmasDirectPort;
    QString m_apismVersion;

    bool executeOpkgCommand(QString opkgCommand);
    QString getOsVersion() const;
    QString getATBQTVersion() const;
    QString getATBUpdateToolVersion() const;
    QString getCPUSerial() const;
    QString getRaucVersion() const;
    QString getOpkgVersion() const;
    QString getPluginVersion(QString const &pluginFileName) const;
    QStringList getDCVersion() const;

    qint64 getFileSize(QString const &fileName) const;
    bool isRepositoryCorrupted();
    bool repairCorruptedRepository();

    int sendCloneAndCheckoutSuccess();
    int sendCloneAndCheckoutFailure();
    int sendIsmasTriggerFailure();
    int sendPullFailure();
    int sendFileUpdateFailure();
    int sendRsyncFailure();
    int sendLastVersionFailure();
    int sendSaveLogFilesFailure();
    int sendCustomerEnvironmentConfigurationFailed();
    int sendFoundFilesToUpdateSuccess();
    int sendUpdateSucceededAndActivated();
    int sendFinalResult();

    static constexpr const int UPDATE_SUCCESS_AND_ACTIVATED = 0;
    static constexpr const int CLONE_AND_CHECKOUT_SUCCESS = 0;
    static constexpr const int CLONE_AND_CHECKOUT_FAILURE = -3;
    static constexpr const int ISMAS_TRIGGER_FAILURE = -5;
    static constexpr const int ENVIRONMENT_CONFIG_FAILURE = -6;
    static constexpr const int GIT_PULL_FAILURE = -7;
    static constexpr const int UPDATE_FILES_FAILURE = -8;
    static constexpr const int RSYNC_FAILURE = -9;
    static constexpr const int SEND_LAST_VERSION_FAILURE = -10;
    static constexpr const int SAVE_LOG_FILES_FAILURE = -11;

    enum class UPDATE_STEP {
        STARTED = _STARTED,
        CHECK_REPOSITORY = _CHECK_REPOSITORY,
        CHECK_SANITY = _CHECK_SANITY,
        CHECK_SANITY_SUCCESS = _CHECK_SANITY_SUCCESS,
        CHECK_SANITY_FAILURE = _CHECK_SANITY_FAILURE,
        CLONE_REPOSITORY = _CLONE_REPOSITORY,
        CLONE_REPOSITORY_SUCCESS = _CLONE_REPOSITORY_SUCCESS,
        CLONE_REPOSITORY_FAILURE = _CLONE_REPOSITORY_FAILURE,
        SWITCH_BRANCH = _SWITCH_BRANCH,
        SWITCH_BRANCH_SUCCESS = _SWITCH_BRANCH_SUCCESS,
        SWITCH_BRANCH_FAILURE = _SWITCH_BRANCH_FAILURE,
        CHECK_ISMAS_TRIGGER = _CHECK_ISMAS_TRIGGER,
        CHECK_ISMAS_TRIGGER_SUCCESS = _CHECK_ISMAS_TRIGGER_SUCCESS,
        CHECK_ISMAS_TRIGGER_FAILURE = _CHECK_ISMAS_TRIGGER_FAILURE,
        UPDATE_REPOSITORY = _UPDATE_REPOSITORY,
        UPDATE_REPOSITORY_SUCCESS = _UPDATE_REPOSITORY_SUCCESS,
        UPDATE_REPOSITORY_FAILURE = _UPDATE_REPOSITORY_FAILURE,
        CHECK_FOR_REPOSITORY_CHANGES = _CHECK_FOR_REPOSITORY_CHANGES,
        CHECK_FOR_REPOSITORY_CHANGES_SUCCESS = _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS,
        CHECK_FOR_REPOSITORY_CHANGES_FAILURE = _CHECK_FOR_REPOSITORY_CHANGES_FAILURE,
        APPLY_REPOSITORY_CHANGES = _APPLY_REPOSITORY_CHANGES,
        DOWNLOAD_CONFIG_FILE = _DOWNLOAD_CONFIG_FILE,
        DOWNLOAD_CONFIG_FILE_SUCCESS = _DOWNLOAD_CONFIG_FILE_SUCCESS,
        DOWNLOAD_CONFIG_FILE_FAILURE = _DOWNLOAD_CONFIG_FILE_FAILURE,
        DOWNLOAD_DEVICE_CONTROLLER = _DOWNLOAD_DEVICE_CONTROLLER,
        DOWNLOAD_DEVICE_CONTROLLER_SUCCESS = _DOWNLOAD_DEVICE_CONTROLLER_SUCCESS,
        DOWNLOAD_DEVICE_CONTROLLER_FAILURE = _DOWNLOAD_DEVICE_CONTROLLER_FAILURE,
        APPLY_REPOSITORY_CHANGES_SUCCESS = _APPLY_REPOSITORY_CHANGES_SUCCESS,
        APPLY_REPOSITORY_CHANGES_FAILURE = _APPLY_REPOSITORY_CHANGES_FAILURE,
        SYNC_CUSTOMER_REPOSITORY = _SYNC_CUSTOMER_REPOSITORY,
        SYNC_CUSTOMER_REPOSITORY_SUCCESS = _SYNC_CUSTOMER_REPOSITORY_SUCCESS,
        SYNC_CUSTOMER_REPOSITORY_FAILURE = _SYNC_CUSTOMER_REPOSITORY_FAILURE,
        SAVE_LOGS = _SAVE_LOGS,
        SAVE_LOGS_SUCCESS = _SAVE_LOGS_SUCCESS,
        SAVE_LOGS_FAILURE = _SAVE_LOGS_FAILURE,
        SEND_LAST_VERSION = _SEND_LAST_VERSION,
        UPDATE_SUCCEEDED = _UPDATE_SUCCEEDED,
        UPDATE_FAILED = _UPDATE_FAILED,
        FINISHED = _FINISHED
    };

    static Worker const *instance;

public:
    static QString getATBUpdateToolYoctoVersion();
    static QString getATBUpdateToolYoctoInstallationStatus();

    static const QString UPDATE_STEP_OK;
    static const QString UPDATE_STEP_DONE;
    static const QString UPDATE_STEP_FAIL;
    static const QString UPDATE_STEP_SUCCESS;

    explicit Worker(int customerNr, // 281
                    int machineNr,
                    int zoneNr,
                    QString branchName,
                    QString pluginName,
                    QString workingDir = ".",
                    bool dryRun = false,
                    QObject *parent = nullptr,
                    char const *serialInterface = SERIAL_PORT,
                    char const *baudrate = "115200");
    ~Worker();

    void setMainWindow(MainWindow *mainWindow) { m_mainWindow = mainWindow; }
    hwinf *getPlugin();
    hwinf const *getPlugin() const;
    void setProgress(int progress);
    void displayProgressInMainWindow(int progress);
    void startProgressLoop();
    void stopProgressLoop();

    IsmasClient &getIsmasClient() { return m_ismasClient; }
    IsmasClient const &getIsmasClient() const { return m_ismasClient; }

    bool updateProcessRunning() const { return m_updateProcessRunning; }
    int returnCode() const { return m_returnCode; }

    int machineNr() const { return m_machineNr; }
    int customerNr() const { return m_customerNr; }
    int zoneNr() const { return m_zoneNr; }
    QString apismVersion() const { return m_apismVersion; }
    QString atbUpdateToolVersion() const { return m_atbUpdateToolVersion; }

    MainWindow *mainWindow() { return m_mainWindow; }
    MainWindow const *mainWindow() const { return m_mainWindow; }

signals:
    void appendText(QString, QString suffix = "");
    void replaceLast(QString, QString);
    void replaceLast(QStringList, QString);
    void showErrorMessage(QString title, QString description);
    void showStatusMessage(QString title, QString description);
    void stopStartTimer();
    void restartExitTimer();
    void enableExit();
    void disableExit();

public slots:
    void update();

private slots:
    bool updateTriggerSet(int progress);
    bool customerEnvironment(int progress);
    bool filesToUpdate(int progress);
    bool updateFiles(int percent);
    bool syncCustomerRepositoryAndFS(int progress);
    bool sendIsmasLastVersionNotification(int progress);
    bool saveLogFile(int progress);

private:
    PSAInstalled getPSAInstalled();
    void privateUpdate();
    std::optional<QString> getApismVersion();
    void printProgress(UPDATE_STEP step);

    static const QMap<UPDATE_STEP, const char*> smap;

    friend UPDATE_STEP operator<<(QDebug debug, UPDATE_STEP step) {
        if (!Worker::instance) {
            return step;
        }

        static const QMap<UPDATE_STEP, const char*> smap (
            std::initializer_list<std::pair<UPDATE_STEP, const char*>>{
#define INSERT_ELEMENT(p) std::pair(p, #p)
                INSERT_ELEMENT(UPDATE_STEP::STARTED),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH),
                INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS),
                INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SEND_LAST_VERSION),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_SUCCEEDED),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_FAILED),
                INSERT_ELEMENT(UPDATE_STEP::FINISHED)
#undef INSERT_ELEMENT
        });

        switch (step) {
        case UPDATE_STEP::STARTED: {
            Utils::printUpdateStatusMsg(
                debug,
                QStringList(smap[step])
                    << QString("CURRENT TIME ...............%1").arg(QDateTime::currentDateTime().toString(Qt::ISODate))
                    << QString("OS VERSION .................%1").arg(instance->m_osVersion)
                    << QString("ATBQT VERSION ..............%1").arg(instance->m_atbqtVersion)
                    << QString("CPU SERIAL .................%1").arg(instance->m_cpuSerial)
                    << QString("CUSTOMER_NR ................%1").arg(instance->m_customerNr)
                    << QString("CUSTOMER_NR_STR ............%1").arg(instance->m_customerNrStr)
                    << QString("CUSTOMER_REPOSITORY_PATH ...%1").arg(instance->m_customerRepositoryPath)
                    << QString("CUSTOMER_REPOSITORY ........%1").arg(instance->m_customerRepository)
                    << QString("MACHINE_NR .................%1").arg(instance->m_machineNr)
                    << QString("ZONE_NR ....................%1").arg(instance->m_zoneNr)
                    << QString("BRANCH_NAME ................%1").arg(instance->m_branchName)
                    << QString("PLUGIN_NAME ................%1").arg(instance->m_pluginName)
                    << QString("WORKING_DIRECTORY ..........%1").arg(instance->m_workingDirectory)
                    << QString("APISM VERSION ..............%1").arg(instance->m_apismVersion)
                    << QString("ATB UPDATE TOOL VERSION ....%1").arg(instance->m_atbUpdateToolVersion));
        } break;
        case UPDATE_STEP::CHECK_REPOSITORY:
        break;
        case UPDATE_STEP::CHECK_SANITY:
        break;
        case UPDATE_STEP::CHECK_SANITY_SUCCESS:
        break;
        case UPDATE_STEP::CHECK_SANITY_FAILURE:
        break;
        case UPDATE_STEP::CLONE_REPOSITORY:
        break;
        case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS:
        break;
        case UPDATE_STEP::CLONE_REPOSITORY_FAILURE:
        break;
        case UPDATE_STEP::SWITCH_BRANCH:
        break;
        case UPDATE_STEP::SWITCH_BRANCH_SUCCESS:
        break;
        case UPDATE_STEP::SWITCH_BRANCH_FAILURE:
        break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
        break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
        break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
        break;
        case UPDATE_STEP::UPDATE_REPOSITORY:
        break;
        case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
        break;
        case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
        break;
        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
        break;
        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
        break;
        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
        break;
        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
        break;
        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
        break;
        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
        break;
        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
        break;
        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
        break;
        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
        break;
        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
        break;
        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
        break;
        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
        break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
        break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
        break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
        break;
        case UPDATE_STEP::SAVE_LOGS:
        break;
        case UPDATE_STEP::SAVE_LOGS_SUCCESS:
        break;
        case UPDATE_STEP::SAVE_LOGS_FAILURE:
        break;
        case UPDATE_STEP::SEND_LAST_VERSION:
        break;
        case UPDATE_STEP::UPDATE_SUCCEEDED:
        break;
        case UPDATE_STEP::UPDATE_FAILED:
        break;
        case UPDATE_STEP::FINISHED:
        break;
        }

        return step;
    }

    friend UPDATE_STEP operator<<(IsmasClient &ismasClient, UPDATE_STEP step) {

        if (!Worker::instance) {
            return step;
        }

        static const QMap<UPDATE_STEP, const char*> smap (
            std::initializer_list<std::pair<UPDATE_STEP, const char*>>{
#define INSERT_ELEMENT(p) std::pair(p, #p)
                INSERT_ELEMENT(UPDATE_STEP::STARTED),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH),
                INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY),
                INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS),
                INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_SUCCESS),
                INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_FAILURE),
                INSERT_ELEMENT(UPDATE_STEP::SEND_LAST_VERSION),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_SUCCEEDED),
                INSERT_ELEMENT(UPDATE_STEP::UPDATE_FAILED),
                INSERT_ELEMENT(UPDATE_STEP::FINISHED)
#undef INSERT_ELEMENT
        });

        switch (step) {
        case UPDATE_STEP::STARTED: {
            ismasClient.setProgressInPercent(_STARTED);
        } break;
        case UPDATE_STEP::CHECK_REPOSITORY:
            ismasClient.setProgressInPercent(_CHECK_REPOSITORY);
        break;
        case UPDATE_STEP::CHECK_SANITY:
            ismasClient.setProgressInPercent(_CHECK_SANITY);
        break;
        case UPDATE_STEP::CHECK_SANITY_SUCCESS:
            ismasClient.setProgressInPercent(_CHECK_SANITY_SUCCESS);
        break;
        case UPDATE_STEP::CHECK_SANITY_FAILURE:
            ismasClient.setProgressInPercent(_CHECK_SANITY_FAILURE);
        break;
        case UPDATE_STEP::CLONE_REPOSITORY:
            ismasClient.setProgressInPercent(_CLONE_REPOSITORY);
        break;
        case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS:
            ismasClient.setProgressInPercent(_CLONE_REPOSITORY_SUCCESS);
        break;
        case UPDATE_STEP::CLONE_REPOSITORY_FAILURE:
            ismasClient.setProgressInPercent(_CLONE_REPOSITORY_FAILURE);
        break;
        case UPDATE_STEP::SWITCH_BRANCH:
            ismasClient.setProgressInPercent(_SWITCH_BRANCH);
        break;
        case UPDATE_STEP::SWITCH_BRANCH_SUCCESS:
            ismasClient.setProgressInPercent(_SWITCH_BRANCH_SUCCESS);
        break;
        case UPDATE_STEP::SWITCH_BRANCH_FAILURE:
            ismasClient.setProgressInPercent(_SWITCH_BRANCH_FAILURE);
        break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER);
        break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_SUCCESS);
        break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_FAILURE);
        break;
        case UPDATE_STEP::UPDATE_REPOSITORY:
            ismasClient.setProgressInPercent(_UPDATE_REPOSITORY);
        break;
        case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
            ismasClient.setProgressInPercent(_UPDATE_REPOSITORY_SUCCESS);
        break;
        case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
            ismasClient.setProgressInPercent(_UPDATE_REPOSITORY_FAILURE);
        break;
        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
            ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES);
        break;
        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
            ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_SUCCESS);
        break;
        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
            ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_FAILURE);
        break;
        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
            ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES);
        break;
        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
            ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE);
        break;
        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
            ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE_SUCCESS);
        break;
        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
            ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE_FAILURE);
        break;
        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
            ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER);
        break;
        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
            ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER_SUCCESS);
        break;
        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
            ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER_FAILURE);
        break;
        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
            ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES_SUCCESS);
        break;
        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
            ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES_FAILURE);
        break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
            ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY);
        break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
            ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY_SUCCESS);
        break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
            ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY_FAILURE);
        break;
        case UPDATE_STEP::SAVE_LOGS:
            ismasClient.setProgressInPercent(_SAVE_LOGS);
        break;
        case UPDATE_STEP::SAVE_LOGS_SUCCESS:
            ismasClient.setProgressInPercent(_SAVE_LOGS_SUCCESS);
        break;
        case UPDATE_STEP::SAVE_LOGS_FAILURE:
            ismasClient.setProgressInPercent(_SAVE_LOGS_FAILURE);
        break;
        case UPDATE_STEP::SEND_LAST_VERSION:
            ismasClient.setProgressInPercent(_SEND_LAST_VERSION);
        break;
        case UPDATE_STEP::UPDATE_SUCCEEDED:
            ismasClient.setProgressInPercent(_UPDATE_SUCCEEDED);
        break;
        case UPDATE_STEP::UPDATE_FAILED:
            ismasClient.setProgressInPercent(_UPDATE_FAILED);
        break;
        case UPDATE_STEP::FINISHED:
            ismasClient.setProgressInPercent(_FINISHED);
        break;
        break;
        }

        return step;
    }

#if 0
        case UPDATE_STEP::CHECK_SANITY:
            Utils::printUpdateStatusMsg(
                QStringList()
                    <<  QString("STEP 1: CHECKED SANITY OF CUSTOMER REPOSITORY %1 DONE")
                            .arg(instance->m_customerRepository)
                    <<  QString("STEP 2: FETCH CUSTOMER REPOSITORY %1...")
                            .arg(instance->m_customerRepository));
            break;
        //case UPDATE_STEP::FETCH_REPOSITORY:
        //    Utils::printUpdateStatusMsg(
        //        QStringList()
        //            <<  QString("STEP 2: FETCHED CUSTOMER REPOSITORY %1 DONE")
        //                    .arg(instance->m_customerRepository)
        //            <<  QString("STEP 3: CHECK ISMAS-UPDATE-TRIGGER FOR WAIT-STATUS..."));
        //    break;
        case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
            Utils::printUpdateStatusMsg(
                QStringList()
                    << QString("STEP 3: CHECKED ISMAS-UPDATE-TRIGGER FOR WAIT-STATUS. SUCCESS.")
                    << QString("STEP 4: CHECK-OUT BRANCH %1...").arg(instance->m_gc.branchName()));
            break;
        case UPDATE_STEP::CHECKED_OUT_BRANCH:
            Utils::printUpdateStatusMsg(
                QStringList()
                    << QString("STEP 4: CHECKED-OUT BRANCH %1 DONE")
                            .arg(instance->m_gc.branchName())
                    << QString("STEP 5: COMPUTE FILES-TO-UPDATE..."));
            break;
        case UPDATE_STEP::COMPUTE_FILES_TO_UPDATE:
            Utils::printUpdateStatusMsg(
                QStringList()
                    << QString("STEP 5: COMPUTE FILES-TO-UPDATE %1 DONE")
                            .arg(instance->m_filesToUpdate.join(','))
                    << QString("STEP 6: DOWNLOAD FILES-TO-DOWNLOAD %1 AND EXECUTE OPKG_COMMANDS...")
                            .arg(instance->m_filesToDownload.join(',')));
            break;
        case UPDATE_STEP::DOWNLOAD_FILES_TO_UPDATE:
            Utils::printUpdateStatusMsg(
                QStringList()
                    << QString("STEP 6: DOWNLOAD FILES-TO-DOWNLOAD %1 AND EXECUTE OPKG_COMMANDS DONE")
                        .arg(instance->m_filesToDownload.join(','))
                    << QString("STEP 7: SYNC CUSTOMER REPOSITORY %1 WITH FILESYSTEM...")
                        .arg(instance->m_customerRepository));
            break;
        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
            Utils::printUpdateStatusMsg(
                QStringList()
                    << QString("STEP 7: SYNC CUSTOMER REPOSITORY %1 WITH FILESYSTEM DONE")
                            .arg(instance->m_customerRepository)
                    << QString("STEP 8: SEND-LAST-VERSION TO ISMAS..."));
            break;
        case UPDATE_STEP::UPDATE_SUCCESS:
            Utils::printUpdateStatusMsg(
                QStringList()
                    << QString("STEP 9: SAVE-LOG-FILES (FUTURE USE) DONE")
                    << QString("STEP 10: MARK UPDATE AS SUCCESSFUL AND ACTIVE..."));
            break;
        }
#endif

    friend UPDATE_STEP operator<<(MainWindow *mainWindow, UPDATE_STEP step) {

        if (!Worker::instance) {
            return step;
        }

        return step;
    }
};

#endif // WORKER_H_INCLUDED