#include "GlobalConfig.h"
#include <QSettings>
#include <QCoreApplication>

#include "spdlog/spdlog.h"
#include "LHLogInit.h"

#include "GlobalVariable.h"


GlobalVariable::GlobalVariable()
{
    m_threadSleepMS = 1000;

    m_actFaceIdentify.clear();
    m_actPersonCount.clear();
    m_actContraband.clear();
    m_actPlayPhone.clear();
    m_actFatigueDetection.clear();
    m_actSleep.clear();
    m_actMouseDetect.clear();
    m_actNoMask.clear();
    m_actAllDown.clear();
    m_actAnimalDetect.clear();
    m_mapAction.clear();
    
}

std::string GlobalVariable::getActionName(const std::string& actionID) 
{
    std::string actionName;
    mutexRW.lockForRead();
    auto it = m_mapAction.find(actionID);
    if(it != m_mapAction.end()) {
        actionName = it->second;
    }
    mutexRW.unlock();
    return actionName;
}

/* 设置算法名称和算法ID对应关系，没有算法不会添加 */
void GlobalVariable::setActionName(const std::map<std::string, std::string>& mapAction)
{
    mutexRW.lockForWrite();
    for(const auto& it : m_mapAction)
    {
        auto it0 = mapAction.find(it.first);
        if(it0 != mapAction.end())
        {
            m_mapAction[it.second] = it0->second;
        }
    }
    mutexRW.unlock();
}

/* 通过不带后缀的算法ID获取完整的算法ID，后缀通过“-”连接 */
// std::string GlobalVariable::getFullActionID(const std::string& actionID)
// {
//     std::string fullActionID;
//     for(const auto& it : m_mapAction)
//     {
//         /* 去掉“-”以及后面的字符串 */
//         auto tmpStr = it.first;
//         auto pos = tmpStr.find("-");
//         if(pos != std::string::npos)
//         {
//             tmpStr = tmpStr.substr(0, pos);
//         }
//         if(tmpStr == actionID)
//         {
//             fullActionID = it.first;
//             break;
//         }
//     }
//     return fullActionID;
// }

/* ====================================================================================
 * **************************    GlobalConfig成员函数    ******************************
 * ====================================================================================*/



GlobalConfig::GlobalConfig()
{
    
}


/* 初始化服务 */
void GlobalConfig::initService()
{
    /* 读取基础配置文件 */
    QString strBaseConfig = QCoreApplication::applicationDirPath() + "/config/BaseConfig.ini";
    if(!GConfig.readBaseConfig(strBaseConfig))
    {
        /* 读取配置文件失败，直接退出程序 */
        SPDLOG_ERROR("读取配置文件失败! 退出程序，{}", strBaseConfig.toStdString());
        exit(-1);
    }
    printBaseConfig();

    /* 读取算法配置 */
    QString strAlgorithmConfig = QCoreApplication::applicationDirPath() + "/config/Actions.ini";
    if(!GConfig.readAlgorithmConfig(strAlgorithmConfig))
    {
        /* 读取配置文件失败，直接退出程序 */
        SPDLOG_ERROR("读取配置文件失败! 退出程序，{}", strAlgorithmConfig.toStdString());
        exit(-1);
    }
    printAlgorithmConfig();

    /* 读取应用配置文件 */
    QString strAppConfig = QCoreApplication::applicationDirPath() + "/config/AppConfig.ini";
    if(!GConfig.readAppConfig(strAppConfig))
    {
        /* 读取配置文件失败，直接退出程序 */
        SPDLOG_ERROR("读取配置文件失败! 退出程序，{}", strAppConfig.toStdString());
        exit(-1);
    }
    printAppConfig();

    /* 设置日志输出级别 */
    if(GVariable.m_logDetail == 0)
    {
        changeLogLevel(ELogLevel::Log_Info);
    }
    else if(GVariable.m_logDetail == 1)
    {
        changeLogLevel(ELogLevel::Log_Debug);
    }

    SPDLOG_INFO("========================================================");
}

