#include "graphicsDataModel/fixedPortsModel.h"
#include "graphicsItem/graphicsBaseItem.h"
#include "graphicsItem/electricSvgItemBus.h"
#include "graphicsItem/electricSvgItemRect.h"
#include "graphicsItem/electricSvgItemTriangle.h"
#include "graphicsItem/electricConnectLineItem.h"
#include "baseModelItem/electricBaseModelLineItem.h"
#include "baseModelItem/electricBaseModelSvgItem.h"
#include "baseModelItem/electricBaseModelSvgBus.h"
#include "baseModelItem/electricBaseModelLineItem.h"
#include "graphicsItem/electricBayItem.h"
#include "graphicsItem/itemPort.h"
#include "designerScene.h"
#include "dataBase.h"
#include "httpInterface.h"
#include "drawingPanel.h"
#include "itemPropertyDlg.h"
#include "dataManager.h"
#include "powerEntity.h"
#include "topologyManager.h"
#include "basePropertyManager.h"
#include "diagramCavas.h"
#include <QJsonArray>
#include <QMessageBox>
#include <QRandomGenerator>
#include "baseProperty.h"
#include "projectModelSetting.h"
#include "bayManagerDlg.h"
#include "projectModelManager.h"
#include "global.h"

bool    FixedPortsModel::_dataInitialised = false;

FixedPortsModel::FixedPortsModel(PowerEntity* pEntity)
    :_scene(nullptr)
    ,_widget(nullptr)
    ,_Interface(nullptr)
    ,_pEntity(pEntity)
    ,m_proModelSettingDlg(nullptr)
    ,m_pBayManager(nullptr)
{
    _cavas = nullptr;
    loadNodeDataFromDataBase();
    _Interface = new HttpInterface(this);
    _timer = new QTimer(this);

    _modelStateInfo = DataManager::instance().modelState();
    _modelDataInfo = DataManager::instance().modelData();
    initialPropertyDlg();
    connect(_timer,SIGNAL(timeout()),this,SLOT(onTimeOut()));
    connect(_Interface,&HttpInterface::sendPointData,this,&FixedPortsModel::onSignal_GetPointData);
}

FixedPortsModel::~FixedPortsModel()
{

}

QMap<QUuid,QPointF> FixedPortsModel::allNodePos() const
{
    QMap<QUuid,QPointF> map;
    for(auto pItem:_nodeItem)
    {
        if(pItem->getItemType() != GIT_link)
            map.insert(pItem->itemId(),pItem->pos());
    }
    return map;
}

QVector<ModelProperty*> FixedPortsModel::allConnectionProperty()
{
    QVector<ModelProperty*> vec;
    for(auto pItem:_nodeItem)
    {
        if(pItem->getItemType() == GIT_link)
        {
            auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
            if(pLine)
            {
                ModelProperty* pPro = pLine->getProperty();
                if(pPro){
                    vec.push_back(pPro);
                }
            }
        }
    }
    return vec;
}

QMap<QUuid,GraphicsProjectModelItem*>& FixedPortsModel::allItems()
{
    return _nodeItem;
}

GraphicsProjectModelItem* FixedPortsModel::nodeItem(QUuid uuid)
{
    return _nodeItem.value(uuid,nullptr);
}

bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsProjectModelItem* pItem)
{

    if(_nodeItem.contains(uuid))
        return false;
    else
    {
        _nodeItem.insert(uuid,pItem);
        connect(pItem,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
        return true;
    }
}

void FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos)
{
    //todo:load图形时必有拓扑实体，关联到对应的entity
    BaseProperty* pro = nullptr;
    GraphicsProjectModelItem* item = nullptr;
    QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();        //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
    if(mapData.contains(id))
    {
        pro = mapData.value(id);
        if(pro)
        {
            int type = pro->graphicsType();
            if(type == GIT_link)        //连线对象外部处理
                return;
            QString sMeta = pro->metaModelName();
            QString sProModel = pro->modelName();
            if(type == GIT_itemTri)
            {
                item = new ElectricSvgItemTriangle(QRect(-15, -15, 30, 30));
                item->setItemType(GIT_itemTri);
            }
            else if(type == GIT_itemRect)
            {
                PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
                QByteArray svg;
                if(model.modelSetting.mapSvg.isEmpty()){
                    svg = DataBase::GetInstance()->ModelType()[3].icon;
                }
                else{
                    svg = model.modelSetting.mapSvg.first();
                }

                auto pCb = new ElectricSvgItemRect(QRect(-15, -15, 30, 30),false);
                pCb->setItemType(GIT_itemRect);
                pCb->loadSvg(svg);
                item = pCb;
                QJsonArray portArr = pro->context()["port"].toArray();
                for(QJsonValueRef portJson:portArr)
                {
                    QJsonObject portObj = portJson.toObject();
                    QString portId = portObj["portId"].toString();
                    int x = portObj["x"].toInt();
                    int y = portObj["y"].toInt();
                    HandleType tye = HandleType(portObj["portType"].toInt());
                    PortPos locate = PortPos(portObj["locate"].toInt());
                    item->addPort(P_const,QPointF(x,y),portId,tye,locate);
                }
            }
            else if(type == GIT_bus)
            {
                PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
                QByteArray svg;
                if(model.modelSetting.mapSvg.isEmpty()){
                    svg = DataBase::GetInstance()->ModelType()[1].icon;
                }
                else{
                    svg = model.modelSetting.mapSvg.first();
                }

                auto pBus = new ElectricSvgItemBus(QRect(-100, -3, 200, 6));
                pBus->setItemType(GIT_bus);
                pBus->loadSvg(svg);
                item = pBus;

                QJsonArray portArr = pro->context()["port"].toArray();
                for(QJsonValueRef portJson:portArr)
                {
                    QJsonObject portObj = portJson.toObject();
                    QString portId = portObj["portId"].toString();
                    int x = portObj["x"].toInt();
                    int y = portObj["y"].toInt();
                    item->addPort(p_movable,QPointF(x,y),portId);
                }
            }
            if(item)
            {
                item->setItemId(id);
                item->editShape(0, pos);
                item->setPos(pos);
                //item->setSelected(true);
                _scene->addItem(item);
                item->addPoint(pos);
                item->setProperty(pro);         //绑定模型
                item->updateByProperty();       //使用模型更新自身
                QString sModel = _projectModelName.value(id.toString());
                item->setModelName(sModel);
                _nodeItem.insert(id,item);
                connect(item,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
            }
        }
    }
}

BaseProperty* FixedPortsModel::addNodeData(QUuid id,int type,QString name,QString modelName)
{
    BaseProperty* pData = BasePropertyManager::instance().findEntityData(id);       //已存在不不创建
    if(pData != nullptr)
        return pData;

    VariableProperty* item = new VariableProperty();
    //todo:关联到对应data

    if(item)
    {
        item->setUuid(id);
        item->setModelName(modelName);
        item->setType(type);
        GraphicsItemType localType = typeToProGraphic[type];        //将通用类型转换为工程模图元
        item->setGraphicsType(localType);
        item->setTag(name);
        item->setName(name);
        item->setDataChanged(true);
        BasePropertyManager::instance().insertEntityData(id,item);
    }
    return item;
}

void FixedPortsModel::loadNodeDataFromDataBase()
{
    if(!_dataInitialised)
    {
        QList<componentInfo> lst= DataBase::GetInstance()->getAllComponents();
        for(auto &info:lst)
        {
            BaseProperty* pData = addNodeData(info.uuid,info.type,info.name,info.modelName);
            pData->setTag(info.tag);
            pData->setName(info.name);
            pData->setPath(info.nspath);
            pData->setDescription(info.description);
            pData->setInService(info.inService);
            pData->setState(info.state);
            pData->setConnectedBus(info.connected_bus);
            pData->setLabel(info.label);
            pData->setContext(info.context);
            pData->setGrid(info.grid);
            pData->setZone(info.zone);
            pData->setStation(info.station);
            pData->setDataChanged(false);

            QString sMeta = info.context["metaModel"].toString();
            pData->setMetaModelName(sMeta);

            PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,info.uuid.toString(),info.name);      //首先load所有data和entity，全局唯一
            if(pEntity){
                createTopoTerminalsByData(pEntity,info.context);
            }

            QList<MeasurementInfo> lstMeasure = DataBase::GetInstance()->getMeasurement(info.uuid);     //添加设备量测
            QMap<QString,MeasurementInfo> mapMeasure;
            for(auto& info:lstMeasure)
            {
                mapMeasure.insert(info.name,info);
            }
            pData->setMeasurement(mapMeasure);
        }

        QList<topologicInfo> lstTopo = DataBase::GetInstance()->getAllTopologics();
        for(auto &info:lstTopo)
        {
            QString from_pin = info.context["from_pin"].toString();
            QString to_pin = info.context["to_pin"].toString();

            TopologyManager::instance().createConnection(QString::number(info.id),from_pin,to_pin,info.uuid_from.toString(),info.uuid_to.toString());
        }

        QList<bayInfo> lstBay = DataBase::GetInstance()->getAllBay();
        for(auto& bay:lstBay)
        {
            BayProperty* pBay = addBayData(bay.uuid);
            pBay->setName(bay.name);
            pBay->setType(bay.type);
            pBay->setLstComponent(bay.components);
            pBay->setVoltage(bay.unom);
            pBay->setFla(bay.fla);
            pBay->setCapacity(bay.capacity);
            pBay->setInService(bay.inService);
            auto fromLst = turnJsonArrToList(bay.fromUuid,"id","ids");
            pBay->setLstFrom(fromLst);
            auto toLst = turnJsonArrToList(bay.toUuid,"id","ids");
            pBay->setLstTo(toLst);
            auto proptecLst = turnJsonArrToList(bay.protect,"id","ids");
            pBay->setLstProtect(proptecLst);
            auto falRecLst = turnJsonArrToList(bay.faultRec,"id","ids");
            pBay->setLstFaultRecord(falRecLst);
            auto dynSenLst = turnJsonArrToList(bay.dynSense,"id","ids");
            pBay->setLstDynSense(dynSenLst);
            auto staLst = turnJsonArrToList(bay.status,"id","ids");
            pBay->setLstStatus(staLst);
            auto insLst = turnJsonArrToList(bay.instruct,"id","ids");
            pBay->setLstInstruct(insLst);
            auto etcLst = turnJsonArrToList(bay.etc,"id","ids");
            pBay->setLstEtc(etcLst);
        }
        _dataInitialised = true;
    }
    else
    {
        //for(auto p:_nodeData)
        {
            int a = 1;
        }
    }
}

void FixedPortsModel::addConnectLline(QUuid lineId,QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort)
{
    GraphicsProjectModelItem* src = _nodeItem[srcId];
    GraphicsProjectModelItem* dest = _nodeItem[destId];
    QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
    if(mapData.contains(lineId))
    {
        BaseProperty* pPro = mapData.value(lineId);
        if(src && dest)
        {
            ElectricConnectLineItem* pItem = new ElectricConnectLineItem();
            pItem->setItemId(lineId);
            pItem->setItemType(GIT_link);
            _scene->addItem(pItem);

            ItemPort* ptSrc = src->getPortById(srcPort.toString());
            HandleType srcType = ptSrc->getType();
            PortPos srcPos = ptSrc->portPos();
            pItem->setStartPoint(ptSrc->scenePos());
            ptSrc->setConnect(pItem);

            ItemPort* ptDest = nullptr;
            ptDest = dest->getPortById(destPort.toString());
            pItem->setEndPoint(ptDest->scenePos());

            if(ptDest != nullptr)
            {
                HandleType destType = ptDest->getType();
                PortPos destPos = ptDest->portPos();

                pItem->calculatePath();

                pPro->setConnection(Connection(srcId,srcPort,srcType,srcPos,destId,destPort,destType,destPos));
                ptDest->setConnect(pItem);

                addNodeItem(pItem->itemId(),pItem);
                pItem->setProperty(pPro);
            }
        }
    }
}

void FixedPortsModel::deleteNodeItem(GraphicsProjectModelItem* pItem)
{
    if(pItem->getItemType() == GIT_link)
    {
        auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
        if(pLine)
        {
            QUuid conId = pLine->itemId();
            TopologyManager::instance().removeConnection(conId.toString());

            PowerConnection* pCon = TopologyManager::instance().connection(conId.toString());
            if(pCon){
                PowerEntity* itemFrom = TopologyManager::instance().getEntityByTerminal(pCon->fromTerminalId());
                PowerEntity* itemTo = TopologyManager::instance().getEntityByTerminal(pCon->toTerminalId());
                if(itemFrom && itemTo)
                {
                    _nodeItem.value(QUuid(itemFrom->id()))->setItemChanged(true);
                    _nodeItem.value(QUuid(itemTo->id()))->setItemChanged(true);
                }
            }

            _nodeItem.take(conId);
            _scene->removeItem(pLine);
            delete pLine;
        }
    }
    else
    {
        QUuid srcId = pItem->itemId();
        QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(srcId.toString());
        for(auto &con:lstCon)
        {
            PowerEntity* pFrom = TopologyManager::instance().getEntityByTerminal(con->fromTerminalId());
            PowerEntity* pTo = TopologyManager::instance().getEntityByTerminal(con->toTerminalId());
            if(pFrom && pTo)
            {
                if(srcId.toString() == pFrom->id())     //对象是srcItem
                    _nodeItem.value(QUuid(pTo->id()))->setItemChanged(true);
                else        //对象是toItem
                    _nodeItem.value(QUuid(pFrom->id()))->setItemChanged(true);
            }

            //TopologyManager::instance().removeConnection(con->id());      //删除entity时会同时删除相关连接，无需手动删除
        }
        TopologyManager::instance().deleteEntity(srcId.toString());

        pItem->setItemChanged(true);
        _nodeItem.take(srcId);
        _scene->removeItem(pItem);
        delete pItem;
    }
}

