DiagramDesigner/diagramCavas/source/diagramEditor/diagramEditorWizard.cpp

#include <QMenu>
#include <QMessageBox>
#include <QUuid>
#include <QtNumeric>
#include <QComboBox>
#include "diagramEditor/diagramEditorWizard.h"
#include "diagramEditor/wizardBusTableDelegate.h"
#include "ui_diagramEditorWizard.h"
#include "diagramEditor/wizardBayContentDlg.h"
#include "diagramEditor/diagramEditorBaseBlock.h"
#include "diagramEditor/diagramEditorStructContainer.h"
#include "diagramEditor/diagramEditorBaySettingDlg.h"
#include "diagramEditor/diagramEditorTransSettingDlg.h"

DiagramEditorWizard::DiagramEditorWizard(QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::diagramEditorWizard)
    ,_baySettingDlg(nullptr)
    ,_transSettingDlg(nullptr)
{
    ui->setupUi(this);
    this->setWindowFlags(Qt::FramelessWindowHint | windowFlags());
    setStyleSheet("background-color: white;");
    initial();
}

DiagramEditorWizard::~DiagramEditorWizard()
{
    delete ui;
}

void DiagramEditorWizard::initial()
{
    _bayContentDlg = new WizardBayContentDlg(this);
    _bayContentDlg->setParent(this);
    ui->stackedWidget->addWidget(_bayContentDlg);
    ui->tabWidget->tabBar()->setEnabled(false);
    connect(ui->btn_ok,&QPushButton::clicked,this,&DiagramEditorWizard::onOkClicked);
    connect(ui->btn_cancel,&QPushButton::clicked,this,&DiagramEditorWizard::onCancelClicked);
    connect(ui->btn_last,&QPushButton::clicked,this,&DiagramEditorWizard::onLastClicked);
    connect(ui->btn_next,&QPushButton::clicked,this,&DiagramEditorWizard::onNextClicked);
    connect(ui->btn_addBus,&QPushButton::clicked,this,&DiagramEditorWizard::onAddBusClicked);
    connect(ui->btn_addBay,&QPushButton::clicked,this,&DiagramEditorWizard::onAddBayClicked);
    connect(ui->btn_addTrans,&QPushButton::clicked,this,&DiagramEditorWizard::onAddTransClicked);

    QStringList headerText;
    headerText<<"层级"<<"电压等级"<<"主接线"<<"分段方式"<<"接线方式";
    ui->tableWidget_bus->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->tableWidget_bus->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableWidget_bus->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableWidget_bus->setColumnCount(headerText.count());
    ui->tableWidget_bus->setHorizontalHeaderLabels(headerText);
    ui->tableWidget_bus->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);

    headerText.clear();
    headerText<<"变压器名称"<<"变压器类型"<<"连接对象";
    ui->tableWidget_trans->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->tableWidget_trans->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableWidget_trans->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableWidget_trans->setColumnCount(headerText.count());
    ui->tableWidget_trans->setHorizontalHeaderLabels(headerText);
    ui->tableWidget_trans->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);

    WizardBusTableDelegate* delegate = new WizardBusTableDelegate(this);
    ui->tableWidget_bus->setItemDelegate(delegate);

    connect(delegate,&WizardBusTableDelegate::editingFinished,this,&DiagramEditorWizard::onDelegateFinishEdit);
    connect(ui->tableWidget_bus, &QTableWidget::customContextMenuRequested, this, &DiagramEditorWizard::onBusIndexRbtnClicked);
    connect(ui->tableWidget_trans, &QTableWidget::customContextMenuRequested, this, &DiagramEditorWizard::onTransIndexRbtnClicked);

    connect(ui->listWidget_bay,&QListWidget::itemClicked,this,&DiagramEditorWizard::onBayListSelected);

    _divideType.insert(1,"A段");
    _divideType.insert(2,"B段");
    _divideType.insert(3,"C段");
    _divideType.insert(4,"D段");
    _divideType.insert(5,"E段");
    _divideType.insert(6,"F段");
    _divideType.insert(7,"G段");
    _divideType.insert(8,"H段");
}

void DiagramEditorWizard::reOrderBus()
{
    reindexQMap(_mapBus);
    //移动后结构只变序号(待测试)

    for(int row = 0 ;row < ui->tableWidget_bus->rowCount();++row)
    {
        QTableWidgetItem* pItem = ui->tableWidget_bus->item(row,0);
        pItem->setText("第"+QString::number(row+1)+"层");
        pItem->setData(Qt::UserRole,row);
    }
}

