#include <QMessageBox>
#include <QMenu>
#include <QStandardItemModel>
#include "diagramEditor/diagramEditorBayDetailAddDlg.h"
#include "diagramEditor/diagramEditorBayDetailSettingDlg.h"
#include "ui_diagramEditorBayDetailAddDlg.h"
#include "diagramEditor/diagramEditorBaseBlock.h"
#include "diagramEditor/diagramEditorWizard.h"
#include "include/instance/baseTypeManager.h"
#include "titleBar.h"
#include <QSizeGrip>

DiagramEditorBayDetailAddDlg::DiagramEditorBayDetailAddDlg(QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::diagramEditorBayDetailAddDlg)
    ,_selectedModel(nullptr)
    ,_pParent(nullptr)
    ,_bindItemModel(nullptr)
    ,_pSizeGrip(nullptr)
{
    ui->setupUi(this);
    this->setWindowFlags(Qt::FramelessWindowHint | windowFlags());
    this->setWindowModality(Qt::WindowModal);
    initial();
}

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

void DiagramEditorBayDetailAddDlg::initial()
{
    m_titleBar = new TitleBar(this);
    m_titleBar->setTitle("新增线路");
    ui->gridLayout_2->addWidget(m_titleBar, 0, 0, 1, 2);        //占两列
    _pSizeGrip = new QSizeGrip(this);
    _pSizeGrip->setFixedSize(12, 12);

    _curMode = 0;
    _selectedModel = new QStandardItemModel(this);
    _selectedModel->setHorizontalHeaderLabels({"分类", "名称", "类型", "关联对象", "引用线路"});
    ui->tableView_selected->setModel(_selectedModel);
    connect(ui->btn_add,&QPushButton::clicked,this,&DiagramEditorBayDetailAddDlg::onAddClicked);
    //connect(ui->btn_delete,&QPushButton::clicked,this,&DiagramEditorBayDetailAddDlg::onDeleteClicked);
    connect(ui->btn_save,&QPushButton::clicked,this,&DiagramEditorBayDetailAddDlg::onSaveClicked);
    connect(ui->btn_ok,&QPushButton::clicked,this,&DiagramEditorBayDetailAddDlg::onOkClicked);
    connect(ui->btn_cancel,&QPushButton::clicked,this,&DiagramEditorBayDetailAddDlg::onCancelClicked);
    connect(ui->cb_category,&QComboBox::currentTextChanged,this,&DiagramEditorBayDetailAddDlg::onCategoryChanged);
    connect(ui->tableView_selected, &QTableView::customContextMenuRequested, this, &DiagramEditorBayDetailAddDlg::onRouteRbtnClicked);
    connect(ui->tableView_items, &QTableView::customContextMenuRequested, this, &DiagramEditorBayDetailAddDlg::onComponentRbtnClicked);
    connect(ui->tableView_items, &QTableView::clicked, this, &DiagramEditorBayDetailAddDlg::onComponentSelected);

    QMap<int,modelType> mapType = BaseTypeManager::getInstance()->getMapType();       //直接添加数据库中的基础类型
    for(auto iter = mapType.begin();iter != mapType.end();++iter){
        int index = ui->cb_type->count();
        ui->cb_type->addItem(iter.value().modelName);
        ui->cb_type->setItemData(index,iter->id,Qt::UserRole);      //存放基模id
        ui->cb_type->setItemData(index,iter->graphicElement,Qt::UserRole+1);    //存放基础类型
    }

    ui->cb_category->addItem("电气设备",0);
    ui->cb_category->addItem("连接关系",1);

    ui->tableView_items->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->tableView_items->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableView_items->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableView_items->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    ui->tableView_items->verticalHeader()->setVisible(false);

    ui->tableView_selected->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->tableView_selected->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableView_selected->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableView_selected->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    //ui->tableView_selected->verticalHeader()->setVisible(false);

    ui->cb_lineType->setItemData(0,1);  //设置主线支线
    ui->cb_lineType->setItemData(1,0);
    _bindItemModel = new QStandardItemModel(this);
    ui->cb_bindObj->setModel(_bindItemModel);
}

void DiagramEditorBayDetailAddDlg::loadFromModelRow(int row)
{
    if (!_pParent)
        return;

    auto pModel = _pParent->getComponentModel();
    if (!pModel || row < 0 || row >= pModel->rowCount())
        return;

    // ===== 1. 基础字段 =====
    ui->le_name->setText(pModel->item(row, Col_Name)->text());

    // ===== 2. 分类 cb_category =====
    int cateData = pModel->item(row, Col_Category)->data().toInt();
    setComboBoxByData(ui->cb_category, cateData);

    // ===== 3. 类型 cb_type =====
    int typeData = pModel->item(row, Col_Type)->data().toInt();
    setComboBoxByData(ui->cb_type, typeData);

    // ===== 4. 绑定对象 cb_bindObj =====
    QStandardItem *objItem = pModel->item(row, Col_BindObj);
    if (objItem)
    {
        int bindType = objItem->data(Qt::UserRole + 1).toInt();
        int bindPara = objItem->data(Qt::UserRole + 2).toInt();
        QString bindParent = objItem->data(Qt::UserRole + 3).toString();

        setBindObjComboBox(
            ui->cb_bindObj,
            bindType,
            bindPara,
            bindParent
            );
    }
}

void DiagramEditorBayDetailAddDlg::setComboBoxByData(
    QComboBox *combo,
    int targetData)
{
    for (int i = 0; i < combo->count(); ++i)
    {
        if (combo->itemData(i).toInt() == targetData)
        {
            combo->setCurrentIndex(i);
            return;
        }
    }
    combo->setCurrentIndex(-1);
}

void DiagramEditorBayDetailAddDlg::setBindObjComboBox(
    QComboBox *combo,
    int bindType,
    int bindPara,
    const QString &bindParent)
{
    for (int i = 0; i < combo->count(); ++i)
    {
        int type = combo->itemData(i, Qt::UserRole + 1).toInt();
        int para = combo->itemData(i, Qt::UserRole + 2).toInt();
        QString parent = combo->itemData(i, Qt::UserRole + 3).toString();

        if (type == bindType &&
            para == bindPara &&
            parent == bindParent)
        {
            combo->setCurrentIndex(i);
            return;
        }
    }
    combo->setCurrentIndex(-1);
}

void DiagramEditorBayDetailAddDlg::syncSelectedModel(
    const QString &deviceName)
{
    if (!_pParent || !_selectedModel)
        return;

    auto pMainModel = _pParent->getComponentModel();

    // ===== 1. 找到主表中最新数据 =====
    QStandardItem *mainNameItem = nullptr;
    int mainRow = -1;

    for (int i = 0; i < pMainModel->rowCount(); ++i)
    {
        QStandardItem *item = pMainModel->item(i, Col_Name);
        if (item && item->text() == deviceName)
        {
            mainNameItem = item;
            mainRow = i;
            break;
        }
    }

    if (!mainNameItem)
        return;

    // ===== 2. 同步 _selectedModel 中所有引用该设备的行 =====
    for (int i = 0; i < _selectedModel->rowCount(); ++i)
    {
        QStandardItem *selNameItem = _selectedModel->item(i, Col_Name);
        if (!selNameItem)
            continue;

        if (selNameItem->text() != deviceName)
            continue;

        // ===== 同步字段 =====
        _selectedModel->item(i, Col_Category)
            ->setText(pMainModel->item(mainRow, Col_Category)->text());

        _selectedModel->item(i, Col_Type)
            ->setText(pMainModel->item(mainRow, Col_Type)->text());

        QStandardItem *mainObj = pMainModel->item(mainRow, Col_BindObj);
        QStandardItem *selObj  = _selectedModel->item(i, Col_BindObj);

        selObj->setText(mainObj->text());
        selObj->setData(mainObj->data(Qt::UserRole + 1), Qt::UserRole + 1);
        selObj->setData(mainObj->data(Qt::UserRole + 2), Qt::UserRole + 2);
        selObj->setData(mainObj->data(Qt::UserRole + 3), Qt::UserRole + 3);
    }
}

void DiagramEditorBayDetailAddDlg::updateBindLst()
{
    _bindItemModel->clear();
    QStandardItem* it = new QStandardItem("无");
    _bindItemModel->appendRow(it);
    DiagramEditorBayBlock* pBlock = _pParent->getCurBlock();
    if(pBlock){
        QList<QUuid> lstCon = pBlock->getConnect();
        DiagramEditorWizard* pWizard = _pParent->getWizard();
        if(pWizard){
            QMap<QUuid,DiagramEditorBriefConnect> mapCon = pWizard->getConnection();
            for(auto& uid:lstCon){
                if(mapCon.contains(uid)){
                    auto con = mapCon.value(uid);
                    DiagramEditorConnectType conOp = con.getOpposite(pBlock->getName());
                    if(conOp.nType == 1){       //母线单block单item
                        //ui->cb_bindObj->addItem(conOp.sName,conOp.nType);
                        QStandardItem* item = new QStandardItem(conOp.sName);
                        item->setData(conOp.nType, Qt::UserRole+1); // 设置用户数据
                        _bindItemModel->appendRow(item);
                    }
                    else if(conOp.nType == 3){      //变压器，选择对应进/出线口
                        QStandardItem* item = nullptr;

                        if(con.nPara == 0){
                            item = new QStandardItem("高压线圈接线点");
                        }
                        else if(con.nPara == 1){
                            item = new QStandardItem("中压线圈接线点");
                        }
                        else if(con.nPara == 2){
                            item = new QStandardItem("低压线圈接线点");
                        }
                        if(item){
                            item->setData(conOp.nType, Qt::UserRole+1);
                            item->setData(con.nPara, Qt::UserRole+2);
                            item->setData(conOp.sName, Qt::UserRole+3);
                            _bindItemModel->appendRow(item);
                        }
                    }
                }
            }
        }
    }
    ui->cb_bindObj->setCurrentIndex(0);
}

void DiagramEditorBayDetailAddDlg::showDlg()
{
    if(_pParent){
        _selectedModel->clear();
        _selectedModel->setHorizontalHeaderLabels({"分类", "名称", "类型", "关联对象", "引用线路"});
        show();
        auto pCompo = _pParent->getComponentModel();
        auto pRoute = _pParent->getRouteModel();
        int n = pRoute->rowCount();
        ui->le_routeName->setText("线路"+QString::number(n+1));
        ui->tableView_items->setModel(pCompo);
        //ui->label->setText("新建线路");
        m_titleBar->setTitle("新增线路");
        //ui->le_routeName->setReadOnly(true);
        _curMode = 0;
        updateBindLst();

        int nCount = pRoute->rowCount();
        for(int i = 0;i < nCount;++i){
            QStandardItem *itemRouteName = pRoute->item(i, 0);
            int nMain = itemRouteName->data().toInt();
            if(nMain == 1){     //主线已存在，新路线(本路线)设置为支线
                ui->cb_lineType->setCurrentIndex(1);
            }
        }
    }
}

void DiagramEditorBayDetailAddDlg::showDlg(DiagramEditorRouteInfo info)
{
    if(_pParent){
        auto pCompo = _pParent->getComponentModel();
        auto pRoute = _pParent->getRouteModel();
        ui->tableView_items->setModel(pCompo);
        _selectedModel->clear();
        _selectedModel->setHorizontalHeaderLabels({"分类", "名称", "类型", "关联对象", "引用线路"});
        ui->le_routeName->setText(info.sRouteName);
        for(auto& component:info.lstCompo){

            QStandardItem *itemCate = new QStandardItem();
            QStandardItem *itemName = new QStandardItem();
            QStandardItem *itemType = new QStandardItem();
            QStandardItem *itemObj = new QStandardItem();
            QStandardItem *itemRoute = new QStandardItem();

            QString sCate;
            QString sType;
            if(component.nCategory == 0){
                sCate = "电气设备";
                sType = BaseTypeManager::getInstance()->getNameById(component.nType);       //直接添加数据库中的基础类型
            }
            else if(component.nCategory == 1){
                sCate = "连接关系";
                if(component.nType == 0){       //连接点暂时写死
                    sType = "连接点";
                }
            }
            itemCate->setText(sCate);
            itemName->setText(component.sName);
            itemType->setText(sType);
            itemObj->setText(component.sBindObj);
            itemRoute->setText(component.sUsedRoute.join(","));

            QList<QStandardItem*> lstItems;
            lstItems<<itemCate<<itemName<<itemType<<itemObj<<itemRoute;
            _selectedModel->appendRow(lstItems);
        }
        show();
        m_titleBar->setTitle("编辑线路");
        //ui->label->setText("编辑线路");
        ui->le_routeName->setReadOnly(false);
        _curMode = 1;
        updateBindLst();

        int nCount = pRoute->rowCount();
        for(int i = 0;i < nCount;++i){
            QStandardItem *itemRouteName = pRoute->item(i, 0);
            if(itemRouteName->text() == info.sRouteName){
                int nMain = itemRouteName->data().toInt();
                if(nMain == 1){     //读取并设置是否主线
                    ui->cb_lineType->setCurrentIndex(0);
                }
                else{
                    ui->cb_lineType->setCurrentIndex(1);
                }
            }
        }
    }
}

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

    QSet<int> uniqueRows;
    foreach (const QModelIndex &index, selectedIndexes) {
        uniqueRows.insert(index.row());
    }

    auto pCompoModel = _pParent->getComponentModel();

    foreach (int row, uniqueRows) {
        QStandardItem *sourceItemName = pCompoModel->item(row, 1);      //名称
        int rowCount = _selectedModel->rowCount();
        for(int i = 0;i < rowCount;++i){
            QStandardItem *item = _selectedModel->item(i, 1);
            if(item->text() == sourceItemName->text()){
                QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"线路中设备已存在"));
                return;
            }
        }

        QList<QStandardItem*> newRowItems;
        for (int col = 0; col < pCompoModel->columnCount(); ++col) {
            QStandardItem *sourceItem = pCompoModel->item(row, col);
            if (sourceItem) {
                // 创建深拷贝（重要！）
                if(col == 4){       //线路引用,特殊处理
                    QString strAllRoute = sourceItem->text();
                    QString strCurRoute = ui->le_routeName->text();

                    if(!strAllRoute.contains(strCurRoute)){     //第一个引用不加符号
                        if(strAllRoute.isEmpty())
                            sourceItem->setText(strCurRoute);
                        else
                            sourceItem->setText(strAllRoute+","+strCurRoute);
                    }
                }

                QStandardItem *newItem = sourceItem->clone();
                newRowItems.append(newItem);
            } else {
                // 如果单元格为空，创建空项目
                newRowItems.append(new QStandardItem());
            }
        }
        _selectedModel->appendRow(newRowItems);
    }
}

void DiagramEditorBayDetailAddDlg::onDeleteClicked()
{

}

void DiagramEditorBayDetailAddDlg::onSaveClicked()
{
    // ===== 1. 读取 UI 数据 =====
    const QString sCategory = ui->cb_category->currentText();
    const int nCate = ui->cb_category->currentData().toInt();

    const QString sName = ui->le_name->text();
    if (sName.isEmpty())
        return;

    const QString sType = ui->cb_type->currentText();
    const int nType = ui->cb_type->currentData().toInt();

    const QString sBindObj = ui->cb_bindObj->currentText();
    const int nBindType = ui->cb_bindObj->currentData(Qt::UserRole + 1).toInt();
    const int nBindPara = ui->cb_bindObj->currentData(Qt::UserRole + 2).toInt();
    const QString sBindParent = ui->cb_bindObj->currentData(Qt::UserRole + 3).toString();

    if (!_pParent)
        return;

    auto pModel = _pParent->getComponentModel();
    if (!pModel)
        return;

    // ===== 2. 查找是否已存在同名设备 =====
    for (int row = 0; row < pModel->rowCount(); ++row)
    {
        QStandardItem *nameItem = pModel->item(row, Col_Name);
        if (!nameItem)
            continue;

        if (nameItem->text() != sName)
            continue;

        // ===== 3. 重名确认 =====
        QMessageBox msgBox;
        msgBox.setText(QString::fromWCharArray(L"提示"));
        msgBox.setInformativeText(QString::fromWCharArray(L"设备名已存在，是否覆盖？"));
        msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
        msgBox.setDefaultButton(QMessageBox::Cancel);

        if (msgBox.exec() != QMessageBox::Ok)
            return;

        // ===== 4. 覆盖已有行 =====
        pModel->item(row, Col_Category)->setText(sCategory);
        pModel->item(row, Col_Category)->setData(nCate);

        nameItem->setData(0);   // 初始化方向占用

        pModel->item(row, Col_Type)->setText(sType);
        pModel->item(row, Col_Type)->setData(nType);

        QStandardItem *objItem = pModel->item(row, Col_BindObj);
        objItem->setText(sBindObj);
        objItem->setData(nBindType, Qt::UserRole + 1);
        objItem->setData(nBindPara, Qt::UserRole + 2);
        objItem->setData(sBindParent, Qt::UserRole + 3);

        syncSelectedModel(sName);
        return;
    }

    // ===== 5. 新增行 =====
    QList<QStandardItem*> rowItems;
    rowItems.resize(Col_Count);

    rowItems[Col_Category] = new QStandardItem(sCategory);
    rowItems[Col_Category]->setData(nCate);

    rowItems[Col_Name] = new QStandardItem(sName);
    rowItems[Col_Name]->setData(0);   // 方向占用
    rowItems[Col_Name]->setData(QUuid::createUuid(), Qt::UserRole + 3);

    rowItems[Col_Type] = new QStandardItem(sType);
    rowItems[Col_Type]->setData(nType);

    rowItems[Col_BindObj] = new QStandardItem(sBindObj);
    rowItems[Col_BindObj]->setData(nBindType, Qt::UserRole + 1);
    rowItems[Col_BindObj]->setData(nBindPara, Qt::UserRole + 2);
    rowItems[Col_BindObj]->setData(sBindParent, Qt::UserRole + 3);

    rowItems[Col_Route] = new QStandardItem();

    pModel->appendRow(rowItems);

    const int newRow = pModel->rowCount() - 1;
    QModelIndex index = pModel->index(newRow, 0);

    // 设置当前选中项（焦点）
    ui->tableView_items->setCurrentIndex(index);

    // 滚动到该行
    ui->tableView_items->scrollTo(index, QAbstractItemView::PositionAtCenter);
}

void DiagramEditorBayDetailAddDlg::onOkClicked()
{
    QString sRoute = ui->le_routeName->text();
    auto& mapRoute = _pParent->getBayInfo().mapRoute;
    auto& lstRouteOrder = _pParent->getBayInfo().routeOrder;
    QStringList lstName;        //线路的设备列表
    DiagramEditorRouteInfo       routeInfo;
    routeInfo.sRouteName = sRoute;

    int rowCount = _selectedModel->rowCount();
    for(int i = 0;i < rowCount;++i){
        DiagramEditorComponentInfo compoInfo;
        QStandardItem *itemCategory = _selectedModel->item(i, 0);
        QStandardItem *itemName = _selectedModel->item(i, 1);
        QStandardItem *itemType = _selectedModel->item(i, 2);
        QStandardItem *itemBind = _selectedModel->item(i, 3);
        QStandardItem *itemAllRoute = _selectedModel->item(i, 4);

        QString sCate = itemCategory->text();
        QString sName = itemName->text();
        QString sType = itemType->text();
        QString sBind = itemBind->text();
        int nBindType = itemBind->data(Qt::UserRole + 1).toInt();
        int nBindPara = itemBind->data(Qt::UserRole + 2).toInt();
        QString sBindParent = itemBind->data(Qt::UserRole + 3).toString();
        QString sAllRoute = itemAllRoute->text();
        QUuid uid = itemName->data(Qt::UserRole+3).toUuid();

        int nCate = 0;
        if(sCate == "电气设备")
            nCate = 0;
        else if(sCate == "连接关系")
            nCate = 1;

        int nType = 0;
        nType = itemType->data().toInt();

        compoInfo.nCategory = nCate;
        compoInfo.sName = sName;
        compoInfo.nType = nType;
        compoInfo.sBindObj = sBind;
        compoInfo.nBindType = nBindType;
        compoInfo.nBindPara = nBindPara;
        compoInfo.sBindParent = sBindParent;
        compoInfo.uid = uid;
        compoInfo.sUsedRoute = sAllRoute.split(",");

        routeInfo.lstCompo.append(compoInfo);
        lstName.append(sName);
    }

    QString strCompoNames = lstName.join(",");
    int nMain = ui->cb_lineType->currentData().toInt();     //是否主线
    if(nMain == 1){     //设本线路为主线，重置其他线路主线标志
        auto pRoute = _pParent->getRouteModel();
        int nCount = pRoute->rowCount();
        for(int i = 0;i < rowCount;++i){
            QStandardItem *itemRouteName = pRoute->item(i, 0);
            if(itemRouteName)
                itemRouteName->setData(0);
        }
    }
    routeInfo.bMainRoute = nMain;

    if(_curMode == 0){
        if(mapRoute.contains(sRoute)){
            QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"线路名重复"));
            return;
        }

        lstRouteOrder.append(sRoute);
        if(!routeInfo.bMainRoute){       //非主线才设置父
            QString sParent = _pParent->calculateParent(mapRoute,lstRouteOrder,routeInfo);
            if(!sParent.isEmpty())
                routeInfo.sParentRoute = sParent;
        }

        mapRoute.insert(sRoute,routeInfo);      //插入线路到parent存储中

        QStandardItem *itemRoute = new QStandardItem();
        QStandardItem *itemParent = new QStandardItem();
        QStandardItem *itemNames = new QStandardItem();
        itemRoute->setText(sRoute);
        itemRoute->setData(nMain);
        itemParent->setText(routeInfo.sParentRoute);
        itemNames->setText(strCompoNames);

        QList<QStandardItem*> lstItems;
        lstItems<<itemRoute<<itemParent<<itemNames;

        auto pRoute = _pParent->getRouteModel();
        pRoute->appendRow(lstItems);
    }
    else if(_curMode == 1){
        _pParent->onRouteModified(mapRoute,lstRouteOrder,routeInfo.sRouteName);
        mapRoute[sRoute] = routeInfo;
        auto pRoute = _pParent->getRouteModel();
        int nCount = pRoute->rowCount();
        for(int i = 0;i < rowCount;++i){
            QStandardItem *itemName = pRoute->item(i, 0);
            if(!itemName){
                qDebug() << "name item node found!";
                continue;
            }
            if(itemName->text() == sRoute){
                itemName->setData(nMain);
                QStandardItem *itemRoutes = pRoute->item(i, 2);
                itemRoutes->setText(strCompoNames);
                break;
            }
        }

        for(int i = 0;i < rowCount;++i){        //重新加载所有父路线
            QStandardItem *itemName = pRoute->item(i, 0);
            if(!itemName){
                qDebug() << "name item node found!";
                continue;
            }
            for(auto& route:mapRoute){
                if(itemName->text() == route.sRouteName){
                    QStandardItem *itemParnet = pRoute->item(i, 1);
                    itemParnet->setText(route.sParentRoute);
                    continue;
                }
            }
        }
    }
    if(_pParent){
        _pParent->showPreview();
    }
    hide();
}

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

void DiagramEditorBayDetailAddDlg::onCategoryChanged(const QString& str)
{
    ui->cb_type->clear();
    if(str == "电气设备"){
        QMap<int,modelType> mapType = BaseTypeManager::getInstance()->getMapType();       //直接添加数据库中的基础类型
        for(auto iter = mapType.begin();iter != mapType.end();++iter){
            int index = ui->cb_type->count();
            ui->cb_type->addItem(iter.value().modelName);
            ui->cb_type->setItemData(index,iter->id,Qt::UserRole);      //存放基模id
            ui->cb_type->setItemData(index,iter->graphicElement,Qt::UserRole+1);    //存放基础类型
        }
    }
    else if(str == "连接关系"){
        ui->cb_type->addItem("连接点",0);      //连接点暂时写死为0
    }
}

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

    // 获取行号并排序（从大到小删除避免索引变化）
    QList<int> rowsToRemove;
    foreach (const QModelIndex &index, selectedIndexes) {
        rowsToRemove.append(index.row());
    }

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

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

    bool bUsed = false;
    auto& mapRoute = _pParent->getBayInfo().mapRoute;       //检索所有路线，判断设备占用情况
    for(auto& route:mapRoute){
        QString sRoute = route.sRouteName;
        for(auto& compo:route.lstCompo){
            if(compo.sName == sName){
                bUsed = true;
                break;
            }
        }
    }

    auto pCompoModel = _pParent->getComponentModel();
    if(bUsed){
        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:     //同步删除所有占用对象
        {
            for(auto& route:mapRoute){
                QString sRoute = route.sRouteName;
                for(int i = 0;i < route.lstCompo.size();++i){
                    QString sCompo = route.lstCompo[i].sName;
                    if(sCompo == sName){
                        route.lstCompo.removeAt(i);
                    }
                }
            }

            //todo:刷新主界面

            foreach (int row, rowsToRemove) {
                QList<QStandardItem*> rowItems;
                for (int col = 0; col < pCompoModel->columnCount(); ++col) {
                    QStandardItem *item = pCompoModel->takeItem(row, col);
                    rowItems.append(item);
                }
                qDeleteAll(rowItems);       //take的item不释放
                pCompoModel->removeRow(row);
            }
        }
        break;
        case QMessageBox::Cancel:
            // Cancel was clicked
            break;
        default:
            // should never be reached
            break;
        }
    }
    else{
        // 移除行
        foreach (int row, rowsToRemove) {
            QList<QStandardItem*> rowItems;
            for (int col = 0; col < pCompoModel->columnCount(); ++col) {
                QStandardItem *item = pCompoModel->takeItem(row, col);
                rowItems.append(item);
            }
            qDeleteAll(rowItems);       //take的item不释放
            pCompoModel->removeRow(row);
        }
    }
}

void DiagramEditorBayDetailAddDlg::onComponentRbtnClicked(const QPoint &pos)
{
    QModelIndex index = ui->tableView_items->indexAt(pos);
    if (!index.isValid()) {
        return; // 如果点击的是空白区域，直接返回
    }

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

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

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

void DiagramEditorBayDetailAddDlg::onComponentSelected(const QModelIndex &index)
{
    int row = index.row();
    loadFromModelRow(row);
}

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

    // 获取行号并排序（从大到小删除避免索引变化）
    QList<int> rowsToRemove;
    foreach (const QModelIndex &index, selectedIndexes) {
        rowsToRemove.append(index.row());
    }

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

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

    // 移除行
    foreach (int row, rowsToRemove) {
        QList<QStandardItem*> rowItems;
        for (int col = 0; col < _selectedModel->columnCount(); ++col) {
            QStandardItem *item = _selectedModel->takeItem(row, col);
            rowItems.append(item);
        }
        qDeleteAll(rowItems);       //take的item不释放
        _selectedModel->removeRow(row);
    }

    QString sRoute = ui->le_routeName->text();
    auto pCompoModel = _pParent->getComponentModel();
    int rowCount = pCompoModel->rowCount();         //移除设备库占用记录
    for(int i = 0;i < rowCount;++i){
        QStandardItem *itemName = pCompoModel->item(i, 1);
        if(itemName->text() == sName){
            QStandardItem *itemUsed = pCompoModel->item(i, 4);
            QString sUsed = itemUsed->text();
            QStringList lst = sUsed.split(",");
            lst.removeAll(sRoute);
            itemUsed->setText(lst.join(","));
        }
    }
}

void DiagramEditorBayDetailAddDlg::onRouteRbtnClicked(const QPoint &pos)
{
    QModelIndex index = ui->tableView_selected->indexAt(pos);
    if (!index.isValid()) {
        return; // 如果点击的是空白区域，直接返回
    }

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

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

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

void DiagramEditorBayDetailAddDlg::resizeEvent(QResizeEvent *) {
    _pSizeGrip->move(width() - _pSizeGrip->width(),
                     height() - _pSizeGrip->height());
}