#include "DataMng.h"
#include "pub_utility_api/FileUtil.h"
#include "pub_utility_api/CommonConfigParse.h"
#include "boost/asio/ip/host_name.hpp"

#include <QDomDocument>
#include <QJsonObject>
#include <QJsonDocument>
#include <QByteArray>
#include <QJsonArray>
#include <QFile>
#include <QApplication>
#include <QDebug>
#include <QTextCodec>
#include <QDir>

using namespace sys_startup;
using namespace std;
using namespace iot_public;

DataMng *DataMng::m_pInstance = Q_NULLPTR;

DataMng *DataMng::instance()
{
    if(m_pInstance == Q_NULLPTR)
    {
        m_pInstance = new DataMng();
    }
    return m_pInstance;
}

void DataMng::destory()
{
    if(m_mutex)
    {
        delete m_mutex;
    }
    m_mutex = Q_NULLPTR;
    if(m_mutexApp)
    {
        delete m_mutexApp;
    }
    m_mutexApp = Q_NULLPTR;

    if(m_mutexProc)
    {
        delete m_mutexProc;
    }
    m_mutexProc = Q_NULLPTR;

    m_pInstance = Q_NULLPTR;

    delete this;
}

bool DataMng::loadJson()
{
    QFile loadFile(iot_public::CFileUtil::getPathOfCfgFile("sys_startup.json").c_str());
    if(!loadFile.exists() || !loadFile.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return false;
    }
    QString allData = loadFile.readAll();

    loadFile.close();

    QJsonParseError error;
    QJsonDocument document = QJsonDocument::fromJson(allData.toUtf8(),&error);
    if(error.error != QJsonParseError::NoError)
    {
        qDebug()<<error.errorString();
        return false;
    }
    QJsonObject rootObj = document.object();
    if(!rootObj.contains("buttoninfo"))
    {
        return false;
    }
    QJsonObject buttonObj = rootObj.value("buttoninfo").toObject();
    int buttonCount = buttonObj["count"].toInt();
    for(int index = 0;index<buttonCount;index++)
    {
        QString name = QString("num%1").arg(index);
        if(!buttonObj.contains(name))
        {
            return false;
        }
        QJsonObject button = buttonObj.value(name).toObject();
        SButtonInfo buttonInfo;
        buttonInfo.m_zh = button["zh"].toString();
        buttonInfo.m_en = button["en"].toString();
        buttonInfo.m_cmd = button["cmd"].toString();
        buttonInfo.m_param = button["param"].toString();
        buttonInfo.m_icon = button["icon"].toString();
        buttonInfo.m_enable = button["enable"].toBool();
        buttonInfo.m_name = name;
        m_buttonInfoMap[name] = buttonInfo;
    }
    if(rootObj.contains("page1"))
    {
        QJsonArray page1Array = rootObj.value("page1").toArray();
        for(int index(0);index<page1Array.size();index++)
        {
            m_page1ButtonInfoVec.append(page1Array.at(index).toString());
        }
    }
    if(rootObj.contains("page3"))
    {
        QJsonObject page3Obj = rootObj.value("page3").toObject();
        int groupCount = page3Obj["count"].toInt();

        for(int index(0);index <groupCount;index++)
        {
            QString groupName = QString("group%1").arg(index);
            if(!page3Obj.contains(groupName))
            {
                return false;
            }
            QJsonObject button = page3Obj.value(groupName).toObject();
            SButtonGroup buttonGroup;
            buttonGroup.m_zh = button["zh"].toString();
            buttonGroup.m_en = button["en"].toString();
            buttonGroup.m_groupId = index;

            QJsonArray buttonArray = button["value"].toArray();
            for(int i = 0;i <buttonArray.size();i++)
            {
                buttonGroup.m_buttonVec.append(buttonArray.at(i).toString());
            }
            m_page3ButtonInfoMap[index] = buttonGroup;
        }
    }
    if(rootObj.contains("startpng"))
    {
        m_stStartPng = rootObj["startpng"].toString();
    }
    if(rootObj.contains("stoppng"))
    {
        m_stStopPng = rootObj["stoppng"].toString();
    }
    if(rootObj.contains("startbarbodercolor"))
    {
        m_stStartBorderColor = rootObj["startbarbodercolor"].toString();
    }
    if(rootObj.contains("stopbarbodercolor"))
    {
        m_stStopBorderColor = rootObj["stopbarbodercolor"].toString();
    }
    if(rootObj.contains("startbarwatercolor"))
    {
        m_stStartWaterColor = rootObj["startbarwatercolor"].toString();
    }
    if(rootObj.contains("stopbarwatercolor"))
    {
        m_stStopWaterColor = rootObj["stopbarwatercolor"].toString();
    }
    if(rootObj.contains("sysicon"))
    {
        m_stSysIcon = rootObj["sysicon"].toString();
    }
    if(rootObj.contains("restartpng"))
    {
        m_stRestartPng = rootObj["restartpng"].toString();
    }
    return true;
}