void DiagramEditorWizard::generateBayStruct()
{
    for(auto iter = _mapBus.begin();iter != _mapBus.end();++iter)
    {
        if(iter->nState == 0)     //只生成修改过的程序
            continue;
        if(iter->nState == 2){      //已修改
            clearTargetLevelContent(iter.key());
        }
        else if(iter->nState == 1){
            QListWidgetItem* item = new QListWidgetItem("第"+QString::number(iter->nIndex+1)+"层");
            item->setData(Qt::UserRole,iter->nIndex);
            ui->listWidget_bay->addItem(item);
        }
        iter->nState = 0;

        QString sVoltage;   //电压前缀
        sVoltage = QString::number(iter->dVoltage)+"kV";

        if(iter->nLineType == 1){       //单母
            int nDivide = iter->nNum1;

            for(int i = 0;i < nDivide;++i){
                QString sDivPre;    //分段前缀
                if(nDivide == 1){//不划分
                }
                else{
                    sDivPre = _divideType.value(i+1);
                }

                auto pContainer = new DiagramEditorStructContainer(this);
                pContainer->setId(QUuid::createUuid().toString());
                auto pBus = new DiagramEditorBusBlock(this);
                pBus->setId(QUuid::createUuid());
                pBus->setBusPro(sVoltage+"母线"+sDivPre,1,iter->dVoltage,0,i+1);
                pContainer->insertBlock(1,pBus);

                _mapSturctContainer[iter.key()].insert(i,pContainer);
            }
        }
        else{       //双母
            int nDivide1 = iter->nNum1;     // Ⅰ母
            int nDivide2 = iter->nNum2;    //  Ⅱ母

            if(nDivide1 == nDivide2){       //双母线划分相同
                for(int i = 0;i < nDivide1;++i){
                    QString sDivPre;    //分段前缀
                    if(nDivide1 == 1){//不划分
                    }
                    else{
                        sDivPre = _divideType.value(i+1);
                    }

                    auto pContainer = new DiagramEditorStructContainer(this);
                    pContainer->setId(QUuid::createUuid().toString());

                    auto pBus1 = new DiagramEditorBusBlock(this);
                    pBus1->setId(QUuid::createUuid());
                    pBus1->setBusPro(sVoltage+"Ⅰ母"+sDivPre,1,iter->dVoltage,1,i+1);
                    pContainer->insertBlock(1,pBus1);

                    auto pBus2 = new DiagramEditorBusBlock(this);
                    pBus2->setId(QUuid::createUuid());
                    pBus2->setBusPro(sVoltage+"Ⅱ母"+sDivPre,1,iter->dVoltage,2,i+1);
                    pContainer->insertBlock(2,pBus2);
                    _mapSturctContainer[iter.key()].insert(i,pContainer);

                }
            }
            else{       //双母线划分不同
                if(nDivide1 > nDivide2){    //2母段数少于1母
                    for(int i = 0;i < nDivide1;++i){
                        QString sDivPre1 = _divideType.value(i+1);    //分段前缀

                        auto pContainer = new DiagramEditorStructContainer(this);

                        auto pBus1 = new DiagramEditorBusBlock(this);
                        pBus1->setId(QUuid::createUuid());
                        pBus1->setBusPro(sVoltage+"Ⅰ母"+sDivPre1,1,iter->dVoltage,1,i+1);
                        pContainer->insertBlock(1,pBus1);

                        if(i < nDivide2){
                            QString sDivPre2;
                            if(nDivide2 == 1){//不划分
                            }
                            else{
                                sDivPre2 = _divideType.value(i+1);
                            }

                            auto pBus2 = new DiagramEditorBusBlock(this);
                            pBus2->setId(QUuid::createUuid());
                            pBus2->setBusPro(sVoltage+"Ⅱ母"+sDivPre2,1,iter->dVoltage,2,i+1);
                            pContainer->insertBlock(2,pBus2);
                        }

                        _mapSturctContainer[iter.key()].insert(i,pContainer);
                    }
                }
                else{
                    for(int i = 0;i < nDivide2;++i){    //1母段数少于2母
                        QString sDivPre2 = _divideType.value(i+1);    //分段前缀

                        auto pContainer = new DiagramEditorStructContainer(this);
                        auto pBus2 = new DiagramEditorBusBlock(this);
                        pBus2->setId(QUuid::createUuid());
                        pBus2->setBusPro(sVoltage+"Ⅱ母"+sDivPre2,1,iter->dVoltage,2,i+1);
                        pContainer->insertBlock(2,pBus2);

                        if(i < nDivide1){
                            QString sDivPre1;
                            if(nDivide1 == 1){//不划分
                            }
                            else{
                                sDivPre1 = _divideType.value(i+1);
                            }

                            auto pBus1 = new DiagramEditorBusBlock(this);
                            pBus1->setId(QUuid::createUuid());
                            pBus1->setBusPro(sVoltage+"Ⅰ母"+sDivPre1,1,iter->dVoltage,1,i+1);
                            pContainer->insertBlock(1,pBus1);
                        }

                        _mapSturctContainer[iter.key()].insert(i,pContainer);
                    }
                }
            }
        }
    }
}

void DiagramEditorWizard::flushTransPage()
{
    ui->tableWidget_trans->clearContents();
    ui->tableWidget_trans->setRowCount(0);
    QList<DiagramEditorBaseBlock*> lst = getTargetLevelBlocks(g_transformerLevel,3);
    for(auto& block:lst){
        auto pItem = dynamic_cast<DiagramEditorTransformerBlock*>(block);
        if(pItem){
            DiagramEditorWizardTransformerInfo info;
            info.sName = pItem->getName();
            info.nType = pItem->getTransType();
            auto lstCon = pItem->getConnect();      //获取间隔所连对象的名称

            for(auto& conId:lstCon){
                if(_mapConnect.contains(conId)){
                    auto con = _mapConnect.value(conId);
                    QString sOpposite = con.getOpposite(pItem->getName()).sName;

                    QString sPos;
                    if(con.nPara == 0){
                        sPos = "高压侧";
                    }
                    else if(con.nPara == 1){
                        sPos = "中压侧";
                    }
                    else if(con.nPara == 2){
                        sPos = "低压侧";
                    }

                    EditorTransConnection editorCon;
                    editorCon.nPara = con.nPara;
                    editorCon.sName = sOpposite;
                    info.lstBindObj.append(editorCon);
                }
            }

            addTransformer(info);
        }
    }
}