/* 读取基础配置文件 */
bool GlobalConfig::readBaseConfig(const QString& strConfigFile)
{
    if(strConfigFile.isEmpty())
    {
        SPDLOG_ERROR("读取配置文件失败! 配置文件名为空");
        return false;
    }
    SPDLOG_DEBUG("读取配置文件: {}", strConfigFile.toStdString());
    QSettings settings(strConfigFile, QSettings::IniFormat);
    settings.setIniCodec("UTF-8");

    /* 读取WebAPI配置 */
    settings.beginGroup("WebAPI");
    m_webAPIUrl = settings.value("ServerURL", "").toString();
    m_webAPIKey = settings.value("ServerKey", "").toString();
    settings.endGroup();

    /* 读取Redis配置 */
    settings.beginGroup("Redis");
    m_redisIP = settings.value("URL", "").toString().toStdString();
    m_redisPort = settings.value("Port", 0).toInt();
    m_redisPWD = settings.value("Password", "").toString().toStdString();
    settings.endGroup();

    /* 读取SuperBrain配置 */
    settings.beginGroup("SuperBrain");
    m_superBrainUrl = settings.value("URL", "").toString().toStdString();
    m_superBrainAppKey = settings.value("AppKey", "").toString().toStdString();
    m_superBrainAppSecret = settings.value("AppSecret", "").toString().toStdString();
    settings.endGroup();

    /* 读取Docker相关的配置 */
    settings.beginGroup("Docker");
    m_listenPort = settings.value("TcpListenPort", 0).toInt();
    settings.endGroup();

    return true;
}

/* 打印基础配置文件 */
void GlobalConfig::printBaseConfig()
{
    SPDLOG_INFO("========================================================");
    SPDLOG_INFO("WebAPI URL:            {}", m_webAPIUrl.toStdString());
    SPDLOG_INFO("WebAPI Key:            {}", m_webAPIKey.toStdString());
    SPDLOG_INFO("--------------------------------------------------------");
    SPDLOG_INFO("Redis IP:              {}", m_redisIP);
    SPDLOG_DEBUG("Redis Port:           {}", m_redisPort);
    SPDLOG_TRACE("Redis Password:       {}", m_redisPWD);
    SPDLOG_INFO("--------------------------------------------------------");
    SPDLOG_INFO("SuperBrain URL:        {}", m_superBrainUrl);
    SPDLOG_TRACE("SuperBrain AppKey:    {}", m_superBrainAppKey);
    SPDLOG_TRACE("SuperBrain AppSecret: {}", m_superBrainAppSecret);
    SPDLOG_INFO("--------------------------------------------------------");
    SPDLOG_INFO("TCP Listen Port:       {}", m_listenPort);
}


/* 读取算法配置文件 */
bool GlobalConfig::readAlgorithmConfig(const QString& strConfigFile)
{
    if(strConfigFile.isEmpty())
    {
        SPDLOG_ERROR("读取配置文件失败! 配置文件名为空");
        return false;
    }
    // SPDLOG_DEBUG("读取配置文件: {}", strConfigFile.toStdString());
    QSettings settings(strConfigFile, QSettings::IniFormat);
    settings.setIniCodec("UTF-8");

    settings.beginGroup("Actions");
    GVariable.m_actFaceIdentify = settings.value("FaceIdentify", "").toString().toStdString();      /* 人脸识别算法ID */
    GVariable.m_actPersonCount = settings.value("PersonCount", "").toString().toStdString();        /* 人员计数算法ID */
    GVariable.m_actPlayPhone = settings.value("PlayPhone", "").toString().toStdString();            /* 玩手机算法ID */
    GVariable.m_actContraband = settings.value("Contraband", "").toString().toStdString();          /* 违禁品算法ID */
    settings.endGroup();

    GVariable.m_mapAction.insert(std::make_pair(GVariable.m_actFaceIdentify, "人脸识别"));
    GVariable.m_mapAction.insert(std::make_pair(GVariable.m_actPersonCount, "人员计数"));
    GVariable.m_mapAction.insert(std::make_pair(GVariable.m_actPlayPhone, "玩手机识别"));
    GVariable.m_mapAction.insert(std::make_pair(GVariable.m_actContraband, "违禁品检测"));

    return true;
}

/* 打印算法配置文件 */
void GlobalConfig::printAlgorithmConfig()
{
    SPDLOG_INFO("========================================================");
    SPDLOG_INFO("人脸识别算法ID:       {}", GVariable.ActFaceIdentify());
    SPDLOG_INFO("人员计数算法ID:       {}", GVariable.ActPersonCount());
    SPDLOG_INFO("玩手机算法ID:         {}", GVariable.ActPlayPhone());
    SPDLOG_INFO("违禁品算法ID:         {}", GVariable.ActContraband());
}