void FixedPortsModel::saveNode(int nPageId)
{
    for(auto& bay:_bayItem)
    {
        AbstractProperty* pro = bay->getProperty();     //间隔
        BayProperty* pBay = dynamic_cast<BayProperty*>(pro);
        if(pBay){
            bool val = DataBase::GetInstance()->ifBayExist(pBay->uuid());
            if(!val){
                QJsonObject objFrom = turnListToJson(pBay->getLstFrom(),"id","ids");
                QJsonObject objTo= turnListToJson(pBay->getLstTo(),"id","ids");
                QJsonObject objProtec= turnListToJson(pBay->getLstProtect(),"id","ids");
                QJsonObject objFalRec= turnListToJson(pBay->getLstFaultRecord(),"id","ids");
                QJsonObject objStatus= turnListToJson(pBay->getLstStatus(),"id","ids");
                QJsonObject objDynSen= turnListToJson(pBay->getLstDynSense(),"id","ids");
                QJsonObject objIns= turnListToJson(pBay->getLstInstruct(),"id","ids");
                QJsonObject objEtc= turnListToJson(pBay->getLstEtc(),"id","ids");

                DataBase::GetInstance()->insertBay(pBay->uuid(),pBay->name(),pBay->getType(),pBay->getVoltage(),pBay->getFla(),pBay->getCapacity(),"1",pBay->getInService(),0,"1","1","1",QJsonObject(),objFrom,objTo,objProtec,objFalRec,objStatus,objDynSen,objIns,objEtc,pBay->getLstComponent(),QJsonObject());
            }
            else{
                QJsonObject objFrom = turnListToJson(pBay->getLstFrom(),"id","ids");
                QJsonObject objTo= turnListToJson(pBay->getLstTo(),"id","ids");
                QJsonObject objProtec= turnListToJson(pBay->getLstProtect(),"id","ids");
                QJsonObject objFalRec= turnListToJson(pBay->getLstFaultRecord(),"id","ids");
                QJsonObject objStatus= turnListToJson(pBay->getLstStatus(),"id","ids");
                QJsonObject objDynSen= turnListToJson(pBay->getLstDynSense(),"id","ids");
                QJsonObject objIns= turnListToJson(pBay->getLstInstruct(),"id","ids");
                QJsonObject objEtc= turnListToJson(pBay->getLstEtc(),"id","ids");

                DataBase::GetInstance()->updateBay(pBay->uuid(),pBay->name(),pBay->getVoltage(),pBay->getFla(),pBay->getCapacity(),"",pBay->getInService(),0,QJsonObject(),objFrom,objTo,objProtec,objFalRec,objStatus,objDynSen,objIns,objEtc,pBay->getLstComponent(),QJsonObject());
            }
        }
    }

    QMap<QUuid,GraphicsProjectModelItem*> mapItems = allItems();
    for(auto& pItem:mapItems)
    {
        BaseProperty* pData = dynamic_cast<BaseProperty*>(pItem->getProperty());
        if(pData){
            Connection con = pData->getConnection();
            QString fromPin = con.nSrcPortId.toString();
            QString toPin = con.nDestPortId.toString();
            QJsonObject context;
            context["from_pin"] = fromPin;
            context["to_pin"] = toPin;
            if(pData->prepareDelete())
            {
                DataBase::GetInstance()->deleteComponent(pData->uuid().toString());
                if(pData->type() == 8){
                    PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
                    if(pCon){
                        DataBase::GetInstance()->deleteTopologic(con.nSrcPortId,con.nDestPortId);
                        TopologyManager::instance().removeConnection(pCon->id());
                    }
                }
                continue;
            }
            if(pData->dataChanged())
            {
                pData->setDataChanged(false);
                bool exist = DataBase::GetInstance()->componentExist(pData->uuid().toString());
                VariableProperty* pVariable = dynamic_cast<VariableProperty*>(pData);
                if(pVariable)
                {
                    modelDataInfo& dataInfo = pVariable->getPropertyValue();
                    if(exist)       //已存在更新
                    {
                        DataBase::GetInstance()->updateComponent(pData->uuid(),pData->tag(),pData->name(),pData->context());
                        for(auto &val:dataInfo.groupInfo)
                        {
                            if(val.groupName == "component")
                                continue;
                            DataBase::GetInstance()->updateDynamicProperty(pData->uuid(),val);
                            if(val.mapInfo.contains(pData->uuid())){        //保存时将数据锁复原
                                auto& mapPro = val.mapInfo[pData->uuid()];
                                for(auto& pro:mapPro)
                                {
                                    pro.lock = false;
                                }
                            }
                        }
                    }
                    else
                    {
                        DataBase::GetInstance()->insertComponent(pData->uuid(),pData->modelName(),pData->path(),pData->tag(),pData->name(),pData->description(),pData->grid(),pData->zone(),pData->station(),pData->type(),true,pData->state(),pData->status(),pData->connectedBus(),pData->label(),pData->context(),1);
                        for(auto &val:dataInfo.groupInfo)
                        {
                            if(val.groupName == "component")
                                continue;
                            DataBase::GetInstance()->insertDynamicProperty(pData->uuid(),val);
                            if(val.mapInfo.contains(pData->uuid())){        //保存时将数据锁复原
                                auto& mapPro = val.mapInfo[pData->uuid()];
                                for(auto& pro:mapPro)
                                {
                                    pro.lock = false;
                                }
                            }
                        }
                    }

                    QMap<QString,MeasurementInfo> mapMeasure = pData->getMeasurement();     //量测

                    QList<MeasurementInfo> lstDataBase = DataBase::GetInstance()->getMeasurement(pData->uuid());        //数据库中现有量测
                    for(auto& info:mapMeasure)
                    {
                        int tpe = 0;        //todo:建立类型映射表
                        if(info.type == "遥测"){
                            tpe = 0;
                        }
                        else if(info.type == "遥信"){
                            tpe = 1;
                        }
                        else if(info.type == "遥控"){
                            tpe = 2;
                        }
                        else if(info.type == "遥调"){
                            tpe = 3;
                        }
                        else if(info.type == "整定值"){
                            tpe = 4;
                        }
                        QJsonObject obj;
                        obj["type"] = info.equipment;
                        obj["main_pos"] = info.channel;
                        bool val = DataBase::GetInstance()->ifMeasureExist(info.name,pData->uuid());
                        if(val){
                            DataBase::GetInstance()->updateMeasurement(info.name,tpe,obj,info.size,pData->uuid());
                        }
                        else{
                            DataBase::GetInstance()->insertMeasurement(info.name,info.tag,tpe,obj,info.size,info.bayUuid,info.componentUuid);
                        }

                        for(int i = 0;i < lstDataBase.size();++i)       //从数据库记录中移除操作过的对象
                        {
                            if(lstDataBase[i].name == info.name){
                                lstDataBase.removeAt(i);
                                break;
                            }
                        }
                    }

                    for(auto& info:lstDataBase)     //操作的记录小于数据库中的记录，删除库中多出的记录
                    {
                        DataBase::GetInstance()->delteMeasurement(info.name,info.componentUuid);
                    }
                }

                if(pData->type() == 8){
                    PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
                    if(pCon){
                        int id = DataBase::GetInstance()->topologicExist(con.nSrcNodeId,con.nDestNodeId);
                        if(id == -1)
                            DataBase::GetInstance()->insertTopologic(con.nSrcNodeId,con.nDestNodeId,context,0,"",0);
                    }
                }
            }
        }
    }
}

