#include "graphicsDataModel/diagramEditorModel.h"
#include "basePropertyManager.h"
#include "baseProperty.h"
#include "powerEntity.h"
#include "graphicsItem/graphicsBaseItem.h"
#include "powerTerminal.h"
#include "graphicsItem/itemPort.h"
#include "topologyManager.h"
#include "baseModelItem/electricBaseModelSvgItem.h"
#include "dataBase.h"
#include "diagramEditor/editScene.h"
#include "baseModelItem/electricBaseModelPortItem.h"
#include "baseModelItem/electricBaseModelSvgBus.h"
#include "baseModelItem/electricBaseModelLineItem.h"
#include "diagramEditor/diagramEditorBaseBlock.h"
#include "diagramEditor/editItems.h"
#include "diagramEditor/editPanel.h"
#include "diagramEditor/diagramEditorWizard.h"
#include "diagramEditor/diagramEditorStructContainer.h"

DiagramEditorModel::DiagramEditorModel()
    :_pCurBayRoute(nullptr)
    ,_pCurBayComponent(nullptr)
    ,_pCurPreviewScene(nullptr)
    ,_pCurTransComponent(nullptr)
    ,_pPanel(nullptr)
{

}

DiagramEditorModel::~DiagramEditorModel()
{

}

bool DiagramEditorModel::addPreviewItem(QUuid uuid,GraphicsBaseModelItem* pItem,int mode)
{
    if(mode == 0){
        if(_tempItem.contains(uuid))
            return false;
        else
        {
            _tempItem.insert(uuid,pItem);
            return true;
        }
    }
    else if(mode == 1){
        if(_previewItem.contains(uuid))
            return false;
        else
        {
            _previewItem.insert(uuid,pItem);
            return true;
        }
    }
    return false;
}

DiagramEditorItemProperty* DiagramEditorModel::addPreviewData(QUuid id,int type,QString name,QString metaName,QString sBlock,int mode)
{
    DiagramEditorItemProperty* pData = nullptr;
    if(mode == 0){
        pData = BasePropertyManager::instance().findTempEditorData(id);       //已存在不不创建
    }
    else if(mode == 1){
        pData = BasePropertyManager::instance().findEditorData(id);
    }

    if(pData != nullptr)
        return pData;

    DiagramEditorItemProperty* itemData = new DiagramEditorItemProperty(this);

    if(itemData)
    {
        itemData->setUuid(id);
        itemData->setMetaModelName(metaName);
        itemData->setType(type);
        itemData->setTag(name);
        itemData->setName(name);
        if(!sBlock.isEmpty())
            itemData->setBlock(sBlock);
        if(mode == 0){
            BasePropertyManager::instance().insertTempEditorData(id,itemData);
        }
        else if(mode == 1){
            BasePropertyManager::instance().insertEditorData(id,itemData);
        }

    }
    return itemData;
}

void DiagramEditorModel::createTopoTerminalsByItem(GraphicsBaseItem* pItem,ModelFunctionType funType)
{
    PowerEntity* pEntity = pItem->entity();

    if(pEntity)
    {
        QMap<QString,ItemPort*> mapPorts = pItem->getPorts();     //创建实体port对应的拓扑port
        for(auto &port:mapPorts)
        {
            TerminalType terType;

            HandleType tpe = port->getType();
            switch (tpe) {
            case T_lineIn:
                terType = TerminalType::PowerInput;
                break;
            case T_lineOut:
                terType = TerminalType::PowerOutput;
                break;
            case T_lineInOut:
                terType = TerminalType::PowerConnect;
                break;
            default:
                break;
            }
            QPointF f = port->pos();
            TopologyManager::instance().createTerminal(pEntity->id(),terType,"",port->pos(),port->getId(),funType);
        }
    }
}

QRectF DiagramEditorModel::generateTempBay()
{
    QRectF itemsRect;
    generateItemByModel(_pCurBayRoute);
    if(_pCurPreviewScene)
        itemsRect = _pCurPreviewScene->itemsBoundingRect();

    return itemsRect;
}

GraphicsBaseModelItem* DiagramEditorModel::generateComponent(QUuid uid,QString sName,int nCategory,int nType,QPointF pos,int nRotate,int mode)
{
    GraphicsBaseModelItem*  pItem = nullptr;
    if(nCategory == 0)
    {
        QByteArray byte;
        if(nType == 1){     //母线
            byte = DataBase::GetInstance()->ModelType()[nType].icon;
            auto pBus = new ElectricBaseModelSvgBus(QRect(-200, -3, 400, 6));
            pBus->loadSvg(byte);
            pItem = pBus;
            pItem->setItemType(GIT_baseBus);
        }
        else if(nType == 2){        //异步电动机
        }
        else if(nType == 3){        //断路器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pBreaker = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
            pBreaker->loadSvg(byte);
            pItem = pBreaker;
            pItem->setItemType(GIT_baseBreaker);
            pItem->initialPortsByDatabase(3);
        }
        else if(nType == 4){        //电缆
        }
        else if(nType == 5){        //电流互感器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pCt= new ElectricBaseModelSvgItem(QRect(-10, -10, 20, 20));
            pCt->loadSvg(byte);
            pItem = pCt;
            pItem->setItemType(GIT_baseCT);
            pItem->initialPortsByDatabase(4);
        }
        else if(nType == 6){        //电压互感器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pPt = new ElectricBaseModelSvgItem(QRect(-25, -25, 50, 50));
            pPt->loadSvg(byte);
            pItem = pPt;
            pItem->setItemType(GIT_basePT);
            pItem->initialPortsByDatabase(5);
        }
        else if(nType == 7){        //隔离开关
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pDs = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
            pDs->loadSvg(byte);
            pItem = pDs;
            pItem->setItemType(GIT_baseDS);
            pItem->initialPortsByDatabase(9);
        }
        else if(nType == 8){        //接地开关
        }
        else if(nType == 9){        //快速接地开关
        }
        else if(nType == 10){       //双掷接地隔离开关
        }
        else if(nType == 11){       //带电指示器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pPi = new ElectricBaseModelSvgItem(QRect(-15, -30, 30, 60));
            pPi->loadSvg(byte);
            pItem = pPi;
            pItem->setItemType(GIT_basePI);
            pItem->initialPortsByDatabase(11);
        }
        else if(nType == 12){       //避雷器
        }
        else if(nType == 13){       //电缆出线套筒
        }
        else if(nType == 14){       //电缆端
        }
        else if(nType == 15){       //两绕组变压器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto p2W = new ElectricBaseModelSvgItem(QRect(-50, -50, 100, 100));
            p2W->loadSvg(byte);
            pItem = p2W;
            pItem->setItemType(GIT_base2wTransformer);
            pItem->initialPortsByDatabase(15);
        }
        else if(nType == 16){       //三绕组变压器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto p3W = new ElectricBaseModelSvgItem(QRect(-75, -50, 150, 100));
            p3W->loadSvg(byte);
            pItem = p3W;
            pItem->setItemType(GIT_base3wTransformer);
            pItem->initialPortsByDatabase(16);
        }
    }
    else if(nCategory == 1){
        if(nType == 1){     //节点
            pItem = new ElectricBaseModelPortItem();
            pItem->setItemType(GIT_baseNode);
        }
    }

    if(pItem){
        pItem->setItemId(uid);
        pItem->setRotation(nRotate);
        ModelFunctionType typ;
        if(mode == 0){
            typ = ModelFunctionType::BlockEditorModel;
        }
        else if(mode == 1){
            typ = ModelFunctionType::EditorModel;
        }
        PowerEntity* pEntityData = TopologyManager::instance().createEntity(EntityType::Component,uid.toString(),sName,typ);
        if(pEntityData)
            pItem->setEntity(pEntityData);
        DiagramEditorItemProperty* pData = nullptr;
        if(nCategory == 1){
           pData = addPreviewData(uid,0,sName,"node","",mode);
        }
        else if(nCategory == 0){        //设备
            pData = addPreviewData(uid,nType,sName,DataBase::GetInstance()->ModelType()[nType].modelType,"",mode);
            pData->setGraphicsType(pItem->getItemType());
        }
        if(pData)
        {
            pItem->setProperty(pData);
            createTopoTerminalsByItem(pItem,typ);
            pData->setDataChanged(true);        //数据状态改变
        }
        addPreviewItem(uid,pItem,mode);
        _pCurPreviewScene->addItem(pItem);
        pItem->setPos(pos);
    }
    return pItem;
}