/* 读取配置文件 */
bool GlobalConfig::readAppConfig(const QString& strConfigFile)
{
    if(strConfigFile.isEmpty())
    {
        SPDLOG_ERROR("读取配置文件失败! 配置文件名为空");
        return false;
    }
    // SPDLOG_DEBUG("读取配置文件: {}", strConfigFile.toStdString());
    QSettings settings(strConfigFile, QSettings::IniFormat);
    settings.setIniCodec("UTF-8");

    settings.beginGroup("System");
    GVariable.m_threadSleepMS = settings.value("FuncThreadSleep", 1000).toInt();        /* 任务线程休眠时间，单位是ms */
    GVariable.CheckAppSet = settings.value("CkeckAppSetTime", 300).toInt();             /* 服务端多久检测一次配置 */
    GVariable.m_logDetail = settings.value("LogDetail", 0).toInt();                     /* 详细日志级别，打印Debug日志，0表示不打印，1表示打印 */

    settings.endGroup();

    settings.beginGroup("AppConfig");

    GVariable.AppUpdateOnWorkTimeInterval_Time = settings.value("UpdateWorkOnInfoSecond", 600).toInt();  /* 更新在岗信息的时间间隔 */
    GVariable.AppLeaveOnWork_Time = settings.value("AppleLeaveWorkTime", 300).toInt();              /* 离岗报警时间 */
    GVariable.AppContraband_Time = settings.value("AppContrabandTime", 50).toInt();                 /* 违禁物品出现的时间 */
    GVariable.AppIllInvasion_Time = settings.value("AppIllegalInvasion", 50).toInt();               /* 非法入侵 */
    GVariable.AppTired_Time = settings.value("AppTired", 50).toInt();                               /* 疲劳检测时间 */
    GVariable.AppPeopleCount_LessTime = settings.value("AppPeopleCount", 50).toInt();               /* 人员聚集时间 */
    GVariable.AppPlayPhone = settings.value("AppPlayPhone", 50).toInt();                            /* 玩手机识别 */
    GVariable.AppMouse = settings.value("AppMouse", 50).toInt();                                    /* 手势识别 */
    GVariable.AppMask = settings.value("AppNoMask", 5).toInt();                                     /* 戴口罩识别 */

    GVariable.EventTimeValid = settings.value("EventTimeValid", 300).toInt();                       /* 检测事件时间有效期 */

    settings.endGroup();

    return true;
}


/* 打印读取到的值 */
void GlobalConfig::printAppConfig()
{
    SPDLOG_INFO("========================================================");
    SPDLOG_INFO("AppUpdateOnWorkTimeInterval:   {}", GVariable.AppUpdateOnWorkTimeInterval_Time);
    SPDLOG_INFO("AppleLeaveWorkTime:            {}", GVariable.AppLeaveOnWork_Time);
    SPDLOG_INFO("AppContrabandTime:             {}", GVariable.AppContraband_Time);
    SPDLOG_INFO("AppIllegalInvasion:            {}", GVariable.AppIllInvasion_Time);
    SPDLOG_INFO("AppTired:                      {}", GVariable.AppTired_Time);
    SPDLOG_INFO("AppPeopleCount:                {}", GVariable.AppPeopleCount_LessTime);
    SPDLOG_INFO("AppPlayPhone:                  {}", GVariable.AppPlayPhone);
    SPDLOG_INFO("AppMouse:                      {}", GVariable.AppMouse);
    SPDLOG_INFO("AppNoMask:                     {}", GVariable.AppMask);
    SPDLOG_INFO("EventTimeValid:                {}", GVariable.EventTimeValid);
    SPDLOG_INFO("---------------------------------------------------------");
    SPDLOG_INFO("CkeckAppSetTime:               {}", GVariable.CheckAppSet);
    SPDLOG_INFO("FuncThreadSleep:               {}", GVariable.ThreadSleepMS());
    SPDLOG_INFO("LogDetail:                     {}", GVariable.m_logDetail);
}

/* 添加通道信息 */
void GlobalConfig::setChannelInfo(std::map<int, std::string> mapChannelName)
{
    m_rwLockChnInfo.lockForWrite();
    m_mapChannelName.clear();
    m_mapChannelName = mapChannelName;
    m_rwLockChnInfo.unlock();
}

/* 清空通道信息 */
void GlobalConfig::clearChannelInfo()
{
    m_rwLockChnInfo.lockForWrite();
    m_mapChannelName.clear();
    m_rwLockChnInfo.unlock();
}

/* 获取通道名称 */
std::string GlobalConfig::getChannelName(int ChannelID)
{
    m_rwLockChnInfo.lockForRead();
    std::string strName = "";
    auto it = m_mapChannelName.find(ChannelID);
    if(it != m_mapChannelName.end())
    {
        strName = it->second;
    }
    m_rwLockChnInfo.unlock();
    return strName;
}

/* 添加摄像机信息 */
void GlobalConfig::setCameraInfo(std::map<int, std::string> mapCameraName)
{
    m_rwLockCamInfo.lockForWrite();
    m_mapCameraName.clear();
    m_mapCameraName = mapCameraName;
    m_rwLockCamInfo.unlock();
}
/* 获取摄像机名称 */
std::string GlobalConfig::getCameraName(int CameraID)
{
    m_rwLockCamInfo.lockForRead();
    std::string strName = "";
    auto it = m_mapCameraName.find(CameraID);
    if(it != m_mapCameraName.end())
    {
        strName = it->second;
    }
    m_rwLockCamInfo.unlock();
    return strName;
}