void DataMng::loadVersion()
{
    m_versionMap.clear();
    CCommonConfigParse config;
    config.load(iot_public::CFileUtil::getPathOfCfgFile(VERSIONXMLNAME));
    std::string strValue;
    config.getStringValue(MODULENAME,SOFTWARE_VERSION,strValue);
    m_versionMap.insert(QString::fromStdString(SOFTWARE_VERSION),QString::fromStdString(strValue));
    config.getStringValue(MODULENAME,SOFTWARE_ISMAIN,strValue);
    m_versionMap.insert(QString::fromStdString(SOFTWARE_ISMAIN),QString::fromStdString(strValue));
    config.getStringValue(MODULENAME,SOFTWARE_ISDB,strValue);
    m_versionMap.insert(QString::fromStdString(SOFTWARE_ISDB),QString::fromStdString(strValue));
    config.getStringValue(MODULENAME,SOFTWARE_ISWEB,strValue);
    m_versionMap.insert(QString::fromStdString(SOFTWARE_ISWEB),QString::fromStdString(strValue));
    config.getStringValue(MODULENAME,SOFTWARE_MAINPATH,strValue);
    m_versionMap.insert(QString::fromStdString(SOFTWARE_MAINPATH),QString::fromStdString(strValue));
#ifdef OS_WINDOWS
    config.getStringValue(MODULENAME,SOFTWARE_DBPATH,strValue);
    m_versionMap.insert(QString::fromStdString(SOFTWARE_DBPATH),QString::fromStdString(strValue));
#endif

    config.getStringValue(MODULENAME,SOFTWARE_NAME_EN,strValue);
    m_enTitle = QString::fromStdString(strValue);
    config.getStringValue(MODULENAME,SOFTWARE_NAME_ZH,strValue);
    m_zhTitle = QString::fromStdString(strValue);
    config.getStringValue(MODULENAME,"ProjectName",strValue);
    m_title= QString::fromStdString(strValue);
    config.getStringValue(MODULENAME,"ProjectPng",strValue);
    m_png= QString::fromStdString(strValue);
}

void DataMng::loadLocInfo()
{
    m_locIdDomainOdMap.clear();
    QString filename = "../../data/sys_model_info/SYS_MODEL_LOCATION_INFO.xml";

    QFile file( filename );
    if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
    {
        return ;
    }

    QDomDocument document;
    if(!document.setContent(&file))
    {
        qDebug()<<"error";
        return ;
    }
    QDomElement table = document.documentElement();//返回根节点table
    QDomNode node = table.firstChild();
    while (!node.isNull()) {
        m_locIdDomainOdMap[node.toElement().attribute("LOCATION_ID").toInt()] = node.toElement().attribute("DOMAIN_ID").toInt();
        node = node.nextSibling();
    }
}

