#include "AlarmMng.h"
#include "public/pub_sysinfo_api/SysInfoApi.h"
#include "pub_utility_api/CharUtil.h"
#include "perm_mng_api/PermMngApi.h"
#include "pub_logger_api/logger.h"
#include <QMutexLocker>
#include <QSqlQuery>

using namespace iot_dbms;
using namespace iot_public;
using namespace std;

AlarmMng *AlarmMng::pInstance = NULL;
AlarmMng *AlarmMng::instance()
{
    if(pInstance == NULL)
    {
        pInstance = new AlarmMng();
        qRegisterMetaType<QStringList>("QStringList");
    }
    return pInstance;
}

void AlarmMng::destory()
{
    if(m_rtdbAccess != NULL)
    {
        delete m_rtdbAccess;
    }
    m_rtdbAccess = NULL;

    m_locMap.clear();
    m_locOrder.clear();
    m_devgMap.clear();
    m_devMap.clear();
    m_devTreeInfo.clear();

    if(m_pReadDb)
    {
        delete m_pReadDb;
    }
    m_pReadDb = NULL;
    pInstance = NULL;
    delete this;
}

QMap<QString, QString> AlarmMng::getDevTpType()
{
    QMutexLocker locker(mutex);
    return m_devTpTypeMap;
}

QMap<int, QMap<QString, QList<QString> > > AlarmMng::getDevTreeInfo()
{
    QMutexLocker locker(mutex);
    return m_devTreeInfo;
}

QMap<int, QList<QString> > AlarmMng::getDevGroupTreeInfo()
{
    QMutexLocker locker(mutex);
    return m_devgTreeInfo;
}

QList<QString> AlarmMng::getDevGroupInfo(int locId)
{
    QMutexLocker locker(mutex);
    return m_devgTreeInfo.value(locId);
}

QString AlarmMng::getLocDescById(int locId)
{
    LOGDEBUG("车站id:%d",locId);
    return m_locMap.value(locId,tr("未知车站"));
}

QString AlarmMng::getDevgDescByTag(const QString &tag)
{
    return m_devgMap.value(tag,tr("未知设备组"));
}

QString AlarmMng::getDevDescByTag(const QString &tag)
{
    return m_devMap.value(tag,tr("未知设备"));
}

QMap<QString, QString> AlarmMng::getDevInfo()
{
    return m_devMap;
}

QMap<QString, QString> AlarmMng::getDevgInfo()
{
    return m_devgMap;
}

QMap<int, QString> AlarmMng::getLocInfo()
{
    return m_locMap;
}

QList<int> AlarmMng::getLocOrder()
{
    return m_locOrder;
}

QMap<QString, QString> AlarmMng::getDevType()
{
    return m_devTypeMap;
}

QMap<int, QString> AlarmMng::getAlarmAction()
{
    return m_alarmActionMap;
}

QMap<int, int> AlarmMng::getAlarmLevelAction()
{
    return m_alarmLevelActionMap;
}

QMap<int, QString> AlarmMng::getAlarmLevel()
{
    return m_alarmLevelMap;
}

bool AlarmMng::isDiObjAlarm(PointInfoPtr info,ST_OBJ_INFO &objInfo)
{
    QSqlQuery query;
    QString table = "digital";
    QString sql = QString("select is_obj_alm_manner,alarm_priority,"
                          "pic_name,sound_name1 from %1 where tag_name = '%2' limit 1").arg(table).arg(info->m_tag);

    if(!m_pReadDb->isOpen())
    {
        return false;
    }

    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {

            bool  isObj = query.value(0).toBool();
            objInfo.bIsObj = isObj;
            objInfo.iPriority = query.value(1).toInt();
            objInfo.strPushPic = query.value(2).toString();
            objInfo.strVoice = query.value(3).toString();
            return isObj;

        }
    }

    return false;
}

