/*!
 *
 * Copyright (c) 2021-2023 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    Settings.h
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      04-Oct-2022
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  29-Mar-2021
 *
 */
#pragma once

// Qt
#include <QObject>
#include <QFutureWatcher>
#include <QString>

// Project
#include "main.h" // Doxygen : do not remove
#include "StorageGlobals.h"
#include "Threads.h"

// forward declarations
class tst_initializations;

namespace Storage {

// TODO - IMPORTANT: this MVC needs to change to configurations in oppose to Settings.
//        It named settings because it suppose to be like QSettings,
//        but since we have settings it is mixing up with that and is very confusing.
// FIXME- IMPORTANT: This set of Settings (MVC) design is not correct:
//      - the data structure should change in Model from column based (keys, values) to tree/map based
//      - the singleton should be the controller not the Model, to protect the model usage, and avoid the shared memory issues.
//      - the model class should be private class, or an object defined in this class, not a global class.

class Settings
{
    // Settings
    const char *_config_attribute_tag   = "#--";
    const char *_duplicate_key_on       = "duplicate_key_on";
    const char *_duplicate_key_off      = "duplicate_key_off";
    const char *_settingsExt            = "conf";
    const char *_settingsFormat         = "%1/%2.%3";
    struct Detail {
        QString category;
        QString location;
        QString content;
    };

private:
    const QString makeSetting(const char *vPath, const char *vFile) {
        QString literal(_settingsFormat);
        return QString(literal.arg(vPath).arg(vFile).arg(_settingsExt));
    }

    bool isValid(const QString &vSettingFile);

    QString fileName(const QString &vCategory);

    void update();

public:
    Settings() {}

    int read();
    int save(const QString &vCategory, const QString &vGroup, const QString &vKey, const QString &vValue);

    enum Category_Enum {
        eInstructions                   ,
        eConfigurationsDataList         , // TODO: the category for this conf is not used. may need to be merged into the Settings, but since it is list, It needs a little more thought.
        eAlarms                         ,
        eMessagesUnhandled              ,
        eSettingsSystem                 ,
        eGenericConfirm                 ,
    };

    enum Key_Enum {
        eKeyTitle                          ,
        eKeyMessage                        ,
        eKeyAlarmName                        ,
        eKeyConfirm                        ,
        eKeyCancel                         ,
    };

    static QString category(Category_Enum vCategory) {
        switch (vCategory) { // NOTE: don't use default
        case eInstructions              : return Storage::Settings_Category_Instructions            ;
        case eConfigurationsDataList    : return Storage::Settings_Category_ConfigurationsDataList  ;
        case eAlarms                    : return Storage::Settings_Category_Alarms                  ;
        case eMessagesUnhandled         : return Storage::Settings_Category_MessagesUnhandled       ;
        case eSettingsSystem            : return Storage::Settings_Category_SettingsSystem          ;
        case eGenericConfirm            : return Storage::Settings_Category_GenericConfirm          ;
        }
        return "";
    }

    static QString key(Key_Enum vKey) {
        switch (vKey) { // NOTE: don't use default
        case eKeyTitle                  : return Storage::Settings_Key_Title                        ;
        case eKeyMessage                : return Storage::Settings_Key_Message                      ;
        case eKeyAlarmName              : return Storage::Settings_Key_AlarmName                    ;
        case eKeyConfirm                : return Storage::Settings_Key_Confirm                      ;
        case eKeyCancel                 : return Storage::Settings_Key_Cancel                       ;
        }
        return "";
    }

    static bool isCategoryInstructions              (const QString &vCategory) { return vCategory == category( eInstructions            ); }
    static bool isCategoryConfigurationsDataList    (const QString &vCategory) { return vCategory == category( eConfigurationsDataList  ); }
    static bool isCategoryAlarms                    (const QString &vCategory) { return vCategory == category( eAlarms                  ); }
    static bool isCategoryMessagesUnhandled         (const QString &vCategory) { return vCategory == category( eMessagesUnhandled       ); }
    static bool isCategorySettingsSystem            (const QString &vCategory) { return vCategory == category( eSettingsSystem          ); }
    static bool isCategoryConfirm                   (const QString &vCategory) { return vCategory == category( eGenericConfirm          ); }
    static bool isKeyTitle                          (const QString &vKey     ) { return vKey      == key     ( eKeyTitle                ); }
    static bool isKeyMessage                        (const QString &vKey     ) { return vKey      == key     ( eKeyMessage              ); }
    static bool isKeyAlarmName                      (const QString &vKey     ) { return vKey      == key     ( eKeyAlarmName            ); }
    static bool isKeyConfirm                        (const QString &vKey     ) { return vKey      == key     ( eKeyConfirm              ); }
    static bool isKeyCancel                         (const QString &vKey     ) { return vKey      == key     ( eKeyCancel               ); }

};

}