void FixedPortsModel::onSignal_ifExits(QUuid id,const QString& str,int type,GraphicsProjectModelItem* pitem)
{
    bool exist = false;
    BaseProperty* pData = nullptr;
    QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
    for(auto pro:mapData)
    {
        if(pro->tag() == str)
        {
            pData = pro;
            exist = true;
            break;
        }
    }
    if(exist)           //已存在，将发出信号的item绑定到此data
    {
        if(_nodeItem.contains(id))      //发出信号对象id与data对象id相同，已绑定,不做响应
            return;
        QMessageBox msgBox;
        msgBox.setText(QString::fromWCharArray(L"提示"));
        msgBox.setInformativeText(QString::fromWCharArray(L"此名称对象已存在,是否使用该对象?"));
        msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
        msgBox.setDefaultButton(QMessageBox::Cancel);
        int ret = msgBox.exec();
        switch (ret) {
        case QMessageBox::Ok:
        {
            //todo:断开原来的连接关系
            pitem->setProperty(pData);
            pitem->setItemId(pData->uuid());
            PowerEntity* pEntity = TopologyManager::instance().findEntity(pData->uuid().toString());
            if(pEntity){
                pitem->setEntity(pEntity);          //item对象的逻辑接线点无需重复创建
            }
            _nodeItem.take(id);
            _nodeItem.insert(pData->uuid(),pitem);
        }
        break;
        case QMessageBox::Cancel:
            // Cancel was clicked
            break;
        default:
            // should never be reached
            break;
        }
    }
    else                //创建新data并绑定
    {
        BaseProperty* pData = addNodeData(id,type,str,pitem->getModelName());
        if(pData)
        {
            pitem->setProperty(pData);
            pData->setDataChanged(true);        //数据状态改变
        }

        PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,id.toString(),str);
        if(pEntity)
            pitem->setEntity(pEntity);
        createTopoTerminalsByItem(pitem);             //创建item对象的逻辑接线点
    }
}


void FixedPortsModel::onTimeOut()
{
    _Interface->getPointData("i");
    _Interface->getPointData("v");
}

void FixedPortsModel::onSignal_GetPointData(QString type,QMap<qint64,double> map)
{
    if(map.size() == 1)         //实时数据
    {
        double d = map.first();

        //for(auto pro:_nodeData)         //demo版本只有一个数据
        {
            //int t = pro->type();
            //if(t == GIT_itemRect)
            {
                //todo:根据id匹配数据
                /*auto p = dynamic_cast<ElectricSvgItemRect_Property*>(pro);
                if(p)
                {
                    p->notifyUpdate();  //通知更新
                }*/
            }
        }
    }
}

void FixedPortsModel::onSignal_generateDiagram(const QString& sName)
{
    QStringList lstInfo;
    for(auto& item:_baseItem){
        BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(item->getProperty());
        if(pBase){
            QString sModel = pBase->getModelProperty().modelSetting.modelName;
            if(sModel.isEmpty()){
                lstInfo.append(pBase->name());
            }
        }
    }
    if(!lstInfo.isEmpty()){
        QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"%1未设置完毕").arg(lstInfo.join("、")));
        return;
    }

    QList<GraphicsBaseModelItem*> lst;
    for(auto& item:_baseItem)
    {
        lst.append(item);
    }

    QList<GraphicsNonStandardItem*> lstBay;
    for(auto& item:_bayItem)
    {
        lstBay.append(item);
    }
    generateProjectModel(sName,lst,lstBay);
}

void FixedPortsModel::onSignal_openBayManager()
{
    if(m_pBayManager == nullptr){
        m_pBayManager = new BayManagerDlg(_widget);
        m_pBayManager->setModelController(this);
    }
    m_pBayManager->showDlg();
}

void FixedPortsModel::startHttpRequest()
{
    if(_timer)
    {
        _timer->setInterval(1000);
        _timer->start();
    }
}

QWidget* FixedPortsModel::getTopWidget()
{
    return dynamic_cast<QWidget*>(_widget);
}

QPointF FixedPortsModel::getTerminalPos(const QString& sTerminalId)
{
    PowerEntity* pParent = TopologyManager::instance().getEntityByTerminal(sTerminalId);
    if(pParent)
    {
        for(auto &item:_nodeItem)
        {
            if(pParent->id() == item->itemId().toString())      //找到terminal父图元
            {
                for(auto &pPort:item->getPorts())
                {
                    if(pPort->getId() == sTerminalId)
                    {
                        return pPort->scenePos();
                    }
                }
            }
        }
    }
    return QPointF(0,0);
}

ElectricConnectLineItem* FixedPortsModel::getLineItemById(const QString& terminalId)
{
    for(auto iter:_nodeItem)        //获取id所在的lineitem
    {
        auto item = dynamic_cast<GraphicsProjectModelItem*>(iter);
        if(item)
        {
            if(item->getItemType() == GIT_link)
            {
                PowerConnection* pCon = TopologyManager::instance().getConnectionContainsTerminal(terminalId);
                if(pCon)
                {
                    if(item->itemId().toString() == pCon->id())
                        return dynamic_cast<ElectricConnectLineItem*>(item);
                }
            }
        }
    }
    return nullptr;
}