bool AlarmMng::isAiObjAlarm(PointInfoPtr info, ST_OBJ_INFO &objInfo, ST_LIMIT_INFO &limitInfo)
{
    QSqlQuery query;
    bool  isLimit = false;
    QString table = "analog";
    QString tableLimit = "analog_limit_info";
    QString stVoice;
    QString sql =QString("select is_limit,sound_name1 from %1 where tag_name = '%2' limit 1").arg(table).arg(info->m_tag);

    if(!m_pReadDb->isOpen())
    {
        return false;
    }

    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {

            isLimit = query.value(0).toBool();
            stVoice = query.value(1).toString();
            break;
        }
    }
    limitInfo.bIsLimit =isLimit;
    objInfo.strVoice = stVoice;
    objInfo.bIsObj = false;
    if(!isLimit)
    {
        return isLimit;
    }else
    {
        sql = QString("select limit_num,limit_up1,limit_low1,limit_up2,limit_low2,is_obj_alm_manner"
                      ",alarm_priority,pic_name from %1 where tag_name = '%2' limit 1").arg(tableLimit).arg(info->m_tag);
        if(m_pReadDb->execute(sql,query))
        {
            while (query.next()) {
                limitInfo.iLevel = query.value(0).toInt();
                limitInfo.dLimitUp1 = query.value(1).toDouble();
                limitInfo.dLimitDown1 = query.value(2).toDouble();
                limitInfo.dLimitUp2 = query.value(3).toDouble();
                limitInfo.dLimitDown2 = query.value(4).toDouble();

                objInfo.bIsObj = query.value(5).toBool();
                objInfo.iPriority = query.value(6).toInt();
                objInfo.strPushPic = query.value(7).toString();
                break;
            }
        }
    }
    return isLimit;

}

QMap<int, ST_USER_DEF> AlarmMng::getUserInfo()
{
    return m_userInfo;
}

QMap<QString, QString> AlarmMng::getFuncInfo()
{
    return m_funcMap;
}

QMap<QString, QList<AlarmCalcInfoPtr> > AlarmMng::getCalcInfo()
{
    return m_calcInfoMap;
}

QList<ST_DEV_INFO> AlarmMng::getDevInfoByDevGroup(const QString devGroup)
{
    QList<ST_DEV_INFO> devList;
    QMap<QString,QList<QString> >::iterator it = m_devgDevMap.find(devGroup);
    if(it!= m_devgDevMap.end())
    {
        QList<QString> devTagList =it.value();
        for(int index(0);index<devTagList.size();index++)
        {
            ST_DEV_INFO info;
            info.strDev = devTagList.at(index);
            info.nLocId = m_devGlocIdMap.value(devGroup);
            info.nSubId = 4;
            info.strDevDesc = m_devMap.value(devTagList.at(index));
            info.nDevType = m_devTypeIdMap.value(devTagList.at(index));
            devList.append(info);
        }
    }
    return devList;
}

QList<QString> AlarmMng::getDiText()
{
    return m_diTextList;
}

bool AlarmMng::getNomRptEditPerm()
{
    iot_service::CPermMngApiPtr permMngPtr = iot_service::getPermMngInstance("base");
    if(permMngPtr == NULL || (PERM_NORMAL != permMngPtr->PermDllInit()))
    {
        LOGERROR("权限接口初始化失败!");
        return false;
    }
    std::string tmpStr = "FUNC_NOM_RPT_EDIT";
    if (PERM_PERMIT != permMngPtr->PermCheck(PERM_NOM_FUNC_DEF, &tmpStr))
    {
        return false;
    }
    return true;
}

void AlarmMng::slotSelectPoint(const QString &devg, const int index, const QString &filter)
{
    if(devg.isEmpty())
    {
        return ;
    }
    QStringList devList = m_devgDevMap.value(devg);
    loadPointByDev(devList,index,filter);
}

AlarmMng::AlarmMng()
    : QObject()
{
    mutex = new QMutex;

    m_pReadDb = new iot_dbms::CDbApi(DB_CONN_MODEL_READ);
    if(!m_pReadDb->open())
    {
        LOGERROR("打开数据库失败,error:%s",m_pReadDb->getLastErrorString().toStdString().c_str());
    }
    m_rtdbAccess = new iot_dbms::CRdbAccess();
    loadLocInfo();
    loadDevgInfo();
    loadDevInfo();
    loadDevType();
    loadAlarmAction();
    loadAlarmLevel();
    loadUserInfo();
    loadFuncInfo();
    loadCalcInfo();
    loadDiText();
}