void DataMng::loadUsedNode()
{
    m_nodeVec.clear();
    m_nodeLocIdMap.clear();
    QString filename = "../../data/sys_model_info/SYS_MODEL_NODE_INFO.xml";

    QFile file( filename );
    if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
    {
        return ;
    }

    QDomDocument document;
    if(!document.setContent(&file))
    {
        qDebug()<<"error";
        return ;
    }
    QDomElement table = document.documentElement();//返回根节点table
    QDomNode node = table.firstChild();
    while (!node.isNull()) {
        if(node.toElement().hasAttribute("IS_USED"))
        {
            if(node.toElement().attribute("IS_USED").toInt() == 1)
            {
                if ( node.toElement().attribute("NODE_TYPE").toInt() == ENodeType::ENodeType_ApplicationServer ||
                     node.toElement().attribute("NODE_TYPE").toInt() == ENodeType::ENodeType_Workstation )
                {
                    m_nodeVec.append(node.toElement().attribute("NODE_NAME"));
                }
            }
            m_nodeLocIdMap[node.toElement().attribute("NODE_NAME")] = node.toElement().attribute("LOCATION_ID").toInt();
        }
        node = node.nextSibling();
    }
}

void DataMng::loadModelAppInfo()
{
    m_modelAppInfoMap.clear();
    QString filename = "../../data/sys_model_info/SYS_MODEL_APP_INFO.xml";

    QFile file( filename );
    if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
    {
        return ;
    }

    QDomDocument document;
    if(!document.setContent(&file))
    {
        qDebug()<<"error";
        return ;
    }
    QDomElement table = document.documentElement();//返回根节点table
    QDomNode node = table.firstChild();
    while (!node.isNull()) {
        SSysModelAppInfo modelAppInfo;
        modelAppInfo.m_appId = node.toElement().attribute("APP_ID").toInt();
        modelAppInfo.m_tagName = node.toElement().attribute("TAG_NAME").toStdString();   //标签
        modelAppInfo.m_desc = node.toElement().attribute("DESCRIPTION").toStdString(); //描述
        m_modelAppInfoMap[modelAppInfo.m_appId] = modelAppInfo;
        node = node.nextSibling();
    }
}

void DataMng::loadModelDeployInfo()
{
    m_modelDeployInfoMap.clear();
    for( int index(0);index< m_nodeVec.size();index++)
    {
        SApp a;
        a.m_appId = CN_AppId_BASE;
        a.m_appName = m_modelAppInfoMap.value(CN_AppId_BASE).m_tagName;
        a.m_desc = m_modelAppInfoMap.value(CN_AppId_BASE).m_desc;
        a.m_nodeName =m_nodeVec.at(index).toStdString();
        QMap<int ,SApp> appMap;
        appMap[CN_AppId_BASE] = a;
        m_modelDeployInfoMap[m_nodeVec.at(index)] = appMap;
    }

    QString filename = "../../data/sys_model_info/SYS_MODEL_DEPLOY_INFO.xml";

    QFile file( filename );
    if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
    {
        return ;
    }

    QDomDocument document;
    if(!document.setContent(&file))
    {
        qDebug()<<"error";
        return ;
    }
    QDomElement table = document.documentElement();//返回根节点table
    QDomNode node = table.firstChild();
    while (!node.isNull()) {
        int num = node.toElement().attribute("NUM").toInt();
        int app_id = node.toElement().attribute("APP_ID").toInt();
        QString app_desc = QString::fromStdString(m_modelAppInfoMap.value(app_id).m_desc);

        for(int i = 1;i <= num; i++)
        {
            QString nodeName = node.toElement().attribute(QString("NODE%1").arg(i));
            QMap<QString, QMap<int ,SApp> >::iterator it = m_modelDeployInfoMap.find(nodeName);
            if(it!= m_modelDeployInfoMap.end())
            {
                QMap<int ,SApp> &info = it.value();
                SApp a;
                a.m_appId = app_id;
                a.m_appName = m_modelAppInfoMap.value(app_id).m_tagName;
                a.m_desc = app_desc.toStdString();
                a.m_nodeName =node.toElement().attribute(QString("NODE%1").arg(i)).toStdString();
                if(nodeIsUsed(a.m_nodeName))
                {
                    info[a.m_appId] = a;
                }
            }else
            {
                QMap<int ,SApp> info;
                SApp a;
                a.m_appId = app_id;
                a.m_appName = m_modelAppInfoMap.value(app_id).m_tagName;
                a.m_desc = app_desc.toStdString();
                a.m_nodeName =node.toElement().attribute(QString("NODE%1").arg(i)).toStdString();
                if(nodeIsUsed(a.m_nodeName))
                {
                    info[a.m_appId] = a;
                    m_modelDeployInfoMap[nodeName] = info;
                }
            }
        }
        node = node.nextSibling();
    }
}

