#include "CDevSpePointWidget.h"
#include "public/pub_utility_api/FileStyle.h"
#include "CRealDataCollect.h"
#include "CRealTableModel.h"
#include <QMap>
#include <QTableView>
#include <QGridLayout>
#include <QHeaderView>

CDevSpePointWidget::CDevSpePointWidget(QWidget *parent, bool isEditMode)
    : QWidget(parent),
      m_pDpcdaForApp(Q_NULLPTR),
      m_pTableView(Q_NULLPTR),
      m_pTableModel(Q_NULLPTR),
      m_isEditMode(isEditMode)
{
    initialize();
}

CDevSpePointWidget::~CDevSpePointWidget()
{
    if(m_pDpcdaForApp)
    {
        m_pDpcdaForApp->unsubscribeAll();
        delete m_pDpcdaForApp;
    }
    m_pDpcdaForApp = NULL;
}

void CDevSpePointWidget::setCornerName(const QString &name)
{
    int columnSize = m_columnNameList.size();
    int columnTagSize = m_columnTagList.size();
    if(columnSize == columnTagSize)
    {
        m_columnNameList.push_front(name);
    }
    else if(columnSize == (columnTagSize + 1))
    {
        m_columnNameList[0] = name;
    }
    m_pTableModel->setHeader(m_columnNameList);
}

void CDevSpePointWidget::showNameType(int labelType)
{
    deviceOrGroupShowType = labelType;
}

QString CDevSpePointWidget::addRow(const QString &pointTag)
{
    if(pointTag.isEmpty())
    {
        return tr("测点标签为空!");
    }

    iot_dbms::CDbApi objReader(DB_CONN_MODEL_READ);
    if(!objReader.open())
    {
        return tr("数据库连接打开失败!");
    }


    QStringList pointList = pointTag.split(",");
    QString error = QString();
    int i=0;

    if(deviceOrGroupShowType == 0) //行标题默认模式-->0
    {
        foreach (QString point, pointList)
        {
            //< 检查标签是否合法
            QStringList list = point.split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }
            //< 检查是否重复添加
            QString device =list[3] + "." + list[4];//occ.PDBD22_PDGKC1
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }
            //< 添加第一列数据（设备描述）
            QString deviceName = queryDeviceDesc(device, objReader);
            if(deviceName.isEmpty())
            {
                error += tr("查询设备描述失败!\n");
                continue;
            }

            //添加排序
            device= QString("%1").arg(i++, 3, 10, QChar('0')) +"." +device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);
            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }
        }

    }
    else if(deviceOrGroupShowType == 1) //行标题按设备组显示-->1(每行参数取该组全部设备存在的第一个值)
    {
        foreach (QString point, pointList)
        {
            //< 检查标签是否合法
            QStringList list = point.split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }

            //< 检查是否重复添加
            QString device =list[3] + "." + list[4].split("_")[0]; //S12.6102
            qDebug() << "deviceOrGroupShowType(1) device: " << device;
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }

            //< 添加第一列数据（设备描述）
            QString deviceName = queryGetGroupDescription(device, objReader); //设备组名，如：6102柜17变1＃变压器

            if(deviceName.isEmpty())
            {
                error += tr("查询设备描述失败!\n");
                continue;
            }

            //添加排序
            device= QString("%1").arg(i++, 3, 10, QChar('0')) +"." +device; //000.S12.6102
            qDebug() << "deviceOrGroupShowType(1) device(1): " << device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);
            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }

            qDebug() << "deviceOrGroupShowType(1) m_columnTagList.isEmpty()";

            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                qDebug() << "realData-->" << realData.tag_name << realData.table_name;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }
        }
    }
    else if(deviceOrGroupShowType == 2) //行标题按设备名显示-->2
    {
        foreach (QString point, pointList)
        {
            //< 检查标签是否合法
            QStringList list = point.split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }
            //< 检查是否重复添加
            QString device =list[3] + "." + list[4].split("_")[0]; //kxg.KXG1Meter1
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }

            //< 添加第一列数据（设备描述）
            QString valueType = list[5];
            device = queryGetDevInfoTagName(valueType, device, objReader);

            iot_dbms::CDbApi descriptionReader(DB_CONN_MODEL_READ);
            if(!descriptionReader.open())
            {
                return tr("数据库连接打开失败!");
            }
            QString deviceName = queryGetDevInfoDescription(device, descriptionReader);


            if(deviceName.isEmpty())
            {
                error += tr("查询设备描述失败!\n");
                continue;
            }

            //添加排序
            device= QString("%1").arg(i++, 3, 10, QChar('0')) +"." +device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);
            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }
        }
    }
    else if(deviceOrGroupShowType == 3) //行标题按设备组名显示,取该组第一个设备和它的值
    {
        foreach (QString point, pointList)
        {
            QStringList list = point.split(".");
            //< 检查标签是否合法
            if(list.length() != 7)
            {
                error += ("测点标签不合法!\n");
                continue;
            }

            //< 检查是否重复添加
            QString device = list[3] + "." + list[4].split("_")[0];
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }

            //< 添加第一列数据(设备描述)
            QString deviceName = queryGetGroupDescription(device, objReader);
            if(deviceName.isEmpty())
            {
                error += tr("查询设备描述失败!\n");
                continue;
            }
            device = list[3] + "." + list[4];
            device = QString("%1").arg(i++, 3, 10, QChar('0')) + "." + device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);

            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }
            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                qDebug() << "realData-->" << realData.tag_name << realData.table_name;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }

        }
    }

    m_pTableModel->updateRealData(m_dataMap);
   // m_pTableModel->sort(1,Qt::AscendingOrder);
    return error;
}