ElectricBaseModelLineItem* DiagramEditorModel::generateLine(QUuid uid,QString sName,int mode)
{
    ElectricBaseModelLineItem* pLine = new ElectricBaseModelLineItem();
    pLine->setItemId(uid);
    pLine->setItemType(GIT_baseLine);
    DiagramEditorItemProperty* pData = addPreviewData(uid,8,sName,DataBase::GetInstance()->ModelType()[4].modelType,"",mode);
    pData->setGraphicsType(GIT_baseLine);
    if(pData)
    {
        pLine->setProperty(pData);
        pData->setDataChanged(true);        //数据状态改变
    }
    addPreviewItem(uid,pLine,mode);
    //establishConnection(pBreaker,pBus,pLine,ModelFunctionType::BaseModel);
    _pCurPreviewScene->addItem(pLine);
    return pLine;
}

void DiagramEditorModel::clearCurPreview()
{
    if(_pCurPreviewScene){
        _tempItem.clear();
        _pCurPreviewScene->clear();
    }
}

void DiagramEditorModel::generateTempTrans(int nType,DiagramEditorTransformerBlock* block)
{
    if(nType == 0 || nType == 1 || nType == 2){
        generateItemByModel(_pCurTransLRoutes.value(nType),1);
    }
    else if(nType == 3){
        TransformerType typ = block->getTransType();
        auto pInfo = block->getTranInfo();
        int nT = 0;
        if(typ == TransformerType::twoWinding){
            generateItemByModel(_pCurTransLRoutes.value(0),1,QPoint(100,-25));
            generateItemByModel(_pCurTransLRoutes.value(2),1,QPoint(100,25));
            pInfo.mapNeutral[0].delPoint = QPoint(100,-25);
            pInfo.mapNeutral[2].delPoint = QPoint(100,25);
        }
        else if(typ == TransformerType::threeWinding){
            generateItemByModel(_pCurTransLRoutes.value(0),1,QPoint(100,-25));
            generateItemByModel(_pCurTransLRoutes.value(1),1,QPoint(-150,0));
            generateItemByModel(_pCurTransLRoutes.value(2),1,QPoint(100,25));
            pInfo.mapNeutral[0].delPoint = QPoint(100,-25);
            pInfo.mapNeutral[1].delPoint = QPoint(-150,0);
            pInfo.mapNeutral[2].delPoint = QPoint(100,25);
        }

        connectTransToNeutral(block);

        if(_pCurPreviewScene){
            QRectF itemsRect = _pCurPreviewScene->itemsBoundingRect();
            block->setRecSize(itemsRect);
        }
    }
}

void DiagramEditorModel::connectTransToNeutral(DiagramEditorTransformerBlock* block)
{
    if(block){      //生成变压器主体
        QUuid uid = block->getId();
        QString sName = block->getName();
        int nT = 0;
        TransformerType typ = block->getTransType();
        if(typ == TransformerType::twoWinding){
            nT = 15;
        }
        else if(typ == TransformerType::threeWinding){
            nT = 16;
        }
        generateComponent(uid,sName,0,nT,QPoint(0,0),0,0);

        auto pTransItem = _tempItem.value(uid);
        if(pTransItem){
            if(typ == TransformerType::twoWinding){
                linkTransItem(pTransItem,_pCurTransLRoutes.value(0));
                linkTransItem(pTransItem,_pCurTransLRoutes.value(2));
            }
            else if(typ == TransformerType::threeWinding){
                linkTransItem(pTransItem,_pCurTransLRoutes.value(0));
                linkTransItem(pTransItem,_pCurTransLRoutes.value(1));
                linkTransItem(pTransItem,_pCurTransLRoutes.value(2));
            }
        }
    }
}

void DiagramEditorModel::linkTransItem(GraphicsBaseModelItem* pTrans,QStandardItemModel* pModel)
{
    QUuid uid1 = pTrans->itemId();
    int rowCount = pModel->rowCount();
    for(int i = 0;i < rowCount;++i){
        QStandardItem *itemComps = pModel->item(i, 1);
        QString sComps = itemComps->text();
        QStringList lst = sComps.split(",");
        for(auto& name:lst){            //寻找绑定到中性点的点
            QStandardItem* pItem = getNameItem(name,1);
            if(pItem){
                QModelIndex index = pItem->index();
                QModelIndex indexObj = index.sibling(index.row(),3);
                QUuid uid2 = pItem->data(Qt::UserRole+3).toUuid();

                QString sBindObj = indexObj.data().toString();      //获取显示数据
                auto pItem = _tempItem.value(uid2);
                if(sBindObj == "高压绕组中性点" || sBindObj == "中压绕组中性点" || sBindObj == "低压绕组中性点"){
                    int nPos = 0;
                    if(sBindObj == "高压绕组中性点")
                        nPos = 0;
                    else if(sBindObj == "中压绕组中性点")
                        nPos = 1;
                    else if(sBindObj == "低压绕组中性点")
                        nPos = 2;
                    auto pLineData = TopologyManager::instance().ifConnection(uid1.toString(),uid2.toString());     //判断两个item是否有连接
                    if(pLineData != nullptr){
                        if(!_tempItem.contains(QUuid(pLineData->id()))){        //connectdata已存在，item未绘制
                            auto pLine = generateLine(QUuid(pLineData->id()),"",0);   //重新绘制
                            if(pLine)
                                establishConnection(pItem,pTrans,pLine,ModelFunctionType::BlockEditorModel,1,nPos);
                        }
                        else{      //已绘制，略过
                        }
                    }
                    else{       //connectdata不存在，新建
                        auto pLine = generateLine(QUuid::createUuid(),"",0);
                        if(pLine)
                            establishConnection(pItem,pTrans,pLine,ModelFunctionType::BlockEditorModel,1,nPos);
                    }
                }
            }
        }
    }
}