int DiagramEditorWizard::getContainerIndex(int nLevel,DiagramEditorStructContainer* pCon)
{
    auto lstCon = _mapSturctContainer.value(nLevel);
    if(!lstCon.empty()){
        for(int i = 0;i < lstCon.size();++i){
            if(lstCon[i]->getId() == pCon->getId()){
                return i;
            }
        }
    }
    return -1;
}

QUuid DiagramEditorWizard::addConnection(const QString& str1,const QString& str2,int nType1,int nType2,int nPara)
{
    for(auto& con:_mapConnect){
        if((con.con1.sName == str1 && con.con2.sName == str2) || (con.con1.sName == str2 && con.con2.sName == str1)){     //已存在不插入
            return con.uid;
        }
    }

    DiagramEditorBriefConnect con;
    con.uid = QUuid::createUuid();
    con.con1.sName = str1;
    con.con1.nType = nType1;
    con.con2.sName = str2;
    con.con2.nType = nType2;
    con.nPara = nPara;

    _mapConnect.insert(con.uid,con);
    return con.uid;
}

QList<QUuid> DiagramEditorWizard::findConnectionByBlock(QString sName,int nType)
{
    QList<QUuid> lst;
    for(auto iter = _mapConnect.begin(); iter != _mapConnect.end();++iter){
        auto con = iter.value();
        if((con.con1.sName == sName && con.con1.nType == nType) || (con.con2.sName == sName && con.con2.nType == nType)){
            if(!lst.contains(con.uid))
                lst.append(con.uid);
        }
    }

    return lst;
}

void DiagramEditorWizard::removeConnection(QUuid uid)
{
    _mapConnect.remove(uid);
}

DiagramEditorProjectInfo DiagramEditorWizard::getCurPara()
{
    DiagramEditorProjectInfo info;


    QMap<int,QList<DiagramEditorContainerInfo>> mapLst;
    for(auto iter = _mapSturctContainer.begin(); iter != _mapSturctContainer.end();++iter){
        QList<DiagramEditorContainerInfo>   lstInfo;
        for(auto con:iter.value()){
            DiagramEditorContainerInfo  conInfo;
            conInfo.mapBlockInfo = con->getMapBlocksData();
            conInfo.sId = con->getId();
            conInfo.dMidUpY = con->getMidUpY();
            conInfo.dMidDownY = con->getMidDownY();
            conInfo.dStartX = con->getStartX();
            conInfo.dStartY = con->getStartY();
            conInfo.dWidth = con->getWidth();
            conInfo.dHeight = con->getHeight();
            conInfo.dMaxUpH = con->getMaxUpH();
            conInfo.dMaxDownH = con->getMaxDownH();
            lstInfo.append(conInfo);
        }
        mapLst.insert(iter.key(),lstInfo);
    }
    info.mapBus = _mapBus;
    info.mapSturctContainer = mapLst;
    info.mapConnect = _mapConnect;
    return info;
}

void DiagramEditorWizard::setPara(DiagramEditorProjectInfo info)
{
    _mapBus = info.mapBus;
    _mapConnect = info.mapConnect;
    for(auto iter = info.mapSturctContainer.begin(); iter != info.mapSturctContainer.end();++iter){

        for(int i = 0;i < iter.value().size();++i){
            auto conInfo = iter.value()[i];
            auto pContainer = new DiagramEditorStructContainer(this);
            pContainer->setId(conInfo.sId);

            pContainer->setMidUpY(conInfo.dMidUpY);
            pContainer->setMidDownY(conInfo.dMidDownY);
            pContainer->setWidth(conInfo.dWidth);
            pContainer->setHeight(conInfo.dHeight);
            pContainer->setStartX(conInfo.dStartX);
            pContainer->setStartY(conInfo.dStartY);
            pContainer->setMaxUpH(conInfo.dMaxUpH);
            pContainer->setMaxDownH(conInfo.dMaxDownH);
            for(auto ite = conInfo.mapBlockInfo.begin(); ite != conInfo.mapBlockInfo.end();++ite){      //<位置0123,容器列表>
                for(auto &blockInfo:ite.value()){
                    DiagramEditorBaseBlock* pBlock = nullptr;
                    if(blockInfo.nType == 1){
                        auto pBus = new DiagramEditorBusBlock(this);
                        pBus->setId(blockInfo.uid);
                        pBus->setType(blockInfo.nType);
                        pBus->setBusPro(blockInfo.sName,1,blockInfo.fVoltage,blockInfo.nBusType,blockInfo.nIndex);
                        pBlock = pBus;
                    }
                    else if(blockInfo.nType == 2){
                        DiagramEditorBayBlock* pBay = new DiagramEditorBayBlock(this);
                        pBay->setId(blockInfo.uid);
                        pBay->setName(blockInfo.sName);
                        pBay->setType(blockInfo.nType);
                        pBay->setBayType(blockInfo.nBayType);
                        for(auto& uid:blockInfo._lstCon){
                            pBay->addConnect(uid);
                        }
                        pBay->setBayInfo(blockInfo.bayInfo);
                        pBlock = pBay;
                    }
                    else if(blockInfo.nType == 3){
                        auto pTrans = new DiagramEditorTransformerBlock(this);
                        pTrans->setId(blockInfo.uid);
                        pTrans->setName(blockInfo.sName);
                        pTrans->setType(blockInfo.nType);
                        pTrans->setTransType(blockInfo.nTransType);
                        for(auto& uid:blockInfo._lstCon){
                            pTrans->addConnect(uid);
                        }
                        pTrans->setTransInfo(blockInfo.transInfo);
                        pBlock = pTrans;
                    }
                    if(pBlock){
                        pBlock->setContainerLevel(blockInfo.nContainerLevel);
                        pBlock->setRecSize(blockInfo.recSize);
                        pBlock->setSeceneDelta(blockInfo.sceneDelta);
                        pBlock->setEditState(blockInfo.bEditState);
                        pContainer->insertBlock(ite.key(),pBlock);
                    }
                }
            }

            _mapSturctContainer[iter.key()].insert(i,pContainer);
        }
    }
    resetBusByData();
    resetBayByData();
    resetTransByData();
    emit wizardFinish();
}

void DiagramEditorWizard::addTransformer(DiagramEditorWizardTransformerInfo info)
{
    int row = ui->tableWidget_trans->rowCount();
    ui->tableWidget_trans->insertRow(row);

    //名称
    QTableWidgetItem* nameItem = new QTableWidgetItem(info.sName);
    ui->tableWidget_trans->setItem(row, 0, nameItem);

    QString sType;
    switch (info.nType) {
    case TransformerType::twoWinding:
        sType = "两绕组变压器";
        break;
    case TransformerType::threeWinding:
        sType = "三绕组变压器";
        break;
    default:
        break;
    }
    //类型
    QTableWidgetItem* typeItem = new QTableWidgetItem(sType);
    ui->tableWidget_trans->setItem(row, 1, typeItem);

    //连接
    QString str;
    for(auto& obj:info.lstBindObj){
        str += obj.sName+"、";
    }
    QTableWidgetItem* connectItem = new QTableWidgetItem(str);
    ui->tableWidget_trans->setItem(row, 2, connectItem);
}

template <typename T> void DiagramEditorWizard::reindexQMap(QMap<int, T> &map) {
    if (map.isEmpty())
        return;

    // 保存原数据的值（按原键升序排列）
    QVector<T> values;
    values.reserve(map.size());
    for (auto it = map.begin(); it != map.end(); ++it) {
        values.append(std::move(it.value())); // 使用移动语义
    }

    // 清空原map并重新插入连续键
    map.clear();
    for (int newKey = 0; newKey < values.size(); ++newKey) {
        map.insert(newKey, std::move(values[newKey])); // 再次移动
    }
}

void DiagramEditorWizard::clearTargetLevelContent(int nLevel)
{
    if(_mapSturctContainer.contains(nLevel)){
        auto lstCon = _mapSturctContainer.take(nLevel);
        for(auto &pCon:lstCon){
            auto mapBlock = pCon->getBlockMap();
            for(auto &lstBlock:mapBlock){
                for(auto& pBlock:lstBlock){
                    auto lst = findConnectionByBlock(pBlock->getName(),pBlock->getType());          //断开删除block相关的连接
                    if(!lst.empty()){
                        for(auto &uid:lst){
                            removeConnection(uid);
                        }
                    }
                }
            }
            delete pCon;
        }
    }
}

void DiagramEditorWizard::resetBusByData()
{
    ui->tableWidget_bus->clearContents();
    ui->tableWidget_bus->setRowCount(0);

    for(auto iter = _mapBus.begin();iter != _mapBus.end();++iter){
        int row = ui->tableWidget_bus->rowCount();
        ui->tableWidget_bus->insertRow(row);
        const DiagramEditorWizardBusInfo& data = iter.value();

        QTableWidgetItem* pItem = new QTableWidgetItem("第"+QString::number(iter.key()+1)+"层");
        pItem->setData(Qt::UserRole,data.nIndex);
        ui->tableWidget_bus->setItem(iter.key(), 0, pItem);

        QTableWidgetItem* pItemVoltage = new QTableWidgetItem(QString::number(data.dVoltage)+"KV");
        ui->tableWidget_bus->setItem(iter.key(), 1, pItemVoltage);

        // 列2 - 单双母 (ComboBox)
        QString sLineType;
        if(data.nLineType == 1){
            sLineType = "单母线";
        }
        else if(data.nLineType == 2){
            sLineType = "双母线";
        }
        QTableWidgetItem* pItemLine = new QTableWidgetItem(sLineType);
        ui->tableWidget_bus->setItem(iter.key(), 2, pItemLine);

        QString sDivide;
        QTableWidgetItem* pItemDivide = new QTableWidgetItem();
        if(data.nLineType == 1){
            QString sD1;
            if(data.nNum1 == 1)
                sD1 = "不分段";
            else
                sD1 = QString::number(data.nNum1);
            sDivide = "母线:"+sD1;
        }
        else if(data.nLineType == 2){
            QString sD1;
            if(data.nNum1 == 1)
                sD1 = "不分段";
            else
                sD1 = QString::number(data.nNum1);

            QString sD2;
            if(data.nNum2 == 1)
                sD2 = "不分段";
            else
                sD2 = QString::number(data.nNum2);
            sDivide = "母线1:"+sD1+";"+"母线2:"+sD2;
        }
        pItemDivide->setText(sDivide);
        ui->tableWidget_bus->setItem(iter.key(), 3, pItemDivide);

        // 列4 - 接线方式 (ComboBox)
        QString sConnectType;
        if(data.connectType == 1){
            sConnectType = "分段连接";
        }
        QTableWidgetItem* pItemConnect = new QTableWidgetItem(sConnectType);
        ui->tableWidget_bus->setItem(row, 4, pItemConnect);
    }
}

void DiagramEditorWizard::resetBayByData()
{
    if(_baySettingDlg == nullptr){
        _baySettingDlg = new DiagramEditorBaySettingDlg(this);
        _baySettingDlg->setParent(this);
    }
    ui->listWidget_bay->clear();
    for(auto iter = _mapBus.begin();iter != _mapBus.end();++iter)
    {
        iter->nState = 0;
        QListWidgetItem* item = new QListWidgetItem("第"+QString::number(iter->nIndex+1)+"层");
        item->setData(Qt::UserRole,iter->nIndex);
        ui->listWidget_bay->addItem(item);
    }
}

void DiagramEditorWizard::resetTransByData()
{
    flushTransPage();
}

void DiagramEditorWizard::onOkClicked()
{
    emit wizardFinish();
    hide();
}

void DiagramEditorWizard::onCancelClicked()
{
    hide();
}

void DiagramEditorWizard::onLastClicked()
{
    if(ui->tabWidget->currentIndex() == 2){
        ui->tabWidget->setCurrentIndex(1);
        ui->stackedWidget_last->setCurrentIndex(1);
        ui->stackedWidget_next->setCurrentIndex(0);
    }
    else if(ui->tabWidget->currentIndex() == 1){
        ui->tabWidget->setCurrentIndex(0);
        ui->stackedWidget_last->setCurrentIndex(0);
        ui->stackedWidget_next->setCurrentIndex(0);
    }
}

void DiagramEditorWizard::onNextClicked()
{
    if(ui->tabWidget->currentIndex() == 0){
        ui->tabWidget->setCurrentIndex(1);
        ui->stackedWidget_last->setCurrentIndex(1);
        ui->stackedWidget_next->setCurrentIndex(0);

        generateBayStruct();
        if(ui->listWidget_bay->count()){
            QListWidgetItem* targetItem = ui->listWidget_bay->item(0);
            // 确保项有效
            if (targetItem) {
                // 手动发射itemClicked信号
                emit ui->listWidget_bay->itemClicked(targetItem);
                // 如果需要同时选中该项
                ui->listWidget_bay->setCurrentItem(targetItem);
            }
        }
    }
    else if(ui->tabWidget->currentIndex() == 1){
        ui->tabWidget->setCurrentIndex(2);
        ui->stackedWidget_last->setCurrentIndex(1);
        ui->stackedWidget_next->setCurrentIndex(1);
    }
}

void DiagramEditorWizard::onAddBusClicked()
{
    int row = ui->tableWidget_bus->rowCount();
    ui->tableWidget_bus->insertRow(row);

    // 层级
    QTableWidgetItem* levelItem = new QTableWidgetItem("第"+QString::number(row+1)+"层");
    ui->tableWidget_bus->setItem(row, 0, levelItem);
    levelItem->setData(Qt::UserRole,row);

    // 电压等级
    QTableWidgetItem* voltageItem = new QTableWidgetItem("未设置");
    ui->tableWidget_bus->setItem(row, 1, voltageItem);

    // 主接线
    QTableWidgetItem* typeItem = new QTableWidgetItem("未设置");
    ui->tableWidget_bus->setItem(row, 2, typeItem);

    // 分段方式
    QTableWidgetItem* divideItem = new QTableWidgetItem("未设置");
    ui->tableWidget_bus->setItem(row, 3, divideItem);

    // 接线方式
    QTableWidgetItem* connectItem = new QTableWidgetItem("未选择");
    ui->tableWidget_bus->setItem(row, 4, connectItem);

    DiagramEditorWizardBusInfo info;
    info.nIndex = row;
    info.nState = 1;        //新建
    _mapBus.insert(row,info);
}

void DiagramEditorWizard::onAddBayClicked()
{
    if(_baySettingDlg == nullptr){
        _baySettingDlg = new DiagramEditorBaySettingDlg(this);
        _baySettingDlg->setParent(this);
    }
    auto pItem = ui->listWidget_bay->currentItem();
    if(pItem)
        _baySettingDlg->showDlg(pItem->data(Qt::UserRole).toInt());
}

void DiagramEditorWizard::onAddTransClicked()
{
    if(_transSettingDlg == nullptr){
        _transSettingDlg = new DiagramEditorTransSettingDlg(this);
        _transSettingDlg->setParent(this);
    }
    _transSettingDlg->showDlg();
}

void DiagramEditorWizard::onAddBayFinished(DiagramEditorWizardBayInfo info)
{
    int curIndex = ui->listWidget_bay->currentItem()->data(Qt::UserRole).toInt();       //当前层级

    if(!info.lstBindObj.isEmpty()){
        QList<int> lstlevel;    //层级
        if(info.nType == BayType::busSectionBay)
        {
            for(auto& sName:info.lstBindObj){
                auto pBlock = getBlockByName(curIndex,1,sName);
                if(pBlock){
                    int n = pBlock->getContainerLevel();
                    lstlevel.append(n);
                }
            }

            if(info.lstBindObj.size() < 2){
                QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"分段连接1%连接对象不足").arg(info.sName));
                return;
            }
            else{
                if(lstlevel.size() > 1){
                    if(lstlevel[0] != lstlevel[1]){
                        QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"分段连接1%连接母线错位").arg(info.sName));
                    }
                }
            }
        }

        DiagramEditorBayBlock* pBlock = new DiagramEditorBayBlock(this);
        pBlock->setId(QUuid::createUuid());
        pBlock->setName(info.sName);
        pBlock->setType(2);
        pBlock->setBayType(info.nType);
        for(auto& sName:info.lstBindObj){
            QUuid uid = addConnection(pBlock->getName(),sName,2,1);
            pBlock->addConnect(uid);
        }

        if(info.nType == BayType::busSectionBay){   //分段间隔

            auto pC1 = getContainerByBlock(curIndex,1,info.lstBindObj.first());
            auto pC2 = getContainerByBlock(curIndex,1,info.lstBindObj.last());
            int idx1 = getContainerIndex(curIndex,pC1);
            int idx2 = getContainerIndex(curIndex,pC2);
            int n = qAbs(idx1-idx2);

            if(n == 1){    //两个容器相连，未插入container，新建
                auto pContainer = new DiagramEditorStructContainer(this);
                pContainer->setId(QUuid::createUuid().toString());

                QList<int> lstIndex;
                for(auto& sName:info.lstBindObj){       //寻找container所处index
                    auto pBlock = getBlockByName(curIndex,1,sName);
                    if(pBlock){
                        auto pCon = pBlock->getCurContainer();
                        if(pCon){
                            int nRes = getContainerIndex(curIndex,pCon);
                            if(nRes != -1){
                                lstIndex.append(nRes);
                            }
                        }
                    }
                }

                if(!lstIndex.isEmpty()){
                    int maxIndex = lstIndex.first(); // 取第一个元素作为初始值
                    for (int i : lstIndex) {
                        if (i > maxIndex) {
                            maxIndex = i; // 更新最大值
                        }
                    }
                    _mapSturctContainer[curIndex].insert(maxIndex,pContainer);      //将容器插入到最右的前一个
                }

                if(lstlevel.size() > 1){       //判断连接母线在container中的层级
                    if((lstlevel.value(0) == lstlevel.value(1))){     //加入container最上层
                        if((lstlevel.value(0) == 1)){
                            pContainer->insertBlock(0,pBlock);
                        }
                        else if((lstlevel.value(0) == 2)){        //加入container最下层
                            pContainer->insertBlock(3,pBlock);
                        }
                    }
                }
            }
            else{       //使用已有container
                int nMiddle = (idx1+idx2)*0.5;
                auto pContainer = _mapSturctContainer[curIndex].value(nMiddle);
                if(pContainer){
                    if(lstlevel.size() > 1){       //判断连接母线在container中的层级
                        if((lstlevel.value(0) == lstlevel.value(1))){     //加入container最上层
                            if((lstlevel.value(0) == 1)){
                                pContainer->insertBlock(0,pBlock);
                            }
                            else if((lstlevel.value(0) == 2)){        //加入container最下层
                                pContainer->insertBlock(3,pBlock);
                            }
                        }
                    }
                }
            }
        }
        else if(info.nType == BayType::incomingBay || info.nType == BayType::ptBay || info.nType == BayType::busCouplerBay){       //进线间隔、母联间隔、pt间隔在上边
            auto pContainer = getContainerByBlock(curIndex,1,info.lstBindObj.first());
            pContainer->insertBlock(0,pBlock);
        }
        else{       //其他间隔
            auto pContainer = getContainerByBlock(curIndex,1,info.lstBindObj.first());
            pContainer->insertBlock(3,pBlock);
        }
        _bayContentDlg->flushData(curIndex);
    }
}

void DiagramEditorWizard::onAddTransFinished(DiagramEditorWizardTransformerInfo info)
{
    auto pContainer = new DiagramEditorStructContainer(this);
    auto pTrans = new DiagramEditorTransformerBlock(this);

    pTrans->setId(QUuid::createUuid());
    pTrans->setName(info.sName);
    pTrans->setType(3);
    pTrans->setTransType(info.nType);

    for(auto& obj:info.lstBindObj){
        QUuid uid = addConnection(pTrans->getName(),obj.sName,3,2,obj.nPara);
        pTrans->addConnect(uid);
        auto pBlock = getBlockByName_all(obj.sName);        //连接的双方都保存连接(todo:修改时删除对面保存的连接)
        if(pBlock){
            pBlock->addConnect(uid);
        }
    }

    pContainer->insertBlock(1,pTrans);          //***变压器添加到了1层***

    int nIndex =_mapSturctContainer.value(g_transformerLevel).size();
    _mapSturctContainer[g_transformerLevel].insert(nIndex,pContainer);

    flushTransPage();
}

void DiagramEditorWizard::onDelegateFinishEdit(const QModelIndex &index, const QString &value)
{
    int row = index.row();
    int col = index.column();
    if(_mapBus.contains(row)){          //todo:增加缓存，点击下页保存
        if(col == 1){
            _mapBus[row].dVoltage = value.toDouble();
        }
        else if(col == 2){
            _mapBus[row].nLineType = value.toInt();
            QTableWidgetItem *divideItem = ui->tableWidget_bus->item(row, 3);
            divideItem->setText("未设置");
            divideItem->setData(Qt::UserRole,0);
        }
        else if(col == 3){
            QStringList lst = value.split(",");
            if(lst.size() > 1)      //双母
            {
                _mapBus[row].nNum1 = lst[0].toInt();
                _mapBus[row].nNum2= lst[1].toInt();
            }
            else{       //单母
                _mapBus[row].nNum1 = lst[0].toInt();
            }
        }
        else if(col == 4){
            _mapBus[row].connectType = value.toInt();
        }
        _mapBus[row].nState = 1;
    }
}

void DiagramEditorWizard::onBusDeleteClicked()
{
    // 获取当前选中的索引
    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:
    {
        QModelIndexList selectedIndexes = ui->tableWidget_bus->selectionModel()->selectedRows();
        if (selectedIndexes.isEmpty()) {
            return; // 没有选中任何行
        }

        // 获取当前选中的第一项索引
        QModelIndex index = selectedIndexes.first();
        if (!index.isValid()) {
            return;
        }

        QModelIndex indexName = index.sibling(index.row(),0);
        int nIndex = indexName.data(Qt::UserRole).toInt();
        if(_mapBus.contains(nIndex)){
            _mapBus.remove(nIndex);
            if(_mapSturctContainer.contains(nIndex)){       //如果删除行，同步删除该行关联的内容
                clearTargetLevelContent(nIndex);
            }
        }

        for (int i = 0; i < ui->listWidget_bay->count(); ++i) {
            QListWidgetItem *item = ui->listWidget_bay->item(i);
            // 处理每个项
            QString text = item->text();
            qDebug() << "Item" << i << ":" << text;
            int idx = item->data(Qt::UserRole).toInt();
            if(idx == nIndex){
                auto item = ui->listWidget_bay->takeItem(i);
                delete item;
            }
        }

        int currentRow = ui->tableWidget_bus->currentRow();
        if (currentRow == -1) {
            return;  // 没有选中行
        }

        ui->tableWidget_bus->removeRow(currentRow);
        reOrderBus();
    }
    break;
    case QMessageBox::Cancel:
        // Cancel was clicked
        break;
    default:
        // should never be reached
        break;
    }
}

void DiagramEditorWizard::onBusIndexRbtnClicked(const QPoint &pos)
{
    // 获取当前点击的位置对应的索引
    QModelIndex index = ui->tableWidget_bus->indexAt(pos);
    if (!index.isValid()) {
        return; // 如果点击的是空白区域，直接返回
    }

    QMenu menu;
    QAction *deleteAction = new QAction("删除本层", this);
    menu.addAction(deleteAction);

    // 连接删除菜单项的触发信号与槽函数
    connect(deleteAction, &QAction::triggered, this, &DiagramEditorWizard::onBusDeleteClicked);

    // 在点击位置显示菜单
    menu.exec(ui->tableWidget_bus->mapToGlobal(pos));
}

void DiagramEditorWizard::onTransDeleteClicked()
{
    // 获取当前选中的索引
    QModelIndexList selectedIndexes = ui->tableWidget_trans->selectionModel()->selectedRows();
    if (selectedIndexes.isEmpty()) {
        return; // 没有选中任何行
    }

    // 获取当前选中的第一项索引
    QModelIndex index = selectedIndexes.first();
    if (!index.isValid()) {
        return;
    }

    QModelIndex indexName = index.sibling(index.row(),0);
    QString sName = indexName.data().toString();

    DiagramEditorStructContainer* pCon = getContainerByBlock(g_transformerLevel,3,sName);
    bool res = removeBlockByName(g_transformerLevel,3,sName);
    if(pCon){   //同时删除container(一个container包含一个变压器)
        /*for(auto iter = _mapSturctContainer[g_transformerLevel].begin(); iter != _mapSturctContainer[g_transformerLevel].end();++iter){
            if(*iter == pCon){
                delete pCon;
                _mapSturctContainer[g_transformerLevel].erase(iter);
                break;
            }
        }*/
        for(int i = 0;i < _mapSturctContainer[g_transformerLevel].size();++i){
            if(_mapSturctContainer[g_transformerLevel][i] == pCon){
                delete pCon;
                _mapSturctContainer[g_transformerLevel].removeAt(i);
                break;
            }
        }
    }
    if(res){
        flushTransPage();
    }
    else{
        return;
    }

    int currentRow = ui->tableWidget_trans->currentRow();
    if (currentRow == -1) {
        return;  // 没有选中行
    }

    ui->tableWidget_trans->removeRow(currentRow);
}

void DiagramEditorWizard::onTransModifyClicked()
{
    // 获取当前选中的索引
    QModelIndexList selectedIndexes = ui->tableWidget_trans->selectionModel()->selectedRows();
    if (selectedIndexes.isEmpty()) {
        return; // 没有选中任何行
    }

    // 获取当前选中的第一项索引
    QModelIndex index = selectedIndexes.first();
    if (!index.isValid()) {
        return;
    }

    QModelIndex indexName = index.sibling(index.row(),0);
    QString sName = indexName.data().toString();

    DiagramEditorBaseBlock* pBlock = getBlockByName(g_transformerLevel,3,sName);
    if(pBlock){
        auto pTran = dynamic_cast<DiagramEditorTransformerBlock*>(pBlock);
        if(pTran)
            _transSettingDlg->showDlg(pTran);
    }
}

void DiagramEditorWizard::onTransIndexRbtnClicked(const QPoint &pos)
{
    // 获取当前点击的位置对应的索引
    QModelIndex index = ui->tableWidget_bus->indexAt(pos);
    if (!index.isValid()) {
        return; // 如果点击的是空白区域，直接返回
    }

    QMenu menu;
    QAction *deleteAction = new QAction("移除变压器", this);
    QAction *modifyAction = new QAction("修改变压器", this);
    menu.addAction(deleteAction);
    menu.addAction(modifyAction);

    // 连接删除菜单项的触发信号与槽函数
    connect(deleteAction, &QAction::triggered, this, &DiagramEditorWizard::onTransDeleteClicked);
    connect(modifyAction, &QAction::triggered, this, &DiagramEditorWizard::onTransModifyClicked);

    // 在点击位置显示菜单
    menu.exec(ui->tableWidget_bus->mapToGlobal(pos));
}

void DiagramEditorWizard::onBayListSelected(QListWidgetItem* pItem)
{
    int nIndex = pItem->data(Qt::UserRole).toInt();
    ui->label_level->setText("第"+QString::number(nIndex+1)+"层");
    _bayContentDlg->flushData(nIndex);
}

QList<DiagramEditorBaseBlock*>  DiagramEditorWizard::getTargetLevelBlocks(int nLevel,int nType)
{
    QList<DiagramEditorBaseBlock*> lstBlock;
    for(auto iter = _mapSturctContainer.begin();iter != _mapSturctContainer.end();++iter){
        if(iter.key() == nLevel){
            for(auto& container:iter.value())
            {
                auto mapBlock = container->getBlockMap();
                if(!mapBlock.isEmpty()){
                    for(auto& lst:mapBlock)
                    {
                        for(auto& block:lst)
                        {
                            if(block->getType() == nType){          //返回对应type
                                lstBlock.append(block);
                            }
                        }
                    }
                }
            }
        }
    }
    return lstBlock;
}

QList<DiagramEditorBaseBlock*>  DiagramEditorWizard::getTargetLevelBlocks_all(int nLevel)
{
    QList<DiagramEditorBaseBlock*> lstBlock;
    for(auto iter = _mapSturctContainer.begin();iter != _mapSturctContainer.end();++iter){
        if(iter.key() == nLevel){
            for(auto& container:iter.value())
            {
                auto mapBlock = container->getBlockMap();
                for(auto& lst:mapBlock)
                {
                    for(auto& block:lst)
                    {
                        lstBlock.append(block);
                    }
                }
            }
        }
    }
    return lstBlock;
}

DiagramEditorStructContainer* DiagramEditorWizard::getContainerByBlock(int nLevel,int nType,QString sName)
{
    DiagramEditorStructContainer* pContainer = nullptr;
    auto lstBlock = getTargetLevelBlocks(nLevel,nType);
    for(auto& block:lstBlock){
        if(block->getName() == sName){
            pContainer = block->getCurContainer();
            break;
        }
    }
    return pContainer;
}

DiagramEditorStructContainer* DiagramEditorWizard::getContainerByBlock_all(QString sName)
{
    DiagramEditorStructContainer* pContainer = nullptr;
    for(auto iter = _mapSturctContainer.begin(); iter != _mapSturctContainer.end();++iter){
        auto lstBlock = getTargetLevelBlocks_all(iter.key());
        for(auto& block:lstBlock){
            if(block->getName() == sName){
                pContainer = block->getCurContainer();
                break;
            }
        }
    }

    return pContainer;
}

DiagramEditorBaseBlock* DiagramEditorWizard::getBlockByName(int nLevel,int nType,QString sName)
{
    auto lstBlock = getTargetLevelBlocks(nLevel,nType);
    for(auto& block:lstBlock){
        if(block->getName() == sName){
            return block;
        }
    }
    return nullptr;
}

DiagramEditorBaseBlock* DiagramEditorWizard::getBlockByName_all(QString sName)
{
    for(auto iter = _mapSturctContainer.begin(); iter != _mapSturctContainer.end();++iter){
        auto lstBlock = getTargetLevelBlocks_all(iter.key());
        for(auto& block:lstBlock){
            if(block->getName() == sName){
                return block;
            }
        }
    }
    return nullptr;
}

bool DiagramEditorWizard::removeBlockByName(int nLevel,int nType,const QString& sName)
{
    DiagramEditorStructContainer* pCon = getContainerByBlock(nLevel,nType,sName);
    if(pCon){
        auto& mapBlock = pCon->getBlockMap();
        for(auto& lst:mapBlock){

            for(int i = 0;i< lst.size();++i){
                if(lst[i]->getName() == sName){
                    QList<QUuid> lstUid =  lst[i]->getConnect();
                    for(auto uid:lstUid){       //删除对象前删除连接
                        auto con = _mapConnect.value(uid);
                        QString sOppo = con.getOpposite(sName).sName;     //删除相连的对象中连接信息
                        auto pBlock = getBlockByName_all(sOppo);
                        if(pBlock){
                            pBlock->removeConnect(uid);
                        }

                        removeConnection(uid);
                    }

                    delete lst[i];
                    lst.removeAt(i);
                    return true;
                }
            }
        }
    }
    return false;
}