QString CDevSpePointWidget::addRowName(const QString &pointTag, const QString &DevName)
{
    if(pointTag.isEmpty())
    {
        return tr("测点标签为空!");
    }
    QStringList pointList = pointTag.split(",");
    QStringList DevNameList = DevName.split(",");

    if(pointList.count() != DevNameList.count())
    {
        //转化为字符串
        QString str = QString("%1:%2").arg(pointList.count(), 2, 10, QLatin1Char('0')).arg(DevNameList.count(), 2, 10, QLatin1Char('0'));
        return str;
    }

    iot_dbms::CDbApi objReader(DB_CONN_MODEL_READ);
    if(!objReader.open())
    {
        return tr("数据库连接打开失败!");
    }

    QString error = QString();
    int i=0;

    if(deviceOrGroupShowType == 0) //行标题默认模式-->0
    {
        foreach (QString point, pointList)
        {
            //< 检查标签是否合法
            QStringList list = point.split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }
            //< 检查是否重复添加
            QString device =list[3] + "." + list[4]; //occ.PDBD22_PDGKC1
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }
            //< 添加第一列数据（设备描述）
            QString deviceName = DevNameList[i];//queryDeviceDesc(device, objReader);


            //添加排序
            device= QString("%1").arg(i++, 3, 10, QChar('0')) +"." +device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);
            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }
        }
    }
    else if(deviceOrGroupShowType == 1 || deviceOrGroupShowType == 3) //行标题按设备组显示-->1(每行参数取该组全部设备存在的第一个值)
    {
        foreach (QString point, pointList)
        {
            //< 检查标签是否合法
            QStringList list = point.split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }
            //< 检查是否重复添加
            QString device =list[3] + "." + list[4].split("_")[0]; //S12.6102
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }
            //< 添加第一列数据（设备描述）
            QString deviceName = DevNameList[i];
            device = queryGetGroupDescription(device, objReader);


            //添加排序
            device= QString("%1").arg(i++, 3, 10, QChar('0')) +"." +device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);
            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }
        }
    }
    else if(deviceOrGroupShowType == 2) //行标题按设备名显示-->2
    {
        foreach (QString point, pointList)
        {
            //< 检查标签是否合法
            QStringList list = point.split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }
            //< 检查是否重复添加
            QString device =list[3] + "." + list[4].split("_")[0]; //kxg.KXG1Meter1
            QMap<QString, QList<ST_RealData>>::iterator iter = m_dataMap.find(device);
            if(iter != m_dataMap.end())
            {
                error += tr("重复添加!\n");
                continue;
            }

            //< 添加第一列数据（设备描述）
            QString valueType = list[5];
            device = queryGetDevInfoTagName(valueType, device, objReader);

            iot_dbms::CDbApi descriptionReader(DB_CONN_MODEL_READ);
            if(!descriptionReader.open())
            {
                return tr("数据库连接打开失败!");
            }
            QString deviceName = queryGetDevInfoDescription(device, descriptionReader);

            //添加排序
            device= QString("%1").arg(i++, 3, 10, QChar('0')) +"." +device;
            ST_RealData devData;
            devData.description = deviceName;
            devData.isInit = false;
            devData.type = TYPE_DESC;
            m_dataMap[device].append(devData);
            //< 添加点标签列数据
            if(m_columnTagList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<m_columnTagList.size(); nIndex++)
            {
                const QPair<QString, QString> &pair = m_columnTagList[nIndex];
                ST_RealData realData;
                realData.tag_name = device.mid(device.indexOf(".")+1) + "." + pair.first;
                realData.table_name = pair.second;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[device].append(realData);
            }
        }

    }

    m_pTableModel->updateRealData(m_dataMap);
   // m_pTableModel->sort(1,Qt::AscendingOrder);
    return error;
}