bool DataMng::nodeIsUsed(const std::string &nodeName)
{
    bool res = false;
    for(int index(0);index<m_nodeVec.size();index++)
    {
        if(nodeName == m_nodeVec.at(index).toStdString())
        {
            res = true;
        }
    }
    return res;
}

void DataMng::loadXml()
{
    loadLocInfo();
    loadUsedNode();
    loadModelAppInfo();
    loadModelDeployInfo();
    loadLocalProcInfo();
}

int DataMng::getLocalProcNum()
{
    return m_nLocalProcNum;
}

QMap<QString, QString> DataMng::getVersionInfo()
{
    return m_versionMap;
}

QString DataMng::getZhTitle()
{
    return m_zhTitle;
}

QString DataMng::getEnTitle()
{
    return m_enTitle;
}

void DataMng::loadLocalProcInfo()
{
    QList<int > localAppIdList;
    localAppIdList.clear();
    m_sysRunProcInfoVec.clear();
    m_modelProcInfoVec.clear();
    QMap<QString,QMap<int,SApp> >::iterator it = m_modelDeployInfoMap.find(getHostName());
    if(it != m_modelDeployInfoMap.end())
    {
        localAppIdList.append(it.value().keys());
    }
    QString filename = "../../data/sys_model_info/SYS_MODEL_PROCESS_INFO.xml";

    QFile file( filename );
    if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
    {
        return ;
    }

    QDomDocument document;
    if(!document.setContent(&file))
    {
        qDebug()<<"error";
        return ;
    }
    QDomElement table = document.documentElement();//返回根节点table
    QDomNode node = table.firstChild();
    while (!(node.isNull())) {
        int app_id = node.toElement().attribute("APP_ID").toInt();
        if(node.toElement().attribute("NOT_USED").toInt() == 1)
        {
            node = node.nextSibling();
            continue;
        }
        if(localAppIdList.contains(app_id))
        {
            SProcess proc;
            proc.m_appId = app_id;
            proc.m_appDesc = m_modelAppInfoMap.value(app_id).m_desc;
            proc.m_nodeName = getHostName().toStdString();
            proc.m_procName = node.toElement().attribute("PROC_NAME").toStdString();
            proc.m_procDesc = node.toElement().attribute("DESCRIPTION").toStdString();

            m_sysRunProcInfoVec.push_back(proc);
            m_modelProcInfoVec.push_back(proc);
        }
        node = node.nextSibling();
    }
    m_nLocalProcNum = (int)m_sysRunProcInfoVec.size();
    LOGINFO("本机一共需要启动%d个进程.",m_nLocalProcNum);
}

QVector<QString> DataMng::getPage1ButtonInfo()
{
    return m_page1ButtonInfoVec;
}
QString DataMng::getTitle()
{
    return m_title;
}
QString DataMng::getPng()
{
    return m_png;
}

QMap<int,sys_startup::SButtonGroup> DataMng::getPage3ButtonInfo()
{
    return m_page3ButtonInfoMap;
}

bool DataMng::getButtonInfoByName(const QString &name, SButtonInfo &buttonInfo)
{
    QMap<QString,sys_startup::SButtonInfo>::iterator it = m_buttonInfoMap.find(name);
    if(it != m_buttonInfoMap.end())
    {
        buttonInfo = it.value();
        return true;
    }else
    {
        return false;
    }
}

QString DataMng::getStartPng()
{
    return m_stStartPng;
}

QString DataMng::getStopPng()
{
    return m_stStopPng;
}

QString DataMng::getStartBorderColor()
{
    return m_stStartBorderColor;
}

QString DataMng::getStopBorderColor()
{
    return m_stStopBorderColor;
}

QString DataMng::getStartWaterColor()
{
    return m_stStartWaterColor;
}

QString DataMng::getStopWaterColor()
{
    return m_stStopWaterColor;
}

QString DataMng::getSysIcon()
{
    return m_stSysIcon;
}

QString DataMng::getRestartPng()
{
    return m_stRestartPng;
}

void DataMng::setBaseStatus(bool runStatus)
{
    QMutexLocker lock(m_mutex);
    m_bBaseIsRun = runStatus;
}