void DiagramEditorModel::generatePreview()
{
    if(_pPanel){
        _pPanel->showPreview();
        QList<EditBaseItem*> lst = _pPanel->getBlockItems();
        QMap<QString,QList<DiagramEditorComponentInfo>>     baysCompo;
        QMap<QString,QMap<int,QList<DiagramEditorComponentInfo>>>  transCompo;

        for(auto item:lst){
            if(item->getType() == EditorItemType::bus){     //首次循环生成母线
                auto p = item->getBlockData();      //获取blockitem对应的data
                if(p){
                    QUuid uid = p->getId();
                    QString name = p->getName();
                    auto pContainer = _pWizard->getContainerByBlock_all(name);        //获取block所在的container

                    auto mapBlocks = pContainer->getBlockMap();
                    int nMaxLen = 0;
                    for(auto &lst:mapBlocks){        //根据容器中block的最大长度，计算出母线最小length
                        int nLen = 0;
                        for(auto block:lst){
                            if(block->getType() == 1)       //容器中block是母线不计算
                                continue;
                            nLen = 100+block->getRecSize().width();
                        }
                        if(nMaxLen < nLen)
                            nMaxLen = nLen;
                    }

                    QRectF rec = item->boundingRect();

                    QPointF pos = item->scenePos();
                    auto pItem = generateComponent(uid,name,0,1,pos,0,1);
                    if(nMaxLen > rec.width())
                        rec.setWidth(nMaxLen);
                    pItem->setBoundingRect(rec);
                    p->setRecSize(rec);
                }
            }
            else if(item->getType() == EditorItemType::bay){     //第二次生成间隔、变压器
                auto p = item->getBlockData();      //获取blockitem对应的data
                DiagramEditorBayBlock* pBay = dynamic_cast<DiagramEditorBayBlock*>(p.data());
                if(pBay){
                    QString sBay = pBay->getName();
                    auto mapRoute = pBay->getBayInfo().mapRoute;
                    auto mapCompo = pBay->getBayInfo().mapComponent;

                    QRectF rect = item->boundingRect();
                    // 计算中心点（本地坐标系）
                    QPointF centerLocal = rect.center();
                    // 转换为场景坐标系
                    QPointF centerScene = item->mapToScene(centerLocal);
                    QList<DiagramEditorComponentInfo> lstCompo = generateItemByInfo(mapRoute,mapCompo,centerScene);     //返回与外部连接的compo
                    if(!baysCompo.contains(sBay))
                        baysCompo.insert(sBay,lstCompo);
                }
            }
            else if(item->getType() == EditorItemType::trans){
                auto p = item->getBlockData();      //获取blockitem对应的data
                DiagramEditorTransformerBlock* pTrans = dynamic_cast<DiagramEditorTransformerBlock*>(p.data());
                if(pTrans){
                    //首先绘制本体
                    auto pType = pTrans->getTransType();
                    QString sTrans = pTrans->getName();
                    QUuid uid = pTrans->getId();
                    QString name = pTrans->getName();

                    QPointF pos = item->scenePos();
                    int nType = 0;
                    if(pType == TransformerType::twoWinding)
                        nType = 15;
                    else
                        nType = 16;
                    auto pItem = generateComponent(uid,name,0,nType,pos,0,1);

                    QRectF rect = item->boundingRect();
                    // 计算中心点（本地坐标系）
                    QPointF centerLocal = rect.center();
                    // 转换为场景坐标系
                    QPointF centerScene = item->mapToScene(centerLocal);
                    auto transInfo = pTrans->getTranInfo();

                    QMap<int,QList<DiagramEditorComponentInfo>>    neutralInfo;
                    for(auto &neutral:transInfo.mapNeutral){
                        QPointF pDelta = neutral.delPoint;
                        int nT = neutral.nType;
                        QList<DiagramEditorComponentInfo> lstCompo = generateItemByInfo(neutral.mapRoute,transInfo.mapComponent,centerScene+pDelta);
                        if(!neutralInfo.contains(nT))
                            neutralInfo.insert(nT,lstCompo);
                    }

                    if(!transCompo.contains(sTrans))        //添加需连接的中性点
                        transCompo.insert(sTrans,neutralInfo);
                }
            }
        }

        for(auto &lst:baysCompo){
            generateOutConnection(lst,2);
        }

        for(auto &map:transCompo){
            for(auto it = map.begin(); it != map.end();++it){
                generateOutConnection(it.value(),1,it.key());
            }
        }
    }

    calculateBlockPos();
}

void DiagramEditorModel::calculateBlockPos()
{
    if(_pWizard){
        double deltaY = 0;      //竖直方向每行增量
        double lastMaxDownH = 0;    //上一行的下部最大高度
        auto mapTotal = _pWizard->getContainerStruct();
        for(auto iter = mapTotal.begin();iter != mapTotal.end();++iter){
            if(iter.key() == g_transformerLevel)
                continue;
            double dMaxUp = 0;      //计算最大上方空间
            double dMaxDown = 0;    //计算最大下方空间

            for(auto &pCon:iter.value()){        //首次循环遍历每行container,计算最大上空间高度，最大下空间高度，容器宽度
                auto mapBlocks = pCon->getBlockMap();
                auto lstBlockUp =  mapBlocks.value(0);
                auto lstBlockDown = mapBlocks.value(3);
                double dConWidth = 0;

                double dWidthUp = 0;
                for(auto pBlock:lstBlockUp){
                    QRectF rec = pBlock->getRecSize();
                    double dHeight = rec.height();
                    double dWidth = rec.width();
                    if(dMaxUp < dHeight)
                        dMaxUp = dHeight;
                    dWidthUp += g_nHorizontalBlockSpacing+dWidth;
                }

                double dWidthDown = 0;
                for(auto pBlock:lstBlockDown){
                    QRectF rec = pBlock->getRecSize();
                    double dHeight = rec.height();
                    double dWidth = rec.width();
                    if(dMaxDown < dHeight)
                        dMaxDown = dHeight;
                    dWidthDown = g_nHorizontalBlockSpacing+dWidth;
                }

                dConWidth = dWidthUp > dWidthDown ? dWidthUp : dWidthDown;
                pCon->setWidth(dConWidth);
            }

            double dDeltaX = 0;          //每行横向偏移
            for(auto &pCon:iter.value()){       //第二次循环赋值,计算位置(首先确定母线位置)
                pCon->setMaxUpH(dMaxUp);
                pCon->setMaxDownH(dMaxDown);
                if(iter.value().first() == pCon){       //每行只进行一次y位移
                    if(iter == mapTotal.begin()){       //首行    deltaY = 首行dMaxUpH
                        deltaY = pCon->getMaxUpH();
                    }
                    else            //其他行   deltaY = deltaY+母线高度+上行dMaxDownH+本行dMaxUpH
                    {
                        deltaY = deltaY + 50 + lastMaxDownH + pCon->getMaxUpH();
                    }
                    lastMaxDownH = pCon->getMaxDownH();
                }
                pCon->setMidUpY(deltaY);
                pCon->setMidDownY(deltaY+50);
                pCon->setStartX(dDeltaX);
                dDeltaX += pCon->getWidth();

                //计算container中block中心点的位置
                auto mapBlocks = pCon->getBlockMap();

                for(auto it = mapBlocks.begin();it != mapBlocks.end();++it){
                    double pStartX = pCon->getStartX();     //容器起始x
                    double dMiddleUpY = pCon->getMidUpY();  //获取1母上边y
                    double dMiddleDownY = pCon->getMidDownY();  //获取2母下边y
                    double deltaX = pStartX;
                    for(auto pBlock:it.value()){
                        QRectF recBlock = pBlock->getRecSize();
                        QPointF center;
                        if(pBlock->getType() == 1){     //母线
                            if(it.key() == 1){      //1母
                                center = QPointF(pStartX+recBlock.width()*0.5,dMiddleUpY+recBlock.height()*0.5);
                            }
                            else if(it.key() == 2){      //2母
                                center = QPointF(pStartX+recBlock.width()*0.5,dMiddleDownY-recBlock.height()*0.5);
                            }
                        }
                        else if(pBlock->getType() == 2){     //间隔
                            if(it.key() == 0){      //容器最上层
                                center = QPointF(deltaX+recBlock.width()*0.5,dMiddleUpY-recBlock.height()*0.5);
                            }
                            else if(it.key() == 3){      //容器最下层
                                center = QPointF(deltaX+recBlock.width()*0.5,dMiddleDownY+recBlock.height()*0.5);
                            }
                            deltaX += recBlock.width();
                        }
                        else if(pBlock->getType() == 3){     //变压器
                        }

                        if(!center.isNull())
                            pBlock->setSeceneDelta(center);
                    }
                }
            }

            dDeltaX = 0;
            if(iter.key() == 0){        //若设置了变压器，直接插入到第一行下方
                if(!mapTotal.value(g_transformerLevel).empty()){
                    for(auto &pCon:iter.value()){        //首次计算变压器大小
                        auto mapBlocks = pCon->getBlockMap();
                        auto lstBlock =  mapBlocks.value(1);
                        for(auto &pb:lstBlock){
                            QRectF rec = pb->getRecSize();
                            pCon->setWidth(rec.width());
                            pCon->setHeight(rec.height());
                        }
                    }

                    for(auto &pCon:iter.value()){       //计算位置
                        if(pCon == iter.value().first()){
                            //只在每行第一次改变deltaY
                            deltaY += pCon->getHeight();
                        }
                        pCon->setStartY(deltaY-pCon->getHeight());
                        pCon->setStartX(dDeltaX);
                        dDeltaX += pCon->getWidth();

                        auto mapBlocks = pCon->getBlockMap();

                        for(auto it = mapBlocks.begin();it != mapBlocks.end();++it){
                            for(auto pBlock:it.value()){
                                QRectF recBlock = pBlock->getRecSize();
                                QPointF center = QPointF(pCon->getStartX()+recBlock.width()*0.5,pCon->getStartY()+recBlock.height()*0.5);
                                pBlock->setSeceneDelta(center);
                            }
                        }
                    }
                }
            }
        }
    }
}