void FixedPortsModel::showModelDlg(const QString& sName,QUuid uuid,GraphicsProjectModelItem* pItem)
{
    modelStateInfo stateInfo = _modelStateInfo[sName];
    ModelDataMap mapData = DataManager::instance().modelData();
    ItemPropertyDlg* pDlg = dynamic_cast<ItemPropertyDlg*>(stateInfo._PropertyDlg);
    if(pDlg)
    {
        pDlg->showDlg(mapData[sName],uuid,pItem);
    }
    else
        qDebug()<<"showModelDlg err";
}

void FixedPortsModel::initialPropertyDlg()
{
    for(auto &modelInfo:_modelStateInfo)
    {
        if(modelInfo._PropertyDlg == NULL)
        {
            generatePropertyDlg(modelInfo.modelName);
        }
    }
}

void FixedPortsModel::generatePropertyDlg(const QString& sModel)
{
    modelStateInfo info = _modelStateInfo[sModel];
    if(info._PropertyDlg == NULL)
    {
        ItemPropertyDlg* dlg = new ItemPropertyDlg(_widget);
        if(dlg)
        {
            dlg->setModelController(this);
            dlg->loadGroupButton(info.groupInfo);
            _modelStateInfo[sModel]._PropertyDlg = dlg;
        }
    }
}

ConfigurationDiagram* FixedPortsModel::getTopologyDiagram()
{
    return dynamic_cast<ConfigurationDiagram*>(_pEntity);
}

void FixedPortsModel::createTopoTerminalsByData(PowerEntity* pParent,QJsonObject componentCon,ModelFunctionType funType)
{
    QJsonArray portsArray = componentCon["port"].toArray();
    for (QJsonValueRef portJson : portsArray)   //每个属性的状态信息
    {
        QJsonObject node = portJson.toObject();
        QString portId = node["portId"].toString();
        int x = node["x"].toInt();
        int y = node["y"].toInt();
        PortPos locate = PortPos(node["locate"].toInt());
        HandleType portType = HandleType(node["portType"].toInt());

        TerminalType terType;
        switch (portType) {
        case T_lineIn:
            terType = TerminalType::PowerInput;
            break;
        case T_lineOut:
            terType = TerminalType::PowerOutput;
            break;
        case T_lineInOut:
            terType = TerminalType::PowerConnect;
            break;
        default:
            break;
        }
        TopologyManager::instance().createTerminal(pParent->id(),terType,"",QPointF(x,y),portId,funType);
    }
}

bool FixedPortsModel::isItemValid(GraphicsProjectModelItem* pItem)
{
    ModelProperty* pData = pItem->getProperty();
    PowerEntity* pEntity = pItem->entity();
    return (pData != nullptr && pEntity != nullptr)?true:false;
}


void FixedPortsModel::insertProjectModelName(QString uuid,QString name)
{
    if(!_projectModelName.contains(uuid))
        _projectModelName.insert(uuid,name);
}
/*********************baseModel**********************/

QMap<QUuid,GraphicsBaseModelItem*>& FixedPortsModel::allBaseItems()
{
    return _baseItem;
}

QVector<Connection> FixedPortsModel::allBaseConnections()
{
    QVector<Connection> vec;
    for(auto pItem:_baseItem)
    {
        if(pItem->getItemType() == GIT_baseLine)
        {
            auto pLine = dynamic_cast<ElectricBaseModelLineItem*>(pItem);
            if(pLine)
            {
                vec.push_back(pLine->getProperty()->getConnection());
            }
        }
    }
    return vec;
}

QMap<QUuid,QPointF> FixedPortsModel::allBaseNodePos() const
{
    QMap<QUuid,QPointF> map;
    for(auto pItem:_baseItem)
    {
        if(pItem->getItemType() != GIT_baseLine)
            map.insert(pItem->itemId(),pItem->pos());
    }
    return map;
}

bool FixedPortsModel::addBaseItem(QUuid uuid,GraphicsBaseModelItem* pItem)
{
    if(_baseItem.contains(uuid))
        return false;
    else
    {
        _baseItem.insert(uuid,pItem);
        return true;
    }
}

BaseModelProperty* FixedPortsModel::addBaseNodeData(QUuid id,int type,QString name,QString metaName,QString bay)
{
    BaseModelProperty* pData = BasePropertyManager::instance().findBaseEntityData(id);       //已存在不不创建
    if(pData != nullptr)
        return pData;

    BaseModelProperty* item = new BaseModelProperty(this);

    if(item)
    {
        item->setUuid(id);
        item->setMetaModelName(metaName);
        item->setType(type);
        item->setTag(name);
        item->setName(name);
        if(!bay.isEmpty())
            item->setBay(bay);
        BasePropertyManager::instance().insertBaseEntityData(id,item);
    }
    return item;
}

void FixedPortsModel::showProjectModelSettingDlg(GraphicsBaseModelItem* srcItem)
{
    if(m_proModelSettingDlg == nullptr)
    {
        m_proModelSettingDlg = new ProjectModelSetting(_widget);
        m_proModelSettingDlg->setController(this);
    }
    m_proModelSettingDlg->showDlg(srcItem);
}

void FixedPortsModel::generateProjectModel(const QString& sPageName,QList<GraphicsBaseModelItem*> lstItem,QList<GraphicsNonStandardItem*> lstOther)
{
    DrawingPanel* pProPanel = nullptr;
    if(_cavas){
        DiagramInfo info;
        info.id = QUuid::createUuid();
        info.sName = sPageName;
        info.sTag = sPageName;
        info.sBasePageName = _pageName;
        _cavas->onSignal_createDiagram(info);
        pProPanel = _cavas->getPanel(sPageName);
    }

    for(auto& pBaseItem:lstItem)        //第二次循环处理所有连线对象
    {
        BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(pBaseItem->getProperty());
        if(pBase->type() == 8){         //电缆
            QUuid id = QUuid::createUuid();
            BaseProperty* pData = pProPanel->getModelController()->addNodeData(id,pBase->type(),pBase->name(),pBase->modelName());
            if(pData)
            {
                pData->setDataChanged(true);        //数据状态改变
                addProjectItemByBaseData(pProPanel,pBaseItem,pData);
            }
        }
    }

    QList<BaseProperty*> lstProData;
    QMap<QUuid,GraphicsProjectModelItem*> mapItem = pProPanel->getModelController()->allItems();        //根据item获取data
    for(auto& item:mapItem){
        BaseProperty* pPro = dynamic_cast<BaseProperty*>(item->getProperty());
        if(pPro){
            lstProData.append(pPro);
        }
    }

    for(auto& pOtherItem:lstOther)
    {
        BayProperty* pBay = dynamic_cast<BayProperty*>(pOtherItem->getProperty());
        if(pBay){
            BayProperty* pData = pProPanel->getModelController()->generateBayData(pBay,lstProData);
            if(pData)
            {
                pProPanel->getModelController()->addBayByData(pData);
            }
        }
    }
}