void AlarmMng::loadLocInfo()
{
    iot_service::CPermMngApiPtr permMngPtr = iot_service::getPermMngInstance("base");
    if(permMngPtr == NULL || (PERM_NORMAL != permMngPtr->PermDllInit()))
    {
        LOGERROR("权限接口初始化失败!");
        return;
    }
    int level;
    std::vector <int> vecLocationId;
    std::vector<std::string> vecPermPic;

    if (PERM_NORMAL != permMngPtr->GetUsergInfo(level, vecLocationId, vecPermPic))
    {
        LOGERROR("权限接口获取获取当前登录用户组的等级、所属车站ID失败!");
        return;
    }
    std::string strApplicationName = "base";
    std::string strTableName = "sys_model_location_info";
    QPair<std::string, std::string> id_value;
    id_value.first = "location_id";
    id_value.second = "description";
    if(m_rtdbAccess->open(strApplicationName.c_str(), strTableName.c_str()))
    {
        iot_dbms::CTableLockGuard locker(*m_rtdbAccess);
        iot_dbms::CRdbQueryResult result;
        std::vector<std::string> columns;
        columns.push_back(id_value.first);
        columns.push_back(id_value.second);
        std::string sOrderColumn = "location_no";

        if(m_rtdbAccess->select(result, columns, sOrderColumn))
        {
            m_locMap.clear();
            for(int nIndex(0); nIndex < result.getRecordCount(); nIndex++)
            {
                iot_dbms::CVarType key;
                iot_dbms::CVarType value;
                result.getColumnValue(nIndex, 0, key);
                result.getColumnValue(nIndex, 1, value);

                std::vector <int>::const_iterator it = vecLocationId.cbegin();
                while (it != vecLocationId.cend())
                {
                    if(key.toInt() == *it)
                    {
                        m_locMap[key.toInt()] = QString::fromStdString(value.toStdString());
                        m_locOrder.push_back(key.toInt());
                    }
                    ++it;
                }
            }
        }
    }
}

void AlarmMng::loadDevgInfo()
{
    QList<QString> devList;
    QSqlQuery query;

    QString strLoctionFilter;
    if(m_locMap.keys().isEmpty())
    {
        return ;
    }
    QStringList listLocation;
    foreach (int nLocationID, m_locMap.keys())
    {
        listLocation.append(QString::number(nLocationID));
    }
    strLoctionFilter = QString("(%1 in (%2))").arg("location_id").arg(listLocation.join(","));

    QString sqlSequenceQuery = QString("select tag_name, description, location_id from dev_group where sub_system > 3");
    if(!strLoctionFilter.isEmpty())
    {
        sqlSequenceQuery.append(QString(" and %1  order by dev_group_no asc;").arg(strLoctionFilter));
    }else
    {
        sqlSequenceQuery.append(QString(" order by dev_group_no asc;"));
    }

    if(m_pReadDb->execute(sqlSequenceQuery,query))
    {
        while(query.next())
        {
            QString tag = query.value(0).toString();
            QString desc = query.value(1).toString();
            int loc = query.value(2).toInt();

            m_devgMap[tag] = desc;
            m_devGlocIdMap[tag] = loc;
            m_devTreeInfo[loc].insert(tag, devList);
            m_devgTreeInfo[loc].append(tag);
        }
    }

}

void AlarmMng::loadDevInfo()
{
    QSqlQuery query;

    QString strLoctionFilter;
    if(m_devgMap.isEmpty())
        return;

    strLoctionFilter = QString("(group_tag_name in ('%1'))").arg(m_devgMap.keys().join("','"));
    QString sqlSequenceQuery = QString("select tag_name, description, group_tag_name, location_id,dev_tp_name,dev_type from dev_info");
    if(!strLoctionFilter.isEmpty())
    {
        sqlSequenceQuery.append(QString(" where %1;").arg(strLoctionFilter));
    }
    if(m_pReadDb->execute(sqlSequenceQuery,query))
    {
        while(query.next())
        {
            QString tag = query.value(0).toString();
            QString desc = query.value(1).toString();
            QString devg = query.value(2).toString();
            int locId = query.value(3).toInt();
            QString devType = query.value(4).toString();
            int nDevType = query.value(5).toInt();
            m_devTypeMap[tag] = devType;
            m_devMap[tag] = desc;
            m_devTreeInfo[locId][devg].append(tag);
            m_devgDevMap[devg].append(tag);
            m_devTypeIdMap[tag] = nDevType;
        }
    }

}