bool DataMng::getBaseStatus()
{
    QMutexLocker lock(m_mutex);
    return m_bBaseIsRun;
}

QString DataMng::getHostName()
{
    return QString::fromStdString(boost::asio::ip::host_name());
}

bool DataMng::getSysStatus()
{
    QMutexLocker lock(m_mutex);
    return m_bSysIsRun;
}

void DataMng::setSysStatus(bool runStatus)
{
    QMutexLocker lock(m_mutex);
    m_bSysIsRun = runStatus;
}

bool DataMng::getAllowedStatus()
{
    QMutexLocker lock(m_mutex);
    return m_bIsAllowedOpt;
}

void DataMng::setAllowedStatus(bool allowed)
{
    QMutexLocker lock(m_mutex);
    m_bIsAllowedOpt = allowed;
}

SSysModelAppInfo DataMng::getModelAppInfoById(int appId)
{
    SSysModelAppInfo appInfo;
    return m_modelAppInfoMap.value(appId,appInfo);
}

QMap<QString, QMap<int, SApp> > DataMng::getDeployInfo()
{
    return m_modelDeployInfoMap;
}

std::vector<SProcess> DataMng::getProcInfo()
{
    return m_modelProcInfoVec;
}

void DataMng::setRunAppInfo(const vector<SApp> &runAppVec)
{
    QMutexLocker lock(m_mutexApp);
    m_sysRunAppInfoVec = runAppVec;
}

vector<SApp> DataMng::getRunAppInfo()
{
    QMutexLocker lock(m_mutexApp);
    return m_sysRunAppInfoVec;
}

void DataMng::setRunProcInfo(const std::vector<SProcess> &runProcVec,const float &disk)
{
    QMutexLocker lock(m_mutexProc);
    m_sysRunProcInfoVec = runProcVec;
    m_fDisk = disk;
}

void DataMng::getRunProcInfo(std::vector<SProcess> &procVec, float &disk)
{
    QMutexLocker lock(m_mutexProc);
    procVec = m_sysRunProcInfoVec;
    disk = m_fDisk;
}

int DataMng::getDomainId()
{
    return m_locIdDomainOdMap.value(m_nodeLocIdMap.value(getHostName(),1),1);
}

std::vector<SApp> DataMng::getInitAppInfoVec()
{
    std::vector<sys_startup::SApp> initAppInfoVec;
    QMap<QString,QMap<int ,sys_startup::SApp> >::iterator it = m_modelDeployInfoMap.begin();
    while (it != m_modelDeployInfoMap.end()) {
        QMap<int ,sys_startup::SApp> appMap = it.value();
        QMap<int ,sys_startup::SApp>::iterator pos = appMap.begin();
        while (pos != appMap.end()) {
            initAppInfoVec.push_back(pos.value());
            pos++;
        }
        it++;
    }
    return initAppInfoVec;
}

std::vector<SProcess> DataMng::getInitProcInfoVec()
{
    return m_modelProcInfoVec;
}

std::string DataMng::getAppDescByAppId(int appId)
{
    return m_modelAppInfoMap.value(appId).m_desc;
}

string DataMng::getAppNameByAppId(int appId)
{
    return m_modelAppInfoMap.value(appId).m_tagName;
}

std::string DataMng::getProcDescByAppIdAndProcName(int appId, const std::string &procName)
{
    for(int index(0);index<(int)m_modelProcInfoVec.size();index++)
    {
        if(m_modelProcInfoVec[index].m_appId == appId && m_modelProcInfoVec[index].m_procName == procName)
        {
            return m_modelProcInfoVec[index].m_procDesc;
        }
    }
    return "";
}

DataMng::DataMng():
    m_mutex(Q_NULLPTR),
    m_mutexApp(Q_NULLPTR),
    m_mutexProc(Q_NULLPTR)
{
    loadJson();
    loadXml();
    loadVersion();
    m_bBaseIsRun = false;
    m_bSysIsRun = false;
    m_bIsAllowedOpt = true;
    m_mutex = new QMutex;
    m_mutexApp = new QMutex;
    m_mutexProc = new QMutex;
    m_fDisk = 0.0;
}