#ifndef GLOBALCONFIG_H
#define GLOBALCONFIG_H

#include <QString>
#include <QReadWriteLock>
#include <map>

#define GVariable GlobalVariable::getInstance()

/**
 * @brief 全局应用使用到的变量
 * 
 */
class GlobalVariable
{
    friend class GlobalConfig;

    GlobalVariable();
    GlobalVariable(const GlobalVariable& other) = delete;
    GlobalVariable& operator=(const GlobalVariable& other) = delete;

public:
    ~GlobalVariable() {}
    static GlobalVariable& getInstance()
    {
        static GlobalVariable gv;
        return gv;
    }

    int AppUpdateOnWorkTimeInterval_Time;   /* 更新在岗信息的时间间隔 */
    int AppPeopleOnWork_Time;               /* 离岗时间 */
    int AppContraband_Time;                 /* 违禁物品出现的时间 */
    int AppBadMan_Time;                     /* 非法入侵超时时间 */
    int AppTired_Time;                      /* 疲劳检测时间 */
    int AppPeopleCont;                      /* 区域人员统计 */
    int AppPlayPhone;                       /* 玩手机识别 */
    int AppMouse;                           /* 老鼠识别 */
    int AppMask;                            /* 戴口罩识别 */

    int CheckSet;                           /* 服务端多久检测一次配置 */
    int EventTimeValid;                     /* 事件时间有效期 */

    int ThreadSleepMS;                      /* 任务线程休眠时间，单位是ms */
    const int CheckDeviceTime = 20;         /* 从超脑平台检测设备的时间间隔，单位是秒 */

    /* 算法ID，通过这个识别从超脑平台获取到的算法，这个算法ID是全的，带有后缀的 */
    /* 人脸识别算法ID */
    std::string ActFaceIdentify;
    /* 人员统计算法ID */
    std::string ActPersonCount;
    /* 违禁品算法ID */
    std::string ActContraband;
    /* 玩手机算法ID */
    std::string ActPlayPhone;
    /* 疲劳检测算法ID */
    std::string ActFatigueDetection;
    /* 睡岗识别算法ID */
    std::string ActSleep;
    /* 老鼠检测 */
    std::string ActMouseDetect;
    /* 未戴口罩识别 */
    std::string ActNoMask;
    /* 摔倒识别 */
    std::string ActAllDown;
    /* 动物识别 */
    std::string ActAnimalDetect;

    QReadWriteLock mutexRW;               /* 读写锁 */
    

    std::string getActionName(const std::string& actionID);
    /* 设置算法名称和算法ID对应关系，没有算法不会添加 */
    void setActionName(const std::map<std::string, std::string>& mapAction);
    /* 通过不带后缀的算法ID获取完整的算法ID，后缀通过“-”连接 */
    std::string getFullActionID(const std::string& actionID);
    

private:
    std::map<std::string, std::string> m_mapAction;     /* 算法ID和算法名称的对应关系，算法ID是完整的ID */

};




/* ====================================================================================
 * *****************************    GlobalConfig   ***********************************
 * ====================================================================================*/


#define GConfig GlobalConfig::getInstance()
/**
 * @brief 配置文件信息
 * 
 */
 class GlobalConfig
 {

    GlobalConfig();
    ~GlobalConfig() = default;
    GlobalConfig(const GlobalConfig& other) = delete;
    GlobalConfig& operator=(const GlobalConfig& other) = delete;

public:
    static GlobalConfig& getInstance()
    {
        static GlobalConfig gc;
        return gc;
    }

    /* 初始化服务 */
    void initService();

    /* 读取基础配置文件 */
    bool readBaseConfig(const QString& strConfigFile);
    /* 打印基础配置文件 */
    void printBaseConfig();

    /* 读取算法配置文件 */
    bool readAlgorithmConfig(const QString& strConfigFile);
    /* 打印算法配置文件 */
    void printAlgorithmConfig();
    
    /* 读取应用配置文件 */
    bool readAppConfig(const QString& strConfigFile);
    /* 打印读取到的值 */
    void printAppConfig();

    /* 获取webapi信息 */
    QString webapiUrl() { return m_webAPIUrl; }
    QString webapiKey() { return m_webAPIKey; }
    QString webapiAppType() { return m_webAPIAppType; }
    /* 获取Redis信息 */
    std::string redisIP() { return m_redisIP; }
    int redisPort() { return m_redisPort; }
    std::string redisPWD() { return m_redisPWD; }
    /* 获取超脑信息 */
    std::string superBrainUrl() { return m_superBrainUrl; }
    std::string superBrainAppKey() { return m_superBrainAppKey; }
    std::string superBrainAppSecret() { return m_superBrainAppSecret; }

    

public:
    /* 添加通道信息 */
    void setChannelInfo(std::map<int, std::string> mapChannelName);
    /* 清空通道信息 */
    void clearChannelInfo();
    /* 获取通道名称 */
    std::string getChannelName(int ChannelID);
    /* 获取通道信息 */
    std::map<int, std::string> getChannelInfoMap();

    /* 添加摄像机信息 */
    void setCameraInfo(std::map<int, std::string> mapCameraName);
    /* 获取摄像机名称 */
    std::string getCameraName(int CameraID);
    /* 获取摄像机信息列表 */
    std::map<int, std::string> getCameraInfoMap() { return m_mapCameraName; }

private:
    QReadWriteLock m_rwLockChnInfo;                     /* 读写锁 */
    std::map<int, std::string> m_mapChannelName;        /* 通道名称 */
    /* 摄像机名称 */
    QReadWriteLock m_rwLockCamInfo;                     /* 读写锁 */
    std::map<int, std::string> m_mapCameraName;         /* 摄像机名称 */

    QString m_webAPIUrl;                                /* WebAPI的URL */
    QString m_webAPIKey;                                /* WebAPI的Key */
    const QString m_webAPIAppType = "SPSS";             /* WebAPI的Secret */

    std::string m_redisIP;                              /* Redis的IP */
    int m_redisPort;                                    /* Redis的端口 */
    std::string m_redisPWD;                             /* Redis的密码 */

    std::string m_superBrainUrl;                          /* 超脑的URL */
    std::string m_superBrainAppKey;                       /* 超脑的AppKey */
    std::string m_superBrainAppSecret;                    /* 超脑的AppSecret */
 };





#endif /* GLOBALCONFIG_H */