void FixedPortsModel::addProjectItemByBaseData(DrawingPanel* pPanel,GraphicsBaseModelItem* pItem,BaseProperty* pPro)
{
    BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(pItem->getProperty());
    if(pBase){
        if(_baseItem.contains(pBase->uuid())){
            GraphicsProjectModelItem* pProItem = nullptr;
            GraphicsBaseModelItem* pBaseItem = _baseItem.value(pBase->uuid());
            pPro->setSourceItemId(pBaseItem->itemId().toString());      //设置被哪个对象生成
            pPro->setMetaModelName(pBase->metaModelName());        //传递基模名
            int type = pBase->graphicsType();
            if(type == GIT_baseBus)
            {
                QByteArray svg;
                if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
                    svg = DataBase::GetInstance()->ModelType()[1].icon;
                }
                else{
                    svg = pBase->getModelProperty().modelSetting.mapSvg.first();
                }
                QRectF rec = pBaseItem->boundingRect();
                auto pBus = new ElectricSvgItemRect(rec.toRect());
                pBus->loadSvg(svg);
                pProItem = pBus;
                pProItem->setItemType(GIT_bus);
            }
            else if(type == GIT_baseBreaker)
            {
                QByteArray svg;
                if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
                    svg = DataBase::GetInstance()->ModelType()[3].icon;
                }
                else{
                    svg = pBase->getModelProperty().modelSetting.mapSvg.first();
                }
                QRectF rec = pBaseItem->boundingRect();
                auto pBreaker = new ElectricSvgItemRect(rec.toRect());
                pBreaker->loadSvg(svg);
                pProItem = pBreaker;
                pProItem->setItemType(GIT_itemRect);
            }
            else if(type == GIT_baseLine)
            {
                pProItem = new ElectricConnectLineItem();
                pProItem->setItemId(pPro->uuid());
                pProItem->setItemType(GIT_link);
                pPanel->getScene()->addItem(pProItem);
            }

            if(pBase->graphicsType() != GIT_baseLine)       //非连接线对象
            {
                PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,pPro->uuid().toString(),pBase->name());
                QList<PowerTerminal*> lstBase = TopologyManager::instance().getTerminalsForEntity(pBase->uuid().toString(),ModelFunctionType::BaseModel);      //获取基模的逻辑点
                for(auto& baseTer:lstBase)
                {
                    QUuid uid = QUuid::createUuid();
                    PowerTerminal* proTer = TopologyManager::instance().createTerminal(pEntity->id(),baseTer->type(),"",baseTer->relativePosition(),uid.toString(),ModelFunctionType::ProjectModel);
                    proTer->setGenerateBy(baseTer->id());
                    if(proTer->type() == TerminalType::PowerConnect)
                    {
                        pProItem->addPort(p_movable,proTer->relativePosition(),proTer->id());
                        ItemPort* pPort = pProItem->getPortById(proTer->id());
                        pPort->setSourcePortId(baseTer->id());
                    }
                    else if(proTer->type() == TerminalType::PowerInput || proTer->type() == TerminalType::PowerOutput)
                    {
                        HandleType typ;
                        if(proTer->type() == TerminalType::PowerInput){
                            typ = T_lineIn;
                        }
                        else{
                            typ = T_lineOut;
                        }
                        QPointF pos = proTer->relativePosition();
                        PortPos locate;
                        if(pos.x() < 0)
                        {
                            locate = P_left;
                        }
                        else if(pos.x() > 0)
                        {
                            locate = P_right;
                        }
                        else if(pos.y() > 0)
                        {
                            locate = P_down;
                        }
                        else if(pos.y() < 0)
                        {
                            locate = P_top;
                        }
                        pProItem->addPort(P_const,pos,proTer->id(),typ,locate);

                        ItemPort* pPort = pProItem->getPortById(proTer->id());
                        pPort->setSourcePortId(baseTer->id());
                    }
                }

                pProItem->setItemId(QUuid(pEntity->id()));
                pProItem->updateHandles();
                pProItem->setPos(pBaseItem->pos());
                pPanel->getScene()->addItem(pProItem);
                pProItem->setProperty(pPro);         //绑定模型
                pProItem->updateByProperty();       //使用模型更新自身
                //QString sModel = _projectModelName.value(id.toString());
                //QString sModel = pBase->getModelProperty().modelSetting.modelName;
                //pProItem->setModelName(sModel);
                pPanel->getModelController()->addNodeItem(QUuid(pEntity->id()),pProItem);
            }
            else            //连接线对象
            {
                PowerConnection* pCon = TopologyManager::instance().connection(pBase->uuid().toString(),ModelFunctionType::BaseModel);
                if(pCon){
                    //基模connect参数
                    QString baseFromComponentId = pCon->fromComponent();
                    QString baseToComponentId = pCon->toComponent();
                    QString baseFromTerId = pCon->fromTerminalId();
                    QString baseToTerId = pCon->toTerminalId();

                    QMap<QUuid,BaseProperty*> mapPro = BasePropertyManager::instance().getEntityData();
                    bool proFromExist = false;         //工程模from对象是否生成
                    bool proToExist = false;           //工程模to对象是否生成

                    QString proFromItemId;
                    QString proToItemId;
                    QString proFromTerId;
                    QString proToTerId;
                    HandleType proFromType;
                    PortPos    proFromPos;
                    HandleType proToType;
                    PortPos    proToPos;
                    for(auto& pPro:mapPro)
                    {
                        if(pPro->getSourceItemId() == baseFromComponentId){
                            proFromExist = true;
                            proFromItemId = pPro->uuid().toString();
                            continue;
                        }
                        if(pPro->getSourceItemId() == baseToComponentId){
                            proToExist = true;
                            proToItemId = pPro->uuid().toString();
                            continue;
                        }
                    }

                    if(!proFromExist)          //工程模from对象未生成
                    {
                        GraphicsBaseModelItem* pFromItem = _baseItem.value(QUuid(baseFromComponentId));
                        QUuid id = QUuid::createUuid();
                        BaseProperty* pData = pPanel->getModelController()->addNodeData(id,pFromItem->getProperty()->type(),pFromItem->getProperty()->name(),pFromItem->getProperty()->modelName());
                        addProjectItemByBaseData(pPanel,pFromItem,pData);
                        proFromItemId = id.toString();
                    }

                    if(!proToExist)            //工程模to对象未生成
                    {
                        GraphicsBaseModelItem* pToItem = _baseItem.value(QUuid(baseToComponentId));
                        QUuid id = QUuid::createUuid();
                        BaseProperty* pData = pPanel->getModelController()->addNodeData(id,pToItem->getProperty()->type(),pToItem->getProperty()->name(),pToItem->getProperty()->modelName());
                        addProjectItemByBaseData(pPanel,pToItem,pData);
                        proToItemId = id.toString();
                    }

                    GraphicsProjectModelItem* proFrom = pPanel->getModelController()->nodeItem(QUuid(proFromItemId));
                    GraphicsProjectModelItem* proTo = pPanel->getModelController()->nodeItem(QUuid(proToItemId));
                    if(proFrom){
                        QMap<QString,ItemPort*> mapFrom = proFrom->getPorts();
                        for(auto& port:mapFrom){
                            if(port->getSourcePortId() == baseFromTerId){
                                proFromTerId = port->getId();
                                proFromType = port->getType();
                                proFromPos = port->portPos();
                                auto pLine = dynamic_cast<ElectricConnectLineItem*>(pProItem);
                                if(pLine)
                                    pLine->setStartPoint(port->scenePos());
                            }
                        }
                    }

                    if(proTo){
                        QMap<QString,ItemPort*> mapTo = proTo->getPorts();
                        for(auto& port:mapTo){
                            if(port->getSourcePortId() == baseToTerId){
                                proToTerId = port->getId();
                                proToType = port->getType();
                                proToPos = port->portPos();
                                auto pLine = dynamic_cast<ElectricConnectLineItem*>(pProItem);
                                if(pLine)
                                    pLine->setEndPoint(port->scenePos());
                            }
                        }
                    }

                    PowerConnection* pCon = TopologyManager::instance().createConnection(pPro->uuid().toString(),proFromTerId,proToTerId,proFromItemId,proToItemId);
                    auto pLine = dynamic_cast<ElectricConnectLineItem*>(pProItem);
                    if(pLine)
                        pLine->calculatePath();
                    pPanel->getModelController()->addNodeItem(pBase->uuid(),pProItem);
                    pProItem->setProperty(pPro);
                    pPro->setConnection(Connection(QUuid(proFromItemId),QUuid(proFromTerId),proFromType,proFromPos,QUuid(proToItemId),QUuid(proToTerId),proToType,proToPos));
                }
            }
            QString sModel = pBase->getModelProperty().modelSetting.modelName;
            pProItem->setModelName(sModel);
        }
    }
}