void DiagramEditorModel::setItemInBlockPos()
{
    QList<EditBaseItem*> lst = _pPanel->getBlockItems();

    for(auto item:lst){
        if(item->getType() == EditorItemType::bus){
            auto p = item->getBlockData();      //获取blockitem对应的data
            if(p){
                QUuid uid = p->getId();
                auto pItem = _previewItem.value(uid);
                if(pItem){
                    QPointF pPos = p->getSceneDelta();
                    pItem->setPos(pPos);
                }
            }
        }
        else if(item->getType() == EditorItemType::bay){
            auto p = item->getBlockData();      //获取blockitem对应的data
            DiagramEditorBayBlock* pBay = dynamic_cast<DiagramEditorBayBlock*>(p.data());
            if(pBay){
                QString sBay = pBay->getName();
                auto bayInfo = pBay->getBayInfo();
                auto mapRoute = bayInfo.mapRoute;
                auto mapCompo = bayInfo.mapComponent;

                auto lst = getRouteItemInfoList(mapCompo,mapRoute);
                for(auto& info:lst){
                    auto pItem = _previewItem.value(info.uid);
                    if(pItem){
                        QPointF pos = info.deltaPos+pBay->getSceneDelta();
                        pItem->setPos(pos);
                    }
                }
            }
        }
        else if(item->getType() == EditorItemType::trans){
            auto p = item->getBlockData();      //获取blockitem对应的data
            DiagramEditorTransformerBlock* pTrans = dynamic_cast<DiagramEditorTransformerBlock*>(p.data());
            if(pTrans){
                auto transInfo = pTrans->getTranInfo();
                auto mapCompo = transInfo.mapComponent;

                for(auto &neuInfo:transInfo.mapNeutral){
                    auto mapRoute = neuInfo.mapRoute;

                    auto lst = getRouteItemInfoList(mapCompo,mapRoute);
                    for(auto& info:lst){
                        auto pItem = _previewItem.value(info.uid);
                        if(pItem){
                            QPointF pos = info.deltaPos+(pTrans->getSceneDelta()-info.deltaPos);
                            pItem->setPos(pos);
                        }
                    }
                }
            }
        }
    }
}

QStandardItem* DiagramEditorModel::getNameItem(const QString& sName,int nFrom)
{
    QStandardItemModel* pModel = nullptr;
    if(nFrom == 0){     //间隔
        pModel = _pCurBayComponent;
    }
    else if(nFrom == 1){
        pModel = _pCurTransComponent;
    }
    if(pModel){
        int nRowCount = pModel->rowCount();
        for(int i = 0;i < nRowCount;++i){
            QStandardItem *itemName = pModel->item(i, 1);
            if(sName == itemName->text()){
                return itemName;
            }
        }
    }

    return nullptr;
}

void DiagramEditorModel::generateItemByModel(QStandardItemModel* pModel,int nFrom,QPoint delta)
{
    int rowCount = pModel->rowCount();
    for(int i = 0;i < rowCount;++i){
        QStandardItem *itemComps = pModel->item(i, 1);
        QString sComps = itemComps->text();
        QStringList lst = sComps.split(",");
        for(auto& name:lst){            //第一次循环生成item
            QStandardItem* pItem = getNameItem(name,nFrom);
            if(pItem){
                QModelIndex index = pItem->index();
                QModelIndex indexCate = index.sibling(index.row(),0);
                QModelIndex indexType = index.sibling(index.row(),2);
                if(!pItem->data(Qt::UserRole+4).isValid()){     //未初始化，新建item
                    pItem->setData(1,Qt::UserRole+4);
                }
                int nCate = indexCate.data(Qt::UserRole+1).toInt();       //0设备1连接
                int nType = indexType.data(Qt::UserRole+1).toInt();
                int nDir = pItem->data().toInt();
                int nRotate = 0;
                if(pItem->data(Qt::UserRole+5).isValid())
                    nRotate = pItem->data(Qt::UserRole+5).toInt();
                QPoint pos = pItem->data(Qt::UserRole+2).toPoint();
                pos += delta;
                QUuid uid = pItem->data(Qt::UserRole+3).toUuid();
                if(!_tempItem.contains(uid))
                    generateComponent(uid,name,nCate,nType,pos,nRotate,0);
            }
        }

        if(lst.size() > 1){
            for(int i = 0;i < lst.size() -1;++i){
                QStandardItem* pItemFirst = getNameItem(lst[i],nFrom);
                QStandardItem* pItemSecond = getNameItem(lst[i+1],nFrom);

                if(pItemFirst && pItemSecond){
                    QUuid uid1 = pItemFirst->data(Qt::UserRole+3).toUuid();
                    QUuid uid2 = pItemSecond->data(Qt::UserRole+3).toUuid();

                    if(_tempItem.contains(uid1) && _tempItem.contains(uid2)){
                        GraphicsBaseModelItem* p1 = _tempItem.value(uid1);
                        GraphicsBaseModelItem* p2 = _tempItem.value(uid2);
                        auto pLineData = TopologyManager::instance().ifConnection(uid1.toString(),uid2.toString(),ModelFunctionType::BlockEditorModel);     //判断两个item是否有连接
                        if(pLineData != nullptr){
                            if(!_tempItem.contains(QUuid(pLineData->id()))){        //connectdata已存在，item未绘制
                                auto pLine = generateLine(QUuid(pLineData->id()),"",0);   //重新绘制
                                if(pLine)
                                    establishConnection(p1,p2,pLine,ModelFunctionType::BlockEditorModel);
                            }
                            else{      //已绘制，略过
                            }
                        }
                        else{       //connectdata不存在，新建
                            auto pLine = generateLine(QUuid::createUuid(),"",0);
                            if(pLine)
                                establishConnection(p1,p2,pLine,ModelFunctionType::BlockEditorModel);
                        }
                    }
                }
            }
        }
    }
}

QList<DiagramEditorComponentInfo> DiagramEditorModel::generateItemByInfo(QMap<QString,DiagramEditorRouteInfo> mapRoute,QMap<QString,DiagramEditorComponentInfo> mapCompo,QPointF delta)
{
    QList<DiagramEditorComponentInfo> lstBind;      //连接外部对象的component
    QString sMain;
    for(auto& route:mapRoute){       //总路线中包含主路,首次生成主路
        if(route.bMainRoute == true){
            sMain = route.sRouteName;
            for(auto& compo:route.lstCompo){     //首先生成设备
                auto info = mapCompo.value(compo.sName);
                generateComponent(info.uid,info.sName,info.nCategory,info.nType,info.deltaPos+delta,info.nRotate,1);
                if(!info.sBindObj.isEmpty() && info.sBindObj != QString::fromWCharArray(L"无")){     //非空且不是无
                    if(!lstBind.contains(info))
                        lstBind.append(info);
                }
            }

            if(route.lstCompo.size() > 1){
                bulidAndLinkComponent(route.lstCompo,mapCompo);
            }
        }
    }

    for(auto &route:mapRoute){       //二次生成其他路线
        if(route.bMainRoute == true){
            continue;
        }
        for(auto &compo:route.lstOrder){     //生成正序设备
            auto info = mapCompo.value(compo.sName);
            generateComponent(info.uid,info.sName,info.nCategory,info.nType,info.deltaPos+delta,info.nRotate,1);
            if(!info.sBindObj.isEmpty() && info.sBindObj != QString::fromWCharArray(L"无")){     //非空且不是无
                if(!lstBind.contains(info))
                    lstBind.append(info);
            }
        }

        for(auto &compo:route.lstReverse){     //生成逆序设备
            auto info = mapCompo.value(compo.sName);
            generateComponent(info.uid,info.sName,info.nCategory,info.nType,info.deltaPos+delta,info.nRotate,1);
            if(!info.sBindObj.isEmpty() && info.sBindObj != QString::fromWCharArray(L"无")){     //非空且不是无
                if(!lstBind.contains(info))
                    lstBind.append(info);
            }
        }

        if(route.lstOrder.size() > 1){
            bulidAndLinkComponent(route.lstOrder,mapCompo);
        }

        if(route.lstReverse.size() > 1){
            bulidAndLinkComponent(route.lstReverse,mapCompo);
        }
    }

    return lstBind;
}