void AlarmMng::loadDevType()
{
    QSqlQuery query;

    QString sqlSequenceQuery = QString("select tag_name, description from dev_temp_def where sub_system > 3");

    if(m_pReadDb->execute(sqlSequenceQuery,query))
    {
        while(query.next())
        {
            QString tag = query.value(0).toString();
            QString desc = query.value(1).toString();
            m_devTpTypeMap[tag] = desc;
        }
    }

}

void AlarmMng::loadAlarmAction()
{
    QSqlQuery query;
    QString sqlSequenceQuery = QString("select action_id, action_name from alarm_action_define");
    if(m_pReadDb->execute(sqlSequenceQuery,query))
    {
        while(query.next())
        {
            int id = query.value(0).toInt();
            QString name = query.value(1).toString();
            m_alarmActionMap[id] = name;
        }
    }
}

void AlarmMng::loadAlarmLevel()
{
    QSqlQuery query;
    QString sqlSequenceQuery = QString("select priority_id, priority_name ,alarm_actions from alarm_level_define");
    if(m_pReadDb->execute(sqlSequenceQuery,query))
    {
        while(query.next())
        {
            int id = query.value(0).toInt();
            QString name = query.value(1).toString();
            int action = query.value(2).toInt();
            m_alarmLevelMap[id] = name;
            m_alarmLevelActionMap[id] = action;
        }
    }
}

void AlarmMng::loadPointByDev(const QStringList &devList, const int index, const QString &filter)
{
    QList<PointInfoPtr> pointList;
    switch (index) {
    case EN_POINT_AI_INDEX:
        loadAi(pointList,devList);
        filterPoint(pointList,filter);
        if(pointList.size()>0)
        {
            emit addAiPoint(pointList);
        }

        break;
    case EN_POINT_DI_INDEX:
        loadDi(pointList,devList);
        filterPoint(pointList,filter);
        if(pointList.size()>0)
        {
            emit addDiPoint(pointList);
        }
        break;
    default:
        break;
    }
}

void AlarmMng::loadAi(QList<PointInfoPtr> &pointList, const QStringList &devList)
{
    QSqlQuery query;
    QString strDeviceFilter;
    QString tableName = "analog";

    strDeviceFilter = "'" + devList.join("', '") + "'";
    strDeviceFilter = QString("(%1 in (%2))").arg("device").arg(strDeviceFilter);
    QString sql = QString("select %1.tag_name,%1.description,%1.device,%1.location_id,%1.is_limit"
                          ",%2.group_tag_name from %1 left join %2 on %1.device"
                          " = %2.tag_name where %3").arg(tableName).arg("dev_info").arg(strDeviceFilter);
    if(m_pReadDb->execute(sql,query))
    {
        while(query.next())
        {
            QString tag = query.value(0).toString();
            QString desc = query.value(1).toString();
            QString dev = query.value(2).toString();
            int locId = query.value(3).toInt();
            int isLimit = query.value(4).toInt();

            QString devg = query.value(5).toString();
            PointInfoPtr info(new PointInfo());
            info->m_tag = tag;
            if(isLimit == 1)
            {
                getAlarmObj(info);
            }

            info->m_desc = desc;
            info->m_dev = dev;
            info->m_devg = devg;
            info->m_loc = locId;
            info->m_sub = 4;
            info->m_type = EN_POINT_ANALOG;
            pointList.append(info);
        }
    }
}

