ts/TransmitterSwitch/TransmitterSwitchInfo.h

#ifndef TRANSMITTERSWITCHINFO_H
#define TRANSMITTERSWITCHINFO_H

#include <QDate>
#include <QString>
#include <QMap>
#include <QObject>

#include "nlohmann/json.hpp"

#define nJson nlohmann::json

extern const QMap<int, QString> g_mapTrack;

/**
 * @brief 支持的发射机类型
 * 
 */
const QMap<int, QString> g_DevTypeInfo = {
    {955, "衢州台发射机"}
};



/* EQM数据库中的主备 */
enum class enum_DeviceMB : int
{
    Dev_Main = 0,                /* 主设备 */
    Dev_Backup = 1,             /* 备设备 */
    Dev_Contingency = 2         /* 应急设备 */
};

enum class enum_Action : int
{
    Act_ON = 1,                 /* 开机 */
    Act_OFF = 2,                /* 关机 */
};

/**
 * @brief UI样式
 * 
 */
enum class enum_UIStyle
{
    UI_Light = 0,               /* 亮色 */
    UI_Dark = 1                 /* 暗色 */
};

/**
 * @brief tExecPlanConfig表格的关键字
 * 
 */
enum class enum_ExecPlanConfig : int
{
    DefaultPlan = 1,            /* 执行计划 */
    ExecMode = 2,               /* 执行模式 */
    IsChanged = 3               /* 是否修改 */
};

/**
 * @brief 默认计划选项
 * 
 */
 enum class enum_DefaultPlan : int
 {
    DefaultPlan_ON = 0,             /* 默认计划关 */
    DefaultPlan_OFF = 1             /* 默认计划开 */
 };

/**
 * @brief WebAPI初始化数据
 * 
 */
struct InitData
{
    QString url;                /* WebAPI地址 */
    QString serverID;           /* 服务器ID */
    QString serverKey;          /* 服务器Key */
    InitData& operator=(const InitData& data)
    {
        url = data.url;
        serverID = data.serverID;
        serverKey = data.serverKey;
        return *this;
    }
};

/**
 * @brief 配置键值对
 *        key1 : 默认执行计划开关
 *        key2 : 执行模式
 * 
 */
struct ConfigData
{
    int key;                    /* 键 */
    int value;                  /* 值 */
    QDateTime updateTime;       /* 更新时间 */
    QString notes;              /* 备注 */
    ConfigData() : key(0), value(0), updateTime(QDateTime::currentDateTime()), notes("") {}
    ConfigData(const ConfigData& data)
    {
        key = data.key;
        value = data.value;
        updateTime = data.updateTime;
        notes = data.notes;
    }
    ConfigData& operator=(const ConfigData& data)
    {
        key = data.key;
        value = data.value;
        updateTime = data.updateTime;
        notes = data.notes;
        return *this;
    }
};

#define CfgData ConfigDataContainer::getInstance()

/**
 * @brief 全局键值对容器
 * 
 */
class ConfigDataContainer
{
private:
    ConfigDataContainer() {}
    ConfigDataContainer(const ConfigDataContainer& data) = delete;
    ConfigDataContainer& operator=(const ConfigDataContainer& data) = delete;
public:
    /* 配置的键值对的说明 */
    const QMap<int, QString> KeyNotes = {
        {static_cast<int>(enum_ExecPlanConfig::DefaultPlan), "默认执行计划开关，0关，1开"},
        {static_cast<int>(enum_ExecPlanConfig::ExecMode), "执行模式，0按时刻，1按天"},
        {static_cast<int>(enum_ExecPlanConfig::IsChanged), "是否更新，0未修改，1修改"}
    };

public:
    ~ConfigDataContainer() {}

    static ConfigDataContainer& getInstance()
    {
        static ConfigDataContainer data;
        return data;
    }

    /* 添加一个配置 */
    void updateConfigData(const ConfigData& data);
    /* 获取一个配置 */
    ConfigData& getConfigData(int key);
    /* 查找一个配置是否在不在 */
    bool findConfigData(int key);
    /* 删除一个配置 */
    void deleteConfigData(int key);
    /* 获取容器 */
    QMap<int, ConfigData>& getMapConfigData() { return m_mapConfigData; }

private:
    QMap<int, ConfigData> m_mapConfigData;          /* 配置信息，key是配置的键 */

};


/**
 * @brief 执行计划条目信息
 * 
 */
struct ExecPlanItemInfo
{
    int ExecType;                                   /* 执行类型，0按时刻，1按天 */
    int WeekDay;                                    /* 周几，数据库里是1-7一周，周8是特殊日 */
    QDate date;                                     /* 日期 */
    QTime execTime;                                 /* 执行时间 */
    QString devName;                                /* 设备名称 */
    int actionID;                                   /* 动作ID */
    QString actionName;                             /* 执行的动作 */

    ExecPlanItemInfo();
    ExecPlanItemInfo(const ExecPlanItemInfo& item);
    ExecPlanItemInfo& operator=(const ExecPlanItemInfo& item);
};




/**
 * @brief 存储一个设备类型及端口参数，即这个设备支持哪些端口，在配置页面选择设备的时候使用
 *        如：“衢州台发射机”支持哪些端口
*/
struct DevTypeInfo
{
    DevTypeInfo();
    ~DevTypeInfo() {}
    DevTypeInfo& operator=(const DevTypeInfo& devInfo);

    QString devTypeName;                            /* 设备类型名称，如：衢州台发射机，非必须的 */
    QMap<int, QString> devAction;                   /* 设备支持的动作，如开机、关机等 */
    QMap<enum_DeviceMB, QString> devType_MB;        /* 同一中设备允许存在的个数，如主/备或其他标记方式，这里用不到 */
    int PTTypeCode;                                 /* 设备类型编号，在EQM数据库中的类型，如发射机是955 */
};


/**
 * @brief 软件支持的设备类型信息
 * 
 */
class MapDevType
{
    MapDevType();
    MapDevType(const MapDevType& devType) = delete;
    MapDevType& operator=(const MapDevType& devType) = delete;
public:
    ~MapDevType() {}

    static MapDevType& getInstance()
    {
        static MapDevType instance;
        return instance;
    }
    /* 添加支持的设备类型 */
    void initDevType();
    /* 获取某一个发射机类型 */
    DevTypeInfo getDevType(int PTTypeCode);
    /* 获取设备类型信息 */
    QMap<int, DevTypeInfo>& getMapDevType() { return m_mapDevType; }

private:
    QMap<int, DevTypeInfo> m_mapDevType;            /* 设备类型信息，int是发射机的PTTypeCode */

};

#define DevTypeContainer MapDevType::getInstance()




/**
 * @brief 配置完成后的信息，给一个类型的设备创建了名字，并存储了设备类型和参数信息
*/
struct DeviceInfo
{
    DeviceInfo();
    ~DeviceInfo() {}
    DeviceInfo(const DeviceInfo& devInfo);
    DeviceInfo& operator=(const DeviceInfo& devInfo);

    QString devName;                    /* 自定义的设备名称 */
    DevTypeInfo DevType;                /* 该设备的类型 */

    // QPair<enum_DeviceMB, QString> devTypeMB;      /* 该设备是主设备还是备用设备 */
    int DID;                            /* 设备ID */
    int DTID;                           /* 设备类型ID */
    int MPID;                           /* 监测点ID */
    int PTTypeCode;                     /* 端口类型编码 */
    int ChannelID;                      /* 通道ID */
};


class MapDevice
{
    MapDevice();
    MapDevice(const MapDevice& dev) = delete;
    MapDevice& operator=(const MapDevice& dev) = delete;
public:
    ~MapDevice() {}

    static MapDevice& getInstance()
    {
        static MapDevice instance;
        return instance;
    }

    /* 添加一个设备 */
    void addDevice(const DeviceInfo& devInfo);
    /* 获取一个设备 */
    DeviceInfo getDevice(const QString& devName);
    /* 查找一个设备 */
    bool findDevice(const QString& devName);
    /* 根据设备名称获取设备动作 */
    bool getDevAction(const QString& devName, QMap<int, QString>& devAction);
    /* 删除一个设备 */
    void deleteDevice(const QString& devName);
    /* 获取容器 */
    QMap<QString, DeviceInfo>& getMapDevice() { return m_mapDevice; }

private:
    QMap<QString, DeviceInfo> m_mapDevice;          /* 设备信息，key是设备名称 */

};

#define DeviceContainer MapDevice::getInstance()


/**
 * @brief 执行计划页面的全局配置信息
 * 
 */
class ExecPlanGlobalConfig : public QObject
{
    Q_OBJECT

    ExecPlanGlobalConfig();
    ExecPlanGlobalConfig(const ExecPlanGlobalConfig& config) = delete;
    ExecPlanGlobalConfig& operator=(const ExecPlanGlobalConfig& config) = delete;
public:
    ~ExecPlanGlobalConfig() {}

    static ExecPlanGlobalConfig& getInstance()
    {
        static ExecPlanGlobalConfig config;
        return config;
    }

    /* 设置样式表路径 */
    // void setQSSPath(const QString& qssPath);
    /* 获取样式表路径 */
    QString getQSSPath();
    /* 换肤，修改样式表 */
    void setUIStyle(enum_UIStyle style);
    /* 获取当前UI风格 */
    enum_UIStyle getUIStyle() { return m_UIStyle; }

signals:
    /* 样式表改变了 */
    void signal_qssChanged();
    /* OneIten样式表改变了 */
    void signal_oneItemQssChanged(const QString& qssPath);

private:
    QString m_qssPath;                      /* 样式表路径 */
    const QString m_lightQSS = "/white";    /* 亮色样式表路径 */
    const QString m_darkQSS = "/black";     /* 暗色样式表路径 */

    enum_UIStyle m_UIStyle;                 /* 当前UI样式 */
};

#define EPConfig ExecPlanGlobalConfig::getInstance()


#endif /* TRANSMITTERSWITCHINFO_H */