void DiagramEditorModel::generateOutConnection(QList<DiagramEditorComponentInfo> lstBind,int nTypeTransCon,int nPos)
{
    for(auto& compo:lstBind){       //遍历关联外部的item，进行连线
        if(compo.nBindType == 1){       //关联的是母线        母线没有数据，获取绘制的母线item
            for(auto& pItem:_previewItem){
                auto pro = pItem->getProperty();
                if(pro){
                    QString sName = pro->name();
                    if(sName == compo.sBindObj){
                        GraphicsBaseModelItem* pSrc = _previewItem.value(compo.uid);
                        GraphicsBaseModelItem* pTarget = pItem;
                        auto pLineData = TopologyManager::instance().ifConnection(pSrc->itemId().toString(),pTarget->itemId().toString(),ModelFunctionType::EditorModel);     //判断两个item是否有连接
                        if(pLineData != nullptr){
                            if(!_previewItem.contains(QUuid(pLineData->id()))){        //connectdata已存在，item未绘制
                                auto pLine = generateLine(QUuid(pLineData->id()),"",1);   //重新绘制
                                if(pLine)
                                    establishConnection(pSrc,pTarget,pLine,ModelFunctionType::EditorModel);
                            }
                            else{      //已绘制，略过
                            }
                        }
                        else{       //connectdata不存在，新建
                            auto pLine = generateLine(QUuid::createUuid(),"",1);
                            if(pLine)
                                establishConnection(pSrc,pTarget,pLine,ModelFunctionType::EditorModel);
                        }
                    }
                }
            }
        }
        else if(compo.nBindType == 3){          //关联变压器
            for(auto& pItem:_previewItem){
                auto pro = pItem->getProperty();
                if(pro){
                    QString sName = pro->name();
                    if(sName == compo.sBindParent){     //判断变压器名
                        GraphicsBaseModelItem* pSrc = _previewItem.value(compo.uid);
                        GraphicsBaseModelItem* pTarget = pItem;
                        auto pLineData = TopologyManager::instance().ifConnection(pSrc->itemId().toString(),pTarget->itemId().toString(),ModelFunctionType::EditorModel);     //判断两个item是否有连接
                        if(pLineData != nullptr){
                            if(!_previewItem.contains(QUuid(pLineData->id()))){        //connectdata已存在，item未绘制
                                auto pLine = generateLine(QUuid(pLineData->id()),"",1);   //重新绘制
                                if(pLine){
                                    if(nTypeTransCon == 2)
                                        establishConnection(pSrc,pTarget,pLine,ModelFunctionType::EditorModel,2,compo.nBindPara);
                                    else
                                        establishConnection(pSrc,pTarget,pLine,ModelFunctionType::EditorModel,nTypeTransCon,nPos);
                                }
                            }
                            else{      //已绘制，略过
                            }
                        }
                        else{       //connectdata不存在，新建
                            auto pLine = generateLine(QUuid::createUuid(),"",1);
                            if(pLine){
                                if(nTypeTransCon == 2)
                                    establishConnection(pSrc,pTarget,pLine,ModelFunctionType::EditorModel,2,compo.nBindPara);
                                else
                                    establishConnection(pSrc,pTarget,pLine,ModelFunctionType::EditorModel,nTypeTransCon,nPos);
                            }
                        }
                    }
                }
            }
        }
    }
}

void DiagramEditorModel::updateTarget(QMap<QString,DiagramEditorRouteInfo>& data,int nLayout,int nSource)
{
    auto& mapRoute = data;
    QString sMainRoute;

    bool hasMain = false;
    for(auto& route:mapRoute){
        if(route.bMainRoute == true){
            sMainRoute = route.sRouteName;
            hasMain = true;
        }
    }
    if(!hasMain){       //没设置主线将最长设为主线
        int nCount = 0;
        for(auto& route:mapRoute){      //寻找包含设备最多的线路
            if(nCount < route.lstCompo.count()){
                nCount = route.lstCompo.count();
                sMainRoute = route.sRouteName;
                route.bMainRoute = true;
            }
        }
    }
    int nMainDir = nLayout/10;        //主朝向倾向 8421上下左右
    int nSubDir = nLayout%10;         //次朝向倾向 8421

    if(nMainDir == 4 || nMainDir == 8){     //竖直
        auto& maoCompo = mapRoute[sMainRoute].lstCompo;     //假设竖直情况下，上下等分为nSeg段    假设主线路水平居中
        int nSeg = maoCompo.size()*0.5;
        int nSegIndex = 0;
        if(nMainDir == 4)       //正向从负半加到正半
            nSegIndex = -nSeg;      //计数器，计算deltaY
        else
            nSegIndex = nSeg;   //反向从正半减到负半
        for(int i = 0;i < maoCompo.size();++i){ //优先遍历主线路，构建主体结构
            int nDir = 0;
            if(i == 0){      //队首
                maoCompo[i].nUsedDirection |= nMainDir;  //默认向下，队首单向下(单线路记录，不可作为跨线判断依据)
                nDir = nMainDir;
            }
            else if(i == maoCompo.size()-1){
                maoCompo[i].nUsedDirection |= 12-nMainDir;  //队尾单向上(单线路记录，不可作为跨线判断依据)
                nDir = 12-nMainDir;
            }
            else{
                maoCompo[i].nUsedDirection |= 12; //其余向上向下都被占用(单线路记录，不可作为跨线判断依据)
                nDir = 12;
            }
            int deltaY = nSegIndex*g_nVDiagramSpacing;

            auto pItemName = getNameItem(maoCompo[i].sName,nSource);
            if(pItemName){
                int nVal = pItemName->data().toInt();
                pItemName->setData(QString::number(nVal |= nDir));      //在公用模型中更新设备方向占用(重要)
                pItemName->setData(QPoint(0,deltaY),Qt::UserRole+2);    //设置相对位置
                if(nMainDir == 4){
                    maoCompo[i].nRotate = 0;
                    pItemName->setData(0,Qt::UserRole+5);
                }
                else{
                    maoCompo[i].nRotate = 180;
                    pItemName->setData(180,Qt::UserRole+5);
                }
            }
            if(nMainDir == 8)
                nSegIndex -= 1;
            else
                nSegIndex += 1;
        }

        for(auto& route:mapRoute){      //遍历主线路之外的线路
            if(route.sRouteName == sMainRoute){
                continue;
            }

            if(!route.lstCompo.isEmpty()){      //拆分线路为以节点为首
                auto pItemFirst = getNameItem(route.lstCompo.first().sName,nSource);
                int nFirstVal = pItemFirst->data().toInt();
                auto pItemLast = getNameItem(route.lstCompo.last().sName,nSource);
                int nLastVal = pItemLast->data().toInt();
                if(nFirstVal != 0){     //首位为节点
                    route.lstOrder = route.lstCompo;
                }
                else if(nLastVal != 0){     //末位为节点
                    for (auto it = route.lstCompo.rbegin(); it != route.lstCompo.rend(); ++it) {
                        route.lstReverse.append(*it);
                    }
                }
                else{       //节点在中间
                    int nIndex = 0;
                    for(int i = 0;i < route.lstCompo.size();++i){
                        auto pItem = getNameItem(route.lstCompo[i].sName,nSource);
                        if(pItem){
                            int nVal = pItem->data().toInt();
                            if(nVal != 0){
                                nIndex = i;
                                break;
                            }
                        }
                    }

                    for(int i = nIndex;i >= 0;--i){
                        route.lstReverse.append(route.lstCompo[i]);
                    }

                    for(int i = nIndex;i < route.lstCompo.size();++i){
                        route.lstOrder.append(route.lstCompo[i]);
                    }
                }
            }

            int nOrderFirstDeltaY = 0;        //首节点y偏移量(假设后续节点与头节点水平)
            int nXOrderIndex = 1;       //横向计数
            int nOrderPolarity = 1;          //方向 1右 -1左
            if(route.lstOrder.size() > 1){
                for(int i = 0;i < route.lstOrder.size()-1;++i){       //遍历以节点为首的队列
                    auto pItem = getNameItem(route.lstOrder[i].sName,nSource);
                    int nVal = pItem->data().toInt();
                    QPoint deltaP = pItem->data(Qt::UserRole+2).toPoint();
                    auto pNextItem = getNameItem(route.lstOrder[i+1].sName,nSource);      //下一个item
                    nOrderFirstDeltaY = deltaP.y();
                    int nNextVal = pNextItem->data().toInt();
                    if(i == 0){     //首节点
                        if(((nVal & 2) == 1) && ((nVal & 1) == 1)){
                            qDebug()<<QString("point %1 full of connection").arg(route.lstOrder[i].sName);
                        }
                        else if((nVal & 2) == 1){
                            //左被占用,右空
                            pItem->setData(QString::number(nVal | 1));
                            pNextItem->setData(QString::number(nNextVal | 2));       //同时连接下个点的一侧占用
                            nOrderPolarity = 1;
                            route.lstOrder[i+1].nRotate = -90;
                            pNextItem->setData(-90,Qt::UserRole+5);
                        }
                        else if((nVal & 1) == 1){
                            //右被占用，左空
                            pItem->setData(QString::number(nVal | 2));
                            pNextItem->setData(QString::number(nNextVal | 1));
                            nOrderPolarity = -1;
                            route.lstOrder[i+1].nRotate = 90;
                            pNextItem->setData(90,Qt::UserRole+5);
                        }
                        else{       //左右都没被占,放到倾向位置
                            pItem->setData(QString::number(nVal | nSubDir));
                            pNextItem->setData(QString::number(nNextVal | 3-nSubDir));
                            if(nSubDir == 1){
                                nOrderPolarity = 1;
                                route.lstOrder[i+1].nRotate = -90;
                                pNextItem->setData(-90,Qt::UserRole+5);
                            }
                            else if(nSubDir == 2){
                                nOrderPolarity = -1;
                                route.lstOrder[i+1].nRotate = 90;
                                pNextItem->setData(90,Qt::UserRole+5);
                            }
                        }
                        int deltaX = nXOrderIndex*nOrderPolarity*g_nHDiagramSpacing;
                        pNextItem->setData(QPoint(deltaX,nOrderFirstDeltaY),Qt::UserRole + 2);
                        continue;
                    }

                    if(((nVal & 2) == 1) && ((nVal & 1) == 1)){
                        qDebug()<<QString("point %1 full of connection").arg(route.lstOrder[i].sName);
                    }
                    else if((nVal & 2) == 1){
                        //左被占用,右空
                        pItem->setData(QString::number(nVal | 1));
                        pNextItem->setData(QString::number(nNextVal | 2));       //同时连接下个点的一侧占用
                        route.lstOrder[i+1].nRotate = -90;
                        pNextItem->setData(-90,Qt::UserRole+5);
                    }
                    else if((nVal & 1) == 1){
                        //右被占用，左空
                        pItem->setData(QString::number(nVal | 2));
                        pNextItem->setData(QString::number(nNextVal | 1));
                        route.lstOrder[i+1].nRotate = 90;
                        pNextItem->setData(90,Qt::UserRole+5);
                    }
                    else{       //左右都没被占,放到设定位置
                        pItem->setData(QString::number(nVal | nSubDir));
                        pNextItem->setData(QString::number(nNextVal | 3-nSubDir));
                        if(nSubDir == 1){
                            route.lstOrder[i+1].nRotate = -90;
                            pNextItem->setData(-90,Qt::UserRole+5);
                        }
                        else if(nSubDir == 2){
                            route.lstOrder[i+1].nRotate = 90;
                            pNextItem->setData(90,Qt::UserRole+5);
                        }
                    }
                    int deltaX = nXOrderIndex*nOrderPolarity*g_nHDiagramSpacing;
                    pNextItem->setData(QPoint(deltaX,nOrderFirstDeltaY),Qt::UserRole + 2);
                    nXOrderIndex += 1;
                }
            }

            int nReverseFirstDeltaY = 0;        //首节点y偏移量(假设后续节点与头节点水平)
            int nXReverseIndex = 1;       //横向计数
            int nReversePolarity = 1;          //方向 1右 -1左
            if(route.lstReverse.size() > 1){
                for(int i = 0;i < route.lstReverse.size()-1;++i){       //遍历以节点为首的队列
                    auto pItem = getNameItem(route.lstReverse[i].sName,nSource);
                    int nVal = pItem->data().toInt();
                    QPoint deltaP = pItem->data(Qt::UserRole+2).toPoint();

                    auto pNextItem = getNameItem(route.lstReverse[i+1].sName,nSource);      //下一个item
                    nReverseFirstDeltaY = deltaP.y();

                    int nNextVal = pNextItem->data().toInt();
                    if(i == 0){     //首节点
                        if(((nVal & 2) == 1) && ((nVal & 1) == 1)){
                            qDebug()<<QString("point %1 full of connection").arg(route.lstReverse[i].sName);
                        }
                        else if((nVal & 2) == 1){
                            //左被占用,右空
                            pItem->setData(QString::number(nVal | 1));
                            pNextItem->setData(QString::number(nNextVal | 2));       //同时连接下个点的一侧占用
                            nReversePolarity = 1;
                            route.lstReverse[i+1].nRotate = -90;
                            pNextItem->setData(-90,Qt::UserRole+5);
                        }
                        else if((nVal & 1) == 1){
                            //右被占用，左空
                            pItem->setData(QString::number(nVal | 2));
                            pNextItem->setData(QString::number(nNextVal | 1));
                            nReversePolarity = -1;
                            route.lstReverse[i+1].nRotate = 90;
                            pNextItem->setData(90,Qt::UserRole+5);
                        }
                        else{       //左右都没被占,放到倾向位置
                            pItem->setData(QString::number(nVal | nSubDir));
                            pNextItem->setData(QString::number(nNextVal | 3-nSubDir));
                            if(nSubDir == 1){
                                nReversePolarity = 1;
                                route.lstReverse[i+1].nRotate = -90;
                                pNextItem->setData(-90,Qt::UserRole+5);
                            }
                            else if(nSubDir == 2){
                                nReversePolarity = -1;
                                route.lstReverse[i+1].nRotate = 90;
                                pNextItem->setData(90,Qt::UserRole+5);
                            }
                        }
                        int deltaX = nXReverseIndex*nReversePolarity*g_nHDiagramSpacing;
                        pNextItem->setData(QPoint(deltaX,nReverseFirstDeltaY),Qt::UserRole + 2);
                        continue;
                    }

                    if(((nVal & 2) == 1) && ((nVal & 1) == 1)){
                        qDebug()<<QString("point %1 full of connection").arg(route.lstReverse[i].sName);
                    }
                    else if((nVal & 2) == 1){
                        //左被占用,右空
                        pItem->setData(QString::number(nVal | 1));
                        pNextItem->setData(QString::number(nNextVal | 2));       //同时连接下个点的一侧占用
                        route.lstReverse[i+1].nRotate = -90;
                        pNextItem->setData(-90,Qt::UserRole+5);
                    }
                    else if((nVal & 1) == 1){
                        //右被占用，左空
                        pItem->setData(QString::number(nVal | 2));
                        pNextItem->setData(QString::number(nNextVal | 1));
                        route.lstReverse[i+1].nRotate = 90;
                        pNextItem->setData(90,Qt::UserRole+5);
                    }
                    else{       //左右都没被占,放到设定位置
                        pItem->setData(QString::number(nVal | nSubDir));
                        pNextItem->setData(QString::number(nNextVal | 3-nSubDir));
                        if(nSubDir == 1){
                            route.lstReverse[i+1].nRotate = -90;
                            pNextItem->setData(-90,Qt::UserRole+5);
                        }
                        else if(nSubDir == 2){
                            route.lstReverse[i+1].nRotate = 90;
                            pNextItem->setData(90,Qt::UserRole+5);
                        }
                    }
                    int deltaX = nXReverseIndex*nReversePolarity*g_nHDiagramSpacing;
                    pNextItem->setData(QPoint(deltaX,nReverseFirstDeltaY),Qt::UserRole + 2);
                    nXReverseIndex += 1;
                }
            }
        }
    }
    else if(nMainDir == 2 || nMainDir == 1){                  //2左1右
        auto& maoCompo = mapRoute[sMainRoute].lstCompo;     //左右等分为nSeg段    假设主线路水平居中
        int nSeg = maoCompo.size()*0.5;
        int nSegIndex = 0;      //计数器，计算deltaY
        if(nMainDir == 1)       //正向从负半加到正半
            nSegIndex = -nSeg;      //计数器，计算deltaY
        else
            nSegIndex = nSeg;   //反向从正半减到负半
        for(int i = 0;i < maoCompo.size();++i){ //优先遍历主线路，构建主体结构
            int nDir = 0;
            if(i == 0){      //队首
                maoCompo[i].nUsedDirection |= 1;  //队首向右
                nDir = 1;
            }
            else if(i == maoCompo.size()-1){
                maoCompo[i].nUsedDirection |= 2;  //队尾单向左(单线路记录，不可作为跨线判断依据)
                nDir = 2;
            }
            else{
                maoCompo[i].nUsedDirection |= 3; //其余左右都被占用(单线路记录，不可作为跨线判断依据)
                nDir = 3;
            }
            int deltaX = nSegIndex*g_nHDiagramSpacing;

            auto pItemName = getNameItem(maoCompo[i].sName,nSource);
            if(pItemName){
                int nVal = pItemName->data().toInt();
                pItemName->setData(QString::number(nVal |= nDir));      //在公用模型中更新设备方向占用(重要)
                pItemName->setData(QPoint(deltaX,0),Qt::UserRole+2);    //设置相对位置
                if(nMainDir == 1){
                    maoCompo[i].nRotate = -90;
                    pItemName->setData(-90,Qt::UserRole+5);     //转至水平
                }
                else{
                    maoCompo[i].nRotate = 90;
                    pItemName->setData(90,Qt::UserRole+5);
                }
            }
            if(nMainDir == 2)
                nSegIndex -= 1;
            else
                nSegIndex += 1;
        }

        for(auto& route:mapRoute){      //遍历主线路之外的线路
            if(route.sRouteName == sMainRoute){
                continue;
            }

            if(!route.lstCompo.isEmpty()){      //拆分线路为以节点为首
                auto pItemFirst = getNameItem(route.lstCompo.first().sName,nSource);
                int nFirstVal = pItemFirst->data().toInt();
                auto pItemLast = getNameItem(route.lstCompo.last().sName,nSource);
                int nLastVal = pItemLast->data().toInt();
                if(nFirstVal != 0){     //首位为节点
                    route.lstOrder = route.lstCompo;
                }
                else if(nLastVal != 0){     //末位为节点
                    for (auto it = route.lstCompo.rbegin(); it != route.lstCompo.rend(); ++it) {
                        route.lstReverse.append(*it);
                    }
                }
                else{       //节点在中间
                    int nIndex = 0;
                    for(int i = 0;i < route.lstCompo.size();++i){
                        auto pItem = getNameItem(route.lstCompo[i].sName,nSource);
                        if(pItem){
                            int nVal = pItem->data().toInt();
                            if(nVal != 0){
                                nIndex = i;
                                break;
                            }
                        }
                    }

                    for(int i = nIndex;i >= 0;--i){
                        route.lstReverse.append(route.lstCompo[i]);
                    }

                    for(int i = nIndex;i < route.lstCompo.size();++i){
                        route.lstOrder.append(route.lstCompo[i]);
                    }
                }
            }

            int nOrderFirstDeltaX = 0;        //首节点x偏移量(假设后续节点与头节点水平相同,纵向分布)
            int nYOrderIndex = 1;       //总向计数
            int nOrderPolarity = 1;          //方向 1下 -1上
            if(route.lstOrder.size() > 1){
                for(int i = 0;i < route.lstOrder.size()-1;++i){       //遍历以节点为首的队列
                    auto pItem = getNameItem(route.lstOrder[i].sName,nSource);
                    int nVal = pItem->data().toInt();
                    QPoint deltaP = pItem->data(Qt::UserRole+2).toPoint();
                    auto pNextItem = getNameItem(route.lstOrder[i+1].sName,nSource);      //下一个item
                    nOrderFirstDeltaX = deltaP.x();
                    int nNextVal = pNextItem->data().toInt();
                    if(i == 0){     //首节点
                        if(((nVal & 8) == 1) && ((nVal & 4) == 1)){
                            qDebug()<<QString("point %1 full of connection").arg(route.lstOrder[i].sName);
                        }
                        else if((nVal & 8) == 1){
                            //上被占用,下空
                            pItem->setData(QString::number(nVal | 4));
                            pNextItem->setData(QString::number(nNextVal | 8));       //同时连接下个点的一侧占用
                            nOrderPolarity = 1;
                            route.lstOrder[i+1].nRotate = 0;
                            pNextItem->setData(0,Qt::UserRole+5);
                        }
                        else if((nVal & 4) == 1){
                            //下被占用，上空
                            pItem->setData(QString::number(nVal | 8));
                            pNextItem->setData(QString::number(nNextVal | 4));
                            nOrderPolarity = -1;
                            route.lstOrder[i+1].nRotate = 180;
                            pNextItem->setData(180,Qt::UserRole+5);
                        }
                        else{       //上下都没占，放到设定位置
                            pItem->setData(QString::number(nVal | nSubDir));
                            pNextItem->setData(QString::number(nNextVal | 12-nSubDir));
                            if(nSubDir == 4){
                                nOrderPolarity = 1;
                                route.lstOrder[i+1].nRotate = 0;
                                pNextItem->setData(0,Qt::UserRole+5);
                            }
                            else if(nSubDir == 8){
                                nOrderPolarity = -1;
                                route.lstOrder[i+1].nRotate = 180;
                                pNextItem->setData(180,Qt::UserRole+5);
                            }
                        }
                        int deltaY = nYOrderIndex*nOrderPolarity*g_nVDiagramSpacing;
                        pNextItem->setData(QPoint(nOrderFirstDeltaX,deltaY),Qt::UserRole + 2);
                        continue;
                    }

                    if(((nVal & 8) == 1) && ((nVal & 4) == 1)){
                        qDebug()<<QString("point %1 full of connection").arg(route.lstOrder[i].sName);
                    }
                    else if((nVal & 8) == 1){
                        //上被占用,下空
                        pItem->setData(QString::number(nVal | 4));
                        pNextItem->setData(QString::number(nNextVal | 8));       //同时连接下个点的一侧占用
                        pNextItem->setData(0,Qt::UserRole+5);
                    }
                    else if((nVal & 4) == 1){
                        //下被占用，上空
                        pItem->setData(QString::number(nVal | 8));
                        pNextItem->setData(QString::number(nNextVal | 4));
                        pNextItem->setData(180,Qt::UserRole+5);
                    }
                    else{       //上下都没被占,放到设定位置
                        pItem->setData(QString::number(nVal | nSubDir));
                        pNextItem->setData(QString::number(nNextVal | 12-nSubDir));
                        if(nSubDir == 4){
                            //nOrderPolarity = 1;
                            route.lstOrder[i+1].nRotate = 0;
                            pNextItem->setData(0,Qt::UserRole+5);
                        }
                        else if(nSubDir == 8){
                            //nOrderPolarity = -1;
                            route.lstOrder[i+1].nRotate = 180;
                            pNextItem->setData(180,Qt::UserRole+5);
                        }
                    }
                    int deltaY = nYOrderIndex*nOrderPolarity*g_nVDiagramSpacing;
                    pNextItem->setData(QPoint(nOrderFirstDeltaX,deltaY),Qt::UserRole + 2);
                    nYOrderIndex += 1;
                }
            }

            int nReverseFirstDeltaX = 0;        //首节点X偏移量(假设后续节点与头节点垂直分布)
            int nYReverseIndex = 1;       //纵向计数
            int nReversePolarity = 1;          //方向 1下 -1上
            if(route.lstReverse.size() > 1){
                for(int i = 0;i < route.lstReverse.size()-1;++i){       //遍历以节点为首的队列
                    auto pItem = getNameItem(route.lstReverse[i].sName,nSource);
                    int nVal = pItem->data().toInt();
                    QPoint deltaP = pItem->data(Qt::UserRole+2).toPoint();

                    auto pNextItem = getNameItem(route.lstReverse[i+1].sName,nSource);      //下一个item
                    nReverseFirstDeltaX = deltaP.x();

                    int nNextVal = pNextItem->data().toInt();
                    if(i == 0){     //首节点
                        if(((nVal & 8) == 1) && ((nVal & 4) == 1)){
                            qDebug()<<QString("point %1 full of connection").arg(route.lstReverse[i].sName);
                        }
                        else if((nVal & 8) == 1){
                            //上被占用,下空
                            pItem->setData(QString::number(nVal | 4));
                            pNextItem->setData(QString::number(nNextVal | 8));       //同时连接下个点的一侧占用
                            nReversePolarity = 1;
                            route.lstReverse[i+1].nRotate = 0;
                            pNextItem->setData(0,Qt::UserRole+5);
                        }
                        else if((nVal & 1) == 4){
                            //下被占用，上空
                            pItem->setData(QString::number(nVal | 8));
                            pNextItem->setData(QString::number(nNextVal | 4));
                            nReversePolarity = -1;
                            route.lstReverse[i+1].nRotate = 180;
                            pNextItem->setData(180,Qt::UserRole+5);
                        }
                        else{       //上下都没被占,放到设定位置
                            pItem->setData(QString::number(nVal | nSubDir));
                            pNextItem->setData(QString::number(nNextVal | 12-nSubDir));
                            if(nSubDir == 4){
                                nReversePolarity = 1;
                                route.lstReverse[i+1].nRotate = 0;
                                pNextItem->setData(0,Qt::UserRole+5);
                            }
                            else if(nSubDir == 8){
                                nReversePolarity = -1;
                                route.lstReverse[i+1].nRotate = 180;
                                pNextItem->setData(180,Qt::UserRole+5);
                            }
                        }
                        int deltaY = nYReverseIndex*nReversePolarity*g_nVDiagramSpacing;
                        pNextItem->setData(QPoint(nReverseFirstDeltaX,deltaY),Qt::UserRole + 2);
                        continue;
                    }

                    if(((nVal & 8) == 1) && ((nVal & 4) == 1)){
                        qDebug()<<QString("point %1 full of connection").arg(route.lstOrder[i].sName);
                    }
                    else if((nVal & 8) == 1){
                        //上被占用,下空
                        pItem->setData(QString::number(nVal | 4));
                        pNextItem->setData(QString::number(nNextVal | 8));       //同时连接下个点的一侧占用
                        route.lstReverse[i+1].nRotate = 0;
                        pNextItem->setData(0,Qt::UserRole+5);
                    }
                    else if((nVal & 4) == 1){
                        //下被占用，上空
                        pItem->setData(QString::number(nVal | 8));
                        pNextItem->setData(QString::number(nNextVal | 4));
                        route.lstReverse[i+1].nRotate = 180;
                        pNextItem->setData(180,Qt::UserRole+5);
                    }
                    else{       //上下都没被占,默认放到下边
                        pItem->setData(QString::number(nVal | 4));
                        pNextItem->setData(QString::number(nNextVal | 8));
                        if(nSubDir == 4){
                            //nReversePolarity = 1;
                            route.lstReverse[i+1].nRotate = 0;
                            pNextItem->setData(0,Qt::UserRole+5);
                        }
                        else if(nSubDir == 8){
                            //nReversePolarity = -1;
                            route.lstReverse[i+1].nRotate = 180;
                            pNextItem->setData(180,Qt::UserRole+5);
                        }
                    }
                    int deltaY = nYReverseIndex*nReversePolarity*g_nVDiagramSpacing;
                    pNextItem->setData(QPoint(nReverseFirstDeltaX,deltaY),Qt::UserRole + 2);
                    nYReverseIndex += 1;
                }
            }
        }
    }
}

void DiagramEditorModel::bulidAndLinkComponent(QList<DiagramEditorComponentInfo> lst,QMap<QString,DiagramEditorComponentInfo> components)
{
    for(int i = 0;i < lst.size()-1;++i){
        auto item1 = lst[i];
        auto item2 = lst[i+1];
        auto info1 = components.value(item1.sName);
        auto info2 = components.value(item2.sName);
        if(_previewItem.contains(info1.uid) && _previewItem.contains(info2.uid)){
            GraphicsBaseModelItem* p1 = _previewItem.value(info1.uid);
            GraphicsBaseModelItem* p2 = _previewItem.value(info2.uid);
            auto pLineData = TopologyManager::instance().ifConnection(info1.uid.toString(),info2.uid.toString(),ModelFunctionType::EditorModel);     //判断两个item是否有连接
            if(pLineData != nullptr){
                if(!_previewItem.contains(QUuid(pLineData->id()))){        //connectdata已存在，item未绘制
                    auto pLine = generateLine(QUuid(pLineData->id()),"",1);   //重新绘制
                    if(pLine)
                        establishConnection(p1,p2,pLine,ModelFunctionType::EditorModel);
                }
                else{      //已绘制，略过
                }
            }
            else{       //connectdata不存在，新建
                auto pLine = generateLine(QUuid::createUuid(),"",1);
                if(pLine)
                    establishConnection(p1,p2,pLine,ModelFunctionType::EditorModel);
            }
        }
    }
}

QList<DiagramEditorComponentInfo> DiagramEditorModel::getRouteItemInfoList(QMap<QString,DiagramEditorComponentInfo> mapCompo,QMap<QString,DiagramEditorRouteInfo> mapRoute)
{
    QList<DiagramEditorComponentInfo> lst;
    for(auto& route:mapRoute){       //总路线中包含主路,首次生成主路
        for(auto& compo:route.lstCompo){     //首先生成设备
            auto info = mapCompo.value(compo.sName);

            bool exist = false;
            for(auto& inf:lst){
                if(inf == info){
                    exist = true;
                    break;
                }
            }
            if(!exist){
                lst.append(info);
            }
        }
    }
    return lst;
}