void FixedPortsModel::addBayItem(QUuid id)
{
    QMap<QUuid,BayProperty*> mapData = BasePropertyManager::instance().getBayData();        //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
    if(mapData.contains(id))
    {
        BayProperty* pro = mapData.value(id);
        if(pro)
        {
            addBayByData(pro);
        }
    }
}

bool FixedPortsModel::addBayItem(QUuid id,ElectricBayItem* pBay)
{
    if(_bayItem.contains(id))
        return false;
    else
    {
        _bayItem.insert(id,pBay);
        return true;
    }
}

void FixedPortsModel::addItemsToBay(QList<GraphicsBaseItem*> lstItem,ElectricBayItem* pBay)
{
    if(pBay == nullptr)
        return;
    BayProperty* proBay = dynamic_cast<BayProperty*>(pBay->getProperty());
    if(proBay){
        for(auto& item:lstItem){
            if(item){
                ModelProperty* p = item->getProperty();
                auto lstCom = proBay->getLstComponent();
                if(!lstCom.contains(p->uuid())){
                    proBay->getLstComponent().append(p->uuid());
                }
            }
        }
    }
}

BayProperty* FixedPortsModel::addBayData(QUuid uuid)
{
    BayProperty* pData = BasePropertyManager::instance().findBayData(uuid);       //已存在不不创建
    if(pData != nullptr)
        return pData;

    BayProperty* item = new BayProperty();

    if(item)
    {
        item->setUuid(uuid);
        BasePropertyManager::instance().insertBayData(uuid,item);
    }
    return item;
}

QMap<QUuid,ElectricBayItem*>& FixedPortsModel::allBayItem()
{
    return _bayItem;
}

BayProperty* FixedPortsModel::generateBayData(BayProperty* pData,QList<BaseProperty*> lst)
{
    QUuid id = QUuid::createUuid();
    BayProperty* p = addBayData(id);
    p->setTag(pData->tag());
    p->setName(pData->name());
    p->setType(pData->getType());
    p->setVoltage(pData->getVoltage());
    p->setFla(pData->getFla());
    p->setCapacity(pData->getCapacity());
    p->setInService(pData->getInService());
    QList<QUuid> lstCompo =  pData->getLstComponent();
    QList<QUuid> lstNewCompo = getCorrespondId(lstCompo,lst);       //将基模component替换为工程模component
    p->setLstComponent(lstNewCompo);

    QList<QUuid> lstFrom =  pData->getLstFrom();
    QList<QUuid> lstNewFrom  = getCorrespondId(lstFrom,lst);
    p->setLstFrom(lstNewFrom);

    QList<QUuid> lstTo =  pData->getLstTo();
    QList<QUuid> lstNewTo  = getCorrespondId(lstTo,lst);
    p->setLstTo(lstNewTo);

    QList<QUuid> lstProtect =  pData->getLstProtect();
    QList<QUuid> lstNewProtect  = getCorrespondId(lstProtect,lst);
    p->setLstProtect(lstNewProtect);

    QList<QUuid> lstFaultRecord =  pData->getLstFaultRecord();
    QList<QUuid> lstNewFaultRecord = getCorrespondId(lstFaultRecord,lst);
    p->setLstFaultRecord(lstNewFaultRecord);

    QList<QUuid> lstDynSense =  pData->getLstDynSense();
    QList<QUuid> lstNewDynSense = getCorrespondId(lstDynSense,lst);
    p->setLstDynSense(lstNewDynSense);

    QList<QUuid> lstStatus =  pData->getLstStatus();
    QList<QUuid> lstNewStatus = getCorrespondId(lstStatus,lst);
    p->setLstStatus(lstNewStatus);

    QList<QUuid> lstInstruct =  pData->getLstInstruct();
    QList<QUuid> lstNewInstruct = getCorrespondId(lstInstruct,lst);
    p->setLstInstruct(lstNewInstruct);

    QList<QUuid> lstEtc =  pData->getLstEtc();
    QList<QUuid> lstNewEtc= getCorrespondId(lstEtc,lst);
    p->setLstEtc(lstNewEtc);
    return p;
}

QList<QUuid> FixedPortsModel::getCorrespondId(QList<QUuid> lstCompo,QList<BaseProperty*> lst)
{
    QList<QUuid> lstNewCompo;
    for(auto& uuid:lstCompo)
    {
        for(auto& basePro:lst)
        {
            if(basePro->getSourceItemId() == uuid.toString()){      //工程模sourceid等于基模存储的componentid，
                lstNewCompo.append(basePro->uuid());
                break;
            }
        }
    }
    return lstNewCompo;
}

QRectF FixedPortsModel::calculateItemsBoundingRect(QList<GraphicsBaseItem*> items)
{
    if (items.isEmpty())
        return QRectF();

    // 初始化矩形为第一个item的场景边界矩形
    QRectF boundingRect = items.first()->sceneBoundingRect();

    // 遍历剩余item，扩展矩形以包含所有item
    for (int i = 1; i < items.size(); ++i) {
        QGraphicsItem* item = items.at(i);
        // 确保item在场景中且有效
        if (item && item->scene()) {
            boundingRect = boundingRect.united(item->sceneBoundingRect());
        }
    }
    return boundingRect.adjusted(-10,-10,10,10);
}

void FixedPortsModel::addBayByData(BayProperty* pData)
{
    QList<GraphicsBaseItem*> items;
    QList<QUuid> lstCompo = pData->getLstComponent();
    for(auto& id:lstCompo){
        if(_nodeItem.contains(id)){
            items.append(_nodeItem.value(id));
        }
    }

    QRectF rec = calculateItemsBoundingRect(items);
    auto pBay = new ElectricBayItem(rec);
    pBay->setItemType(GIT_bay);
    pBay->setProperty(pData);
    pBay->setText(pData->name());
    addBayItem(pData->uuid(),pBay);
    getScene()->addItem(pBay);
}

void FixedPortsModel::addTestData()
{
    QUuid breakerId = QUuid::createUuid();
    ElectricBaseModelSvgItem* pBreaker = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
    pBreaker->setItemId(breakerId);
    pBreaker->setItemType(GIT_baseBreaker);
    QByteArray byte = DataBase::GetInstance()->ModelType()[3].icon;
    pBreaker->loadSvg(byte);
    PowerEntity* pEntityBreaker = TopologyManager::instance().createEntity(EntityType::Component,breakerId.toString(),"断路器1",ModelFunctionType::BaseModel);
    if(pEntityBreaker)
        pBreaker->setEntity(pEntityBreaker);
    BaseModelProperty* pBreakerData = addBaseNodeData(breakerId,3,"断路器1",DataBase::GetInstance()->ModelType()[3].modelType);
    pBreakerData->setGraphicsType(GIT_baseBreaker);
    if(pBreakerData)
    {
        pBreaker->setProperty(pBreakerData);
        pBreaker->initialPortsByDatabase(3);
        createTopoTerminalsByItem(pBreaker,ModelFunctionType::BaseModel);
        pBreakerData->setDataChanged(true);        //数据状态改变
    }
    addBaseItem(breakerId,pBreaker);
    _scene->addItem(pBreaker);
    pBreaker->setPos(QPointF(0,50));


    QUuid busId = QUuid::createUuid();
    ElectricBaseModelSvgBus* pBus = new ElectricBaseModelSvgBus(QRect(-200, -3, 400, 6));
    pBus->setItemId(busId);
    pBus->setItemType(GIT_baseBus);
    //pBreaker->initialPortsByDatabase();
    QByteArray byte1 = DataBase::GetInstance()->ModelType()[1].icon;
    pBus->loadSvg(byte1);
    //createTopoTerminalsByItem(pBreaker);
    BaseModelProperty* pBusData = addBaseNodeData(busId,1,"母线1",DataBase::GetInstance()->ModelType()[1].modelType);
    pBusData->setGraphicsType(GIT_baseBus);
    if(pBusData)
    {
        pBus->setProperty(pBusData);
        pBusData->setDataChanged(true);        //数据状态改变
    }
    PowerEntity* pEntityBus = TopologyManager::instance().createEntity(EntityType::Component,busId.toString(),"母线1",ModelFunctionType::BaseModel);
    if(pEntityBus)
        pBus->setEntity(pEntityBus);
    addBaseItem(busId,pBus);
    _scene->addItem(pBus);
    pBus->setPos(QPointF(0,150));

    QUuid lineId = QUuid::createUuid();
    ElectricBaseModelLineItem* pLine = new ElectricBaseModelLineItem();
    pLine->setItemId(lineId);
    pLine->setItemType(GIT_baseLine);
    BaseModelProperty* pLineData = addBaseNodeData(lineId,8,"电缆1",DataBase::GetInstance()->ModelType()[4].modelType);
    pLineData->setGraphicsType(GIT_baseLine);
    if(pLineData)
    {
        pLine->setProperty(pLineData);
        pLineData->setDataChanged(true);        //数据状态改变
    }
    addBaseItem(lineId,pLine);
    establishConnection(pBreaker,pBus,pLine,ModelFunctionType::BaseModel);
    _scene->addItem(pLine);

    QList<GraphicsBaseItem*> lst;
    lst.append(pBreaker);
    QRectF rec = calculateItemsBoundingRect(lst);
    ElectricBayItem* pBay = new ElectricBayItem(rec);
    pBay->setItemType(GIT_bay);
    pBay->setText("间隔1");
    QUuid bayId = QUuid::createUuid();
    BayProperty* pBayData = addBayData(bayId);
    pBay->setProperty(pBayData);
    pBayData->setName("间隔1");
    pBayData->setTag("间隔1");
    pBayData->getLstComponent().append(breakerId);
    addBayItem(bayId,pBay);
    addItemsToBay(lst,pBay);
    _scene->addItem(pBay);
    QString s = pageName();
    int a = 1;
}

QJsonObject FixedPortsModel::turnListToJson(QList<QUuid> lst,QString sInerTag,QString sOutTag)
{
    QJsonObject o;
    QJsonArray arr;
    if(lst.isEmpty())
        return QJsonObject();
    for(auto id:lst)
    {
        QJsonObject obj;
        obj[sInerTag] = id.toString();
        arr.push_back(obj);
    }
    o[sOutTag] = arr;
    return o;
}

QList<QUuid> FixedPortsModel::turnJsonArrToList(QJsonObject object,QString sInner,QString sOut)
{
    QJsonArray jsonArray = object[sOut].toArray();

    QList<QUuid> lst;
    for (QJsonValueRef nodeJson : jsonArray)
    {
        QJsonObject node = nodeJson.toObject();
        QUuid uid = QUuid(node[sInner].toString());
        lst.append(uid);
    }
    return lst;
}