void AlarmMng::loadDi(QList<PointInfoPtr> &pointList, const QStringList &devList)
{
    QSqlQuery query;
    QString strDeviceFilter;
    QString tableName = "digital";

    strDeviceFilter = "'" + devList.join("', '") + "'";
    strDeviceFilter = QString("(%1 in (%2))").arg("device").arg(strDeviceFilter);
    QString sql = QString("select %1.tag_name,%1.description,%1.device,%1.location_id,%1.is_obj_alm_manner,%1.alarm_priority"
                          ",%2.group_tag_name from %1 left join %2 on %1.device"
                          " = %2.tag_name where %3").arg(tableName).arg("dev_info").arg(strDeviceFilter);

    if(m_pReadDb->execute(sql,query))
    {
    while(query.next())
    {
        QString tag = query.value(0).toString();
        QString desc = query.value(1).toString();
        QString dev = query.value(2).toString();
        int locId = query.value(3).toInt();
        int is_obj = query.value(4).toInt();
        int priority = -1;
        QString devg = query.value(6).toString();

        priority = query.value(5).toInt();

        PointInfoPtr info(new PointInfo());
        info->m_tag = tag;
        //getAlarmShield(info);
        info->m_desc = desc;
        info->m_dev = dev;
        info->m_devg = devg;
        info->m_sub = 4;
        info->m_loc = locId;
        info->m_obj = is_obj;
        info->m_type = EN_POINT_DIGITAL;
        info->m_priority = priority;
        pointList.append(info);
    }
    }
}

void AlarmMng::loadPi(QList<PointInfoPtr> &pointList, const QStringList &devList)
{
    QSqlQuery query;
    QString strDeviceFilter;
    QString tableName = "accuml";

    strDeviceFilter = "'" + devList.join("', '") + "'";
    strDeviceFilter = QString("(%1 in (%2))").arg("device").arg(strDeviceFilter);
    QString sql = QString("select %1.tag_name,%1.description,%1.device,%1.location_id"
                          ",%2.group_tag_name from %1 left join %2 on %1.device"
                          " = %2.tag_name where %3").arg(tableName).arg("dev_info").arg(strDeviceFilter);

    if(m_pReadDb->execute(sql,query))
    {
        while(query.next())
        {
            QString tag = query.value(0).toString();
            QString desc = query.value(1).toString();
            QString dev = query.value(2).toString();
            int locId = query.value(3).toInt();
            QString devg = query.value(4).toString();

            PointInfoPtr info(new PointInfo());
            info->m_tag = tag;
            info->m_desc = desc;
            info->m_dev = dev;
            info->m_devg = devg;
            info->m_loc = locId;
            info->m_type = EN_POINT_ACCUML;
            pointList.append(info);
        }
    }
}

void AlarmMng::loadUserInfo()
{
    QSqlQuery query;
    QString tableName = "rm_user_def";
    QString sql = QString("select %1.perm_id,%1.perm_name,%1.perm_alias,%1.perm_desc from %1").arg(tableName);
    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {
            ST_USER_DEF user;
            user.iId = query.value(0).toInt();
            user.strName = query.value(1).toString();
            user.strAlias = query.value(2).toString();
            user.strDesc = query.value(3).toString();
            m_userInfo[user.iId] = user;
        }
    }
}

void AlarmMng::loadFuncInfo()
{
    QSqlQuery query;
    QString tableName = "calc_func_def";
    QString sql = QString("select %1.func_name,%1.description from %1").arg(tableName);
    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {
            m_funcMap[query.value(0).toString()] = query.value(1).toString();
        }
    }
}

void AlarmMng::loadCalcInfo()
{
    m_calcInfoMap.clear();
    QSqlQuery query;
    QString tableName = "calc_para_def";
    QString sql = QString("select %1.func_name,%1.para_seq_no,%1.description from %1 ").arg(tableName);
    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {
            AlarmCalcInfoPtr info(new AlarmCalcInfo());
            info->m_tag = query.value(0).toString();
            info->m_nId = query.value(1).toInt();
            info->m_strTip = query.value(2).toString();
            m_calcInfoMap[info->m_tag].append(info);
        }
    }
}

void AlarmMng::loadDiText()
{
    m_diTextList.clear();

    QSqlQuery query;
    QString tableName = "dict_state_text_info";
    QString sql = QString("select state_text_name from %1 where sub_system >3 group by state_text_name").arg(tableName);
    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {
            QString text = query.value(0).toString();
            m_diTextList.append(text);
        }
    }
}

void AlarmMng::filterPoint(QList<PointInfoPtr> &pointList, const QString &filter)
{
    if(!filter.isEmpty())
    {
        QList<PointInfoPtr>::iterator iter = pointList.begin();
        while (iter != pointList.end()) {
            if(!conditionFilter(*iter,filter))
            {
                iter = pointList.erase(iter);
                //pointList.erase(iter++);
            }else
            {
                iter++;
            }
        }
    }
}

bool AlarmMng::conditionFilter(PointInfoPtr info,const QString &filter)
{
    if(info->m_desc.indexOf(filter) != -1)
    {
        return true;
    }
    if(m_locMap.value(info->m_loc,"").indexOf(filter) != -1)
    {
        return true;
    }
    if(m_devgMap.value(info->m_devg,"").indexOf(filter) != -1)
    {
        return true;
    }
    if(m_devMap.value(info->m_dev).indexOf(filter) != -1)
    {
        return true;
    }
    if(m_alarmLevelMap.value(info->m_priority,tr("未知")).indexOf(filter) != -1)
    {
        return true;
    }
    QString text;
    int priority = info->m_priority;
    if( priority < 0)
    {
        text = "-";
    }else
    {
        int act = m_alarmLevelActionMap.value(priority,0);
        QMap<int,QString>::const_iterator it = m_alarmActionMap.cbegin();
        while (it != m_alarmActionMap.cend()) {
            if(act>>(it.key()-1) & 0x0001)
            {
                text += QString("%2 ").arg(it.value());
            }
            it++;
        }
    }
    if(text.indexOf(filter) != -1)
    {
        return true;
    }
    return false;
}

void AlarmMng::getAlarmObj(PointInfoPtr info)
{
    QSqlQuery query;
    QString tableName = "analog_limit_info";
    QString sql = QString("select %1.is_obj_alm_manner,%1.alarm_priority from %1 where tag_name = '%2' ").arg(tableName).arg(info->m_tag);
    if(m_pReadDb->execute(sql,query))
    {
        while (query.next()) {
            int is_obj = query.value(0).toInt();
            int priority = query.value(1).toInt();
            info->m_obj = is_obj;
            info->m_priority = priority;
            return ;
        }
    }
    return ;
}

//void AlarmMng::getAlarmShield(PointInfoPtr info)
//{
//    QSqlQuery query;
//    QString sql = QString("select shield_id,key_id_tag from %1 where shield_object ='%2' limit 1").arg("opt_shield_obj").arg(info->m_tag);
//    if(m_pReadDb->execute(sql,query))
//    {
//        while (query.next()) {
//            int shield_id =query.value(0).toInt();
//            QString key_id_tag = query.value(1).toString();
//            info->m_bShield = true;
//            info->m_keyIdTag =key_id_tag;
//            info->m_shieldId = shield_id;
//            break;
//        }
//    }
//    //查询屏蔽描述和时段
//    if(!info->m_bShield)
//    {
//        return ;
//    }
//    query.clear();
//    sql = QString("select shield_name,time_id from %1 where shield_id =%2 limit 1").arg("opt_shield_info").arg(info->m_shieldId);
//    if(m_pReadDb->execute(sql,query))
//    {
//        while (query.next()) {
//            info->m_shieldDesc = query.value(0).toString();
//            int time_id =query.value(1).toInt();
//            info->m_timeId = time_id;
//            break;
//        }
//    }
//    if(info->m_timeId < 0)
//    {
//        return ;
//    }
//    query.clear();
//    sql = QString("select time_type,start_time,end_time,time_option from %1 where time_id = %2 limit 1").arg("opt_shield_time").arg(info->m_timeId);
//    if(m_pReadDb->execute(sql,query))
//    {
//        while (query.next()) {
//            info->m_timeType = query.value(0).toInt();
//            info->m_startTime = query.value(1).toString();
//            info->m_endTime = query.value(2).toString();
//            info->m_timeOption = query.value(3).toInt();
//            break;
//        }
//    }
//}