QString CDevSpePointWidget::addColumn(const QString &title, const QString &pointTag)
{
    if(pointTag.isEmpty())
    {
        return tr("测点标签为空!");
    }
    iot_dbms::CDbApi objReader(DB_CONN_MODEL_READ);
    if(!objReader.open())
    {
        return tr("数据库连接打开失败!");
    }
    QStringList titleList = title.split(",");
    QStringList pointList = pointTag.split(",");
    if(titleList.size() != pointList.size())
    {
        return tr("传入参数个数不一致!");
    }
    QString error = QString();


    if(deviceOrGroupShowType == 0 || deviceOrGroupShowType == 2)
    {
        for(int i(0); i < pointList.length(); i++)
        {
            //< 检查标签是否合法
            QStringList list = QString(pointList[i]).split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }
            //< 添加列头
            QString table = list[2];
            QString tag = list[5];
            m_columnTagList.append(qMakePair<QString, QString>(tag, table));
            m_columnNameList.append(titleList[i]);
            m_pTableModel->setHeader(m_columnNameList);
            //< 添加点标签列数据
            QStringList devList = m_dataMap.keys();
            if(devList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<devList.size(); nIndex++)
            {
                ST_RealData realData;
                QString str_tag_name = devList[nIndex];
                str_tag_name=str_tag_name.mid(str_tag_name.indexOf(".")+1);
                realData.tag_name = str_tag_name + "." + tag;
                realData.table_name = table;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[devList[nIndex]].append(realData);
            }
        }
    }
    else if(deviceOrGroupShowType == 1)
    {
        for(int i(0); i < pointList.length(); i++)
        {
            //< 检查标签是否合法
            QStringList list = QString(pointList[i]).split(".");
            if(list.length() != 7)
            {
                error += tr("测点标签不合法!\n");
                continue;
            }

            //< 添加列头
            QString table = list[2]; //analog
            QString tag = list[5]; //VA
            m_columnTagList.append(qMakePair<QString, QString>(tag, table)); //VA、analog
            m_columnNameList.append(titleList[i]); //列标题栏
            m_pTableModel->setHeader(m_columnNameList);


            //< 添加点标签列数据
            QStringList devList = m_dataMap.keys();
            //000.S12.6102", "001.S12.6342", "002.S12.6343", "003.S12.6344", "004.S12.6345", "005.S12.6346", "006.S12.6111
            
            if(devList.isEmpty())
            {
                continue;
            }

            int groupNum = 0;
            for(int nIndex(0); nIndex<devList.size(); nIndex++)
            {
                ST_RealData realData;
                // QString str_tag_name = devList[nIndex];
                // str_tag_name=str_tag_name.mid(str_tag_name.indexOf(".")+1);
                QString str_tag_name;
                QString groupTagName = list[3] + "." + list[4].split("1_")[0] + QString::number(++groupNum);
                str_tag_name = queryGetCollumnDevInfoTagName(table, tag, groupTagName, objReader);

                // realData.tag_name = str_tag_name + "." + tag;
                realData.tag_name = str_tag_name;
                realData.table_name = table;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[devList[nIndex]].append(realData);
            }
        }
    }
    else if(deviceOrGroupShowType == 3)
    {
        for(int i(0); i < pointList.length(); i++)
        {
            QStringList list = QString(pointList[i]).split("."); 
            //< 检查标签是否合法
            if(list.length() < 2)
            {
                error += ("测点标签不合法");
                continue;
            }
            //< 添加列头
            QString table = list[0];
            QString tag = list[1];
            m_columnTagList.append(qMakePair<QString, QString>(tag, table));
            m_columnNameList.append(titleList[i]);
            m_pTableModel->setHeader(m_columnNameList);
            //< 添加点标签列数据
            QStringList devList = m_dataMap.keys();
            if(devList.isEmpty())
            {
                continue;
            }

            for(int nIndex(0); nIndex<devList.size(); nIndex++)
            {
                ST_RealData realData;
                QString str_tag_name = devList[nIndex];
                qDebug() << "deviceOrGroupShowType(3) str_tag_name" << str_tag_name;
                str_tag_name=str_tag_name.mid(str_tag_name.indexOf(".")+1);
                realData.tag_name = str_tag_name + "." + tag;
                qDebug() << "deviceOrGroupShowType(3) tag_name" << str_tag_name + "." + tag;
                realData.table_name = table;
                realData.isInit = false;
                realData.type = TYPE_POINT;
                if(realData.table_name == "digital")
                {
                    realData.stateTextName = queryDigitalStateText(realData.tag_name, objReader);
                }
                m_dataMap[devList[nIndex]].append(realData);
            }
        }
    }
    
    m_pTableModel->updateRealData(m_dataMap);
    return error;
}

void CDevSpePointWidget::subscribe()
{
    qDebug() << "subscribe start!";
    if(m_pDpcdaForApp == Q_NULLPTR)
    {
        return;
    }
    m_pDpcdaForApp->unsubscribeAll();

    QMap<QString, QList<ST_RealData>>::const_iterator iter = m_dataMap.cbegin();
    for(; iter != m_dataMap.cend(); iter++)
    {
        const QList<ST_RealData> &list = iter.value();
        foreach (const ST_RealData &data, list) {
            qDebug() << "subscribe data-->" << data.table_name << data.tag_name;
            if(data.type != TYPE_POINT)
            {
                continue;
            }
            if(data.tag_name.isEmpty() || data.table_name.isEmpty())
            {
                continue;
            }
            m_pDpcdaForApp->subscribe(data.table_name.toStdString(), data.tag_name.toStdString(), "value");
            m_pDpcdaForApp->subscribe(data.table_name.toStdString(), data.tag_name.toStdString(), "status");
            qDebug() << "subscribe-->" << data.table_name << data.tag_name;
        }
    }
}

void CDevSpePointWidget::unsubscribeAll()
{
    if(m_pDpcdaForApp)
    {
        m_pDpcdaForApp->unsubscribeAll();
    }
}

void CDevSpePointWidget::setRowHeight(int height)
{
    for(int nIndex(0); nIndex<m_pTableModel->rowCount(); nIndex++)
    {
        m_pTableView->setRowHeight(nIndex, height);
    }
}

void CDevSpePointWidget::setColumnWidth(int column, int width)
{
    for(int nIndex(0); nIndex<m_pTableModel->rowCount(); nIndex++)
    {
        m_pTableView->setColumnWidth(column, width);
    }
}

void CDevSpePointWidget::setValidString(const QString &text)
{
    if(m_pTableModel)
    {
        m_pTableModel->setValidString(text);
    }
}

void CDevSpePointWidget::setColumnStateText(int column, const QString &stateText)
{
    QStringList list = stateText.split(",");
    if((list.length() % 2) != 0)
    {
        return;
    }
    QMap<double, QString> map;
    double key;
    QString value;
    for(int n = 0; n < list.length(); ++n)
    {
        key = QString(list[n++]).toDouble();
        value = list[n];
        map[key] = value;
    }

    m_pTableModel->addColStateTextMap(column, map);
}

void CDevSpePointWidget::slotUpdateAi(const QMap<QString, QPair<float, uint> > &aiMap)
{
    QMap<QString, QPair<float, uint> >::const_iterator iter = aiMap.constBegin();
    for(; iter != aiMap.constEnd(); iter++)
    {
        QMap<QString, QList<ST_RealData>>::iterator dIter = m_dataMap.begin();
        for(; dIter != m_dataMap.end(); dIter++)
        {
            QList<ST_RealData> &dataList = dIter.value();
            for(int nIndex(0); nIndex<dataList.length(); nIndex++){
                if(dataList[nIndex].type != TYPE_POINT)
                {
                    continue;
                }
                if(dataList[nIndex].table_name != "analog")
                {
                    continue;
                }
                if(dataList[nIndex].tag_name != iter.key())
                {
                    continue;
                }
                dataList[nIndex].isInit = true;
                dataList[nIndex].value = iter.value().first;
                dataList[nIndex].status = iter.value().second;
            }
        }
    }
    m_pTableModel->updateRealValue(m_dataMap);
}

void CDevSpePointWidget::slotUpdateDi(const QMap<QString, QPair<int, uint> > &diMap)
{
    QMap<QString, QPair<int, uint> >::const_iterator iter = diMap.constBegin();
    for(; iter != diMap.constEnd(); iter++)
    {
        QMap<QString, QList<ST_RealData>>::iterator dIter = m_dataMap.begin();
        for(; dIter != m_dataMap.end(); dIter++)
        {
            QList<ST_RealData> &dataList = dIter.value();
            for(int nIndex(0); nIndex<dataList.length(); nIndex++){
                if(dataList[nIndex].type != TYPE_POINT)
                {
                    continue;
                }
                if(dataList[nIndex].table_name != "digital")
                {
                    continue;
                }
                if(dataList[nIndex].tag_name != iter.key())
                {
                    continue;
                }
                dataList[nIndex].isInit = true;
                dataList[nIndex].value = iter.value().first;
                dataList[nIndex].status = iter.value().second;
            }
        }
    }
    m_pTableModel->updateRealValue(m_dataMap);
}

void CDevSpePointWidget::slotUpdatePi(const QMap<QString, QPair<double, uint> > &piMap)
{
    QMap<QString, QPair<double, uint> >::const_iterator iter = piMap.constBegin();
    for(; iter != piMap.constEnd(); iter++)
    {
        QMap<QString, QList<ST_RealData>>::iterator dIter = m_dataMap.begin();
        for(; dIter != m_dataMap.end(); dIter++)
        {
            QList<ST_RealData> &dataList = dIter.value();
            for(int nIndex(0); nIndex<dataList.length(); nIndex++){
                if(dataList[nIndex].type != TYPE_POINT)
                {
                    continue;
                }
                if(dataList[nIndex].table_name != "accuml")
                {
                    continue;
                }
                if(dataList[nIndex].tag_name != iter.key())
                {
                    continue;
                }
                dataList[nIndex].isInit = true;
                dataList[nIndex].value = iter.value().first;
                dataList[nIndex].status = iter.value().second;
            }
        }
    }
    m_pTableModel->updateRealValue(m_dataMap);
}

void CDevSpePointWidget::slotUpdateMi(const QMap<QString, QPair<int, uint> > &miMap)
{
    QMap<QString, QPair<int, uint> >::const_iterator iter = miMap.constBegin();
    for(; iter != miMap.constEnd(); iter++)
    {
        QMap<QString, QList<ST_RealData>>::iterator dIter = m_dataMap.begin();
        for(; dIter != m_dataMap.end(); dIter++)
        {
            QList<ST_RealData> &dataList = dIter.value();
            for(int nIndex(0); nIndex<dataList.length(); nIndex++){
                if(dataList[nIndex].type != TYPE_POINT)
                {
                    continue;
                }
                if(dataList[nIndex].table_name != "mix")
                {
                    continue;
                }
                if(dataList[nIndex].tag_name != iter.key())
                {
                    continue;
                }
                dataList[nIndex].isInit = true;
                dataList[nIndex].value = iter.value().first;
                dataList[nIndex].status = iter.value().second;
            }
        }
    }
    m_pTableModel->updateRealValue(m_dataMap);
}

void CDevSpePointWidget::initialize()
{
    m_pTableView = new QTableView;
    m_pTableView->horizontalHeader()->setStretchLastSection(true);
    m_pTableView->setSelectionMode(QAbstractItemView::NoSelection);
    m_pTableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_pTableView->setAlternatingRowColors(true);
    m_pTableModel = new CRealTableModel;
    m_pTableView->setModel(m_pTableModel);
    QGridLayout *layout = new QGridLayout;
    layout->addWidget(m_pTableView);
    layout->setMargin(0);
    setLayout(layout);

    if(m_isEditMode)
    {
        return;
    }
    initStyle();

    qRegisterMetaType<QMap<QString, QPair<float, uint>>>("QMap<QString, QPair<float, uint>>");
    qRegisterMetaType<QMap<QString, QPair<double, uint>>>("QMap<QString, QPair<double, uint>>");
    qRegisterMetaType<QMap<QString, QPair<int, uint>>>("QMap<QString, QPair<int, uint>>");

    m_pDpcdaForApp = new iot_service::CDpcdaForApp();

    connect(CRealDataCollect::instance(), &CRealDataCollect::signal_updateAi, this, &CDevSpePointWidget::slotUpdateAi);
    connect(CRealDataCollect::instance(), &CRealDataCollect::signal_updateDi, this, &CDevSpePointWidget::slotUpdateDi);
    connect(CRealDataCollect::instance(), &CRealDataCollect::signal_updateMi, this, &CDevSpePointWidget::slotUpdateMi);
    connect(CRealDataCollect::instance(), &CRealDataCollect::signal_updatePi, this, &CDevSpePointWidget::slotUpdatePi);
}

void CDevSpePointWidget::initStyle()
{
    QString qss = QString();
    std::string strFullPath = iot_public::CFileStyle::getPathOfStyleFile("public.qss");
    qDebug() << "strFullPath-->" << QString::fromStdString(strFullPath);
    QFile qssfile1(QString::fromStdString(strFullPath));
    qssfile1.open(QFile::ReadOnly);
    if (qssfile1.isOpen())
    {
        qDebug() << "load public.qss";
        qss += QLatin1String(qssfile1.readAll());
        qssfile1.close();
    }
    qssfile1.close();

    std::string style = iot_public::CFileStyle::getPathOfStyleFile("devSpePoint.qss") ;
    qDebug() << "Style Path-->" << QString::fromStdString(style);
    QFile file(QString::fromStdString(style));
    file.open(QFile::ReadOnly);
    if (file.isOpen())
    {
        setStyleSheet(QLatin1String(file.readAll()));
        file.close();
        qDebug() << "load devSpePoint.qss";
    }
}

QString CDevSpePointWidget::queryDeviceDesc(const QString &devTag, iot_dbms::CDbApi &objReader) const
{
    if(!objReader.isOpen())
    {
        return QString();
    }

    QList<QString> listColName;
    listColName.append("DESCRIPTION");
    iot_dbms::CDbCondition objCondition;
    objCondition.m_sColName = "TAG_NAME";
    objCondition.m_value = devTag;
    objCondition.m_eCompare = iot_dbms::CDbCondition::COMPARE_EQ;
    objCondition.m_eLogic = iot_dbms::CDbCondition::LOGIC_AND;

    QSqlQuery objQuery;
    if(objReader.select("dev_info", listColName, objCondition, objQuery))
    {
        while(objQuery.next())
        {
            return objQuery.value(0).toString();
        }
    }
    return QString();
}

QString CDevSpePointWidget::queryDigitalStateText(const QString &point, iot_dbms::CDbApi &objReader) const
{
    if(!objReader.isOpen())
    {
        return QString();
    }
    QList<QString> listColName;
    listColName.append("STATE_TEXT_NAME");
    iot_dbms::CDbCondition objCondition;
    objCondition.m_sColName = "TAG_NAME";
    objCondition.m_value = point;
    objCondition.m_eCompare = iot_dbms::CDbCondition::COMPARE_EQ;
    objCondition.m_eLogic = iot_dbms::CDbCondition::LOGIC_AND;

    QSqlQuery objQuery;
    if(objReader.select("digital", listColName, objCondition, objQuery))
    {
        while(objQuery.next())
        {
            return objQuery.value(0).toString();
        }
    }
    return QString();
}

//获取设备组名，仅deviceOrGroupType==1时使用
QString CDevSpePointWidget::queryGetGroupDescription(const QString &tagName, iot_dbms::CDbApi &objReader) const
{
    if(!objReader.isOpen())
    {
        return QString();
    }

    QList<QString> listColName;
    listColName.append("DESCRIPTION"); //需要取的值
    iot_dbms::CDbCondition objCondition;
    objCondition.m_sColName = "TAG_NAME"; //比较的组名
    objCondition.m_value = tagName; // 比较的值
    objCondition.m_eCompare = iot_dbms::CDbCondition::COMPARE_EQ; // 比较条件
    objCondition.m_eLogic = iot_dbms::CDbCondition::LOGIC_AND; // 两个比较条件之间的关系

    QSqlQuery objQuery;
    if(objReader.select("dev_group", listColName, objCondition, objQuery))
    {
        while(objQuery.next())
        {
            return objQuery.value(0).toString();
        }
    }
    return QString();
}

//获取设备组里第1个存在的列标题值的设备名，仅deviceOrGroupType==1时使用
QString   CDevSpePointWidget::queryGetCollumnDevInfoTagName(const QString &measureType, const QString &valueType, const QString &groupName, iot_dbms::CDbApi &objReader) const
{
    if(!objReader.isOpen())
    {
        return QString();
    }

    QString mysqlExecute;
    mysqlExecute = QString("SELECT %1.TAG_NAME FROM %2 JOIN dev_info ON dev_info.TAG_NAME = %3.DEVICE WHERE dev_info.GROUP_TAG_NAME = '%4'")
                           .arg(measureType).arg(measureType).arg(measureType).arg(groupName);
    QSqlQuery objQuery;
    if(objReader.execute(mysqlExecute, objQuery))
    {
        qDebug() << "queryGetCollumnDevInfoTagName";
        while(objQuery.next())
        {
            qDebug() << "queryGetCollumnDevInfoTagName-->" << objQuery.value(0).toString();
             if(objQuery.value(0).toString().contains(valueType))
             {
                 return objQuery.value(0).toString();
             }
        }
    }
    return QString();
}

//以第1个存在VA值的设备名为列标题时，仅deviceOrGroupType==2时使用
QString CDevSpePointWidget::queryGetDevInfoTagName(const QString &valueType, const QString &groupTagName, iot_dbms::CDbApi &objReader) const
{
    if(!objReader.isOpen())
    {
        return QString();
    }
    
    QString mysqlExecute;
    mysqlExecute = QString("SELECT analog.TAG_NAME FROM analog JOIN dev_info ON analog.DEVICE = dev_info.TAG_NAME WHERE dev_info.GROUP_TAG_NAME = '%1'").arg(groupTagName);
    QSqlQuery objQuery;
    if(objReader.execute(mysqlExecute, objQuery))
    {
        while(objQuery.next())
        {
            qDebug() << "queryGetGroupDescription-->" << objQuery.value(0).toString();
            if(objQuery.value(0).toString().contains(valueType))
            {
                return objQuery.value(0).toString().replace("." + valueType, "");
            }
        }
    }
    return QString();
}

//获取某组设备里的设备名，仅deviceOrGroupType==2时使用
QString CDevSpePointWidget::queryGetDevInfoDescription(const QString &deviceTagName, iot_dbms::CDbApi &objReader) const
{
    if(!objReader.isOpen())
    {
        return QString();
    }

    QList<QString> listColName;
    listColName.append("DESCRIPTION"); //是objCondition.m_value的组名
    iot_dbms::CDbCondition objCondition;
    objCondition.m_sColName = "TAG_NAME"; //比较的字段名
    objCondition.m_value = deviceTagName; //比较的值
    objCondition.m_eCompare = iot_dbms::CDbCondition::COMPARE_EQ; //比较条件
    objCondition.m_eLogic = iot_dbms::CDbCondition::LOGIC_AND; //两个比较条件之间的关系

    QSqlQuery objQuery;
    if(objReader.select("dev_info", listColName, objCondition, objQuery))
    {
        while(objQuery.next())
        {
            return objQuery.value(0).toString();
        }
    }
    return QString();
}