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, "衢州台发射机"}
};

enum class enum_OnOff : int
{
    Off = 0,                    /* 关机 */
    On = 1                      /* 开机 */
};

const QMap<int, QString> g_ActionName
{
    {static_cast<int>(enum_OnOff::On), "开机"},
    {static_cast<int>(enum_OnOff::Off), "关机"}
};


/* 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 tExecPlanConfig表格的关键字
 * 
 */
enum class enum_ExecPlanConfig : int
{
    OpenPlan = 1,               /* 执行计划 */
    ExecMode = 2,               /* 执行模式 */
    IsChanged = 3               /* 是否修改 */
};

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

 /**
  * @brief 周几枚举
  * 
  */
enum class enum_WeekDay : int
{
    WeekDay_Mon = 1,               /* 周一 */
    WeekDay_Tue = 2,               /* 周二 */
    WeekDay_Wed = 3,               /* 周三 */
    WeekDay_Thu = 4,               /* 周四 */
    WeekDay_Fri = 5,               /* 周五 */
    WeekDay_Sat = 6,               /* 周六 */
    WeekDay_Sun = 7,               /* 周日 */
    WeekDay_Special = 8            /* 特殊日 */
};

/**
 * @brief 用户权限枚举
 * 
 */
enum class eUserPermission : int
{
    User_Administrator = 0,         /* 管理员 */
    User_Normal = 1,                /* 普通用户 */
};

/**
 * @brief WebAPI初始化数据
 * 
 */
struct InitData
{
    int userPermission = 0;     /* 用户权限，0管理员，1普通用户 */
    QString url;                /* WebAPI地址 */
    QString serverID;           /* 服务器ID */
    QString serverKey;          /* 服务器Key */
    InitData& operator=(const InitData& data)
    {
        userPermission = data.userPermission;
        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::OpenPlan), "默认执行计划开关，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 OnePlanItemInfo
{
    int ChannelID;                                  /* 频率ID */
    QString ChannelName;                            /* 频率名称 */
    enum_WeekDay onWeekDay;                         /* 周几，数据库里是1-7一周，周8是特殊日 */
    QDateTime onDateTime;                           /* 时间和日期 */
    enum_WeekDay offWeekDay;                        /* 周几，数据库里是1-7一周，周8是特殊日 */
    QDateTime offDateTime;                          /* 时间和日期 */

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


/**
 * @brief 频率信息
 * 
 */
struct ChannelInfo
{
    int ChannelID = -1;                         /* 通道ID */
    QString ChannelName;                        /* 通道名称 */

    ChannelInfo() {}
    ChannelInfo(const ChannelInfo& channel);
    ChannelInfo& operator=(const ChannelInfo& channel);
};

#define ChnContainer MapChannel::getInstance()
class MapChannel
{
    MapChannel() {}
    MapChannel(const MapChannel& channel) = delete;
    MapChannel& operator=(const MapChannel& channel) = delete;
public:
    ~MapChannel() {}

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

    /* 添加一个频率 */
    void addChannel(const ChannelInfo& channelInfo);
    /* 获取一个频率 */
    ChannelInfo getChannel(int channelID);
    /* 获取容器 */
    QMap<int, ChannelInfo>& getMapChannel() { return m_mapChannel; }
    /* 删除除了设置频率外的其他频率信息 */
    void deleteOtherChannel(int channelID);
    /* 清空所有的频率 */
    void clearAllChannel() { m_mapChannel.clear(); }
    
private:
    QMap<int, ChannelInfo> m_mapChannel;          /* 频率信息，key是通道ID */
};

/**
 * @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 */
};


#define DevTypeContainer MapDevType::getInstance()
/**
 * @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 */

};





/**
 * @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 */
};

#define DeviceContainer MapDevice::getInstance()
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是设备名称 */

};



/**
 * @brief 模版结构体
 * 
 */
struct OneTemplateInfo
{
    ChannelInfo channelInfo;                /* 频率信息 */
    QString templateName;                   /* 模版名称 */

    OneTemplateInfo() : channelInfo(), templateName("") {}
    OneTemplateInfo(const OneTemplateInfo& info);
    OneTemplateInfo& operator=(const OneTemplateInfo& info);
    bool operator<(const OneTemplateInfo& info) const;
    bool operator==(const OneTemplateInfo& info) const;
};



/**
 * @brief 用于传输执行计划相关的信息
 * 
 */
struct ExecPlanInfo
{
    int ChannelID = -1;                     /* 频率ID */
    QString ChannelName;                    /* 频率名称 */
    QString DatabasePath;                   /* 数据库路径 */

    ExecPlanInfo& operator=(const ExecPlanInfo& info)
    {
        ChannelID = info.ChannelID;
        ChannelName = info.ChannelName;
        DatabasePath = info.DatabasePath;

        return *this;
    }
};

/**
 * @brief 页面的其他配置信息
 * 
 */
struct ExecPlanConfig
{
    int isUsingPlan;                /* 是否使用执行计划，0不使用，1使用 */
    int execMdoe;                   /* 执行模式，0按时刻，1按天 */
};




/**
 * @brief 全局信息，主要是一些全局标志位
 * 
 */
#define GInfo GlobalInfo::getInstance()

class GlobalInfo
{
private:
    GlobalInfo();
    GlobalInfo(const GlobalInfo& info) = delete;
    GlobalInfo& operator=(const GlobalInfo& info) = delete;
public:
    static GlobalInfo& getInstance()
    {
        static GlobalInfo instance;
        return instance;
    }
    ~GlobalInfo() {}

    /* 设置单频率模式 */
    void setOneFrequency(bool oneFrequency) { m_oneFrequency = oneFrequency; }
    /* 获取单频率模式 */
    bool isOneFrequency() const { return m_oneFrequency; }
    
    /* 设置是否使用在线数据库 */
    void setOnlineDB(bool isOnlineDB) { m_isOnlineDB = isOnlineDB; }
    /* 获取是否使用在线数据库 */
    bool isOnlineDB() const { return m_isOnlineDB; }

    /* 设置频率信息 */
    void setChannelInfo(const ChannelInfo& channel) { channelInfo = channel; }
    /* 获取频率信息 */
    ChannelInfo getChannelInfo() const { return channelInfo; }
    /* 设置数据库路径 */
    void setDatabasePath(const QString& path) { DatabasePath = path; }
    /* 获取数据库路径 */
    QString getDatabasePath() const { return DatabasePath; }

    /* 设置权限 */
    void setUserPermission(eUserPermission permission) { m_userPermission = permission; }
    /* 获取权限 */
    eUserPermission getUserPermission() const { return m_userPermission; }

private:
    bool m_oneFrequency = false;            /* 单频率模式 */
    bool m_isOnlineDB = true;               /* 是否在线数据库 */

    eUserPermission m_userPermission = eUserPermission::User_Administrator; /* 用户权限，默认普通用户 */

    ChannelInfo channelInfo;                /* 频率信息 */
    QString DatabasePath;                   /* 数据库路径 */
};




#endif /* TRANSMITTERSWITCHINFO_H */