#include "monitorItemsDlg.h"
#include "ui_monitorItemsDlg.h"
#include "dataBase.h"
#include "tools.h"
#include <QToolTip>


MonitorItemsDlg::MonitorItemsDlg(QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::monitorItemsDlg)
    ,_modelAll(nullptr)
    ,_modelSelect(nullptr)
{
    ui->setupUi(this);
    initial();
}

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

void MonitorItemsDlg::initial()
{
    _modelAll = new QStandardItemModel(this);
    ui->treeView_all->setModel(_modelAll);
    ui->treeView_all->setHeaderHidden(true);
    _modelSelect = new QStandardItemModel(this);
    ui->treeView_select->setModel(_modelSelect);
    ui->treeView_select->setHeaderHidden(true);
    ui->le_name->setPlaceholderText("输入名称");
    connect(ui->btn_generate,&QPushButton::clicked,this,&MonitorItemsDlg::onGenerateClicked);
    connect(_modelAll, &QStandardItemModel::itemChanged,this, &MonitorItemsDlg::onItemChanged);
}

void MonitorItemsDlg::onUpdateItems(QList<RelationItem> lst,bool refresh)
{
    if(refresh){
        QStandardItem *root = _modelAll->invisibleRootItem();
        int rowCount = root->rowCount();
        if (rowCount > 0) {
            _modelAll->removeRows(0, rowCount);
        }
        // 清空间隔节点缓存
        m_mapBayItems.clear();
    }

    // 先处理间隔节点（nCategory == 1）
    for(auto &info:lst){
        auto curItem = info.item;
        if(curItem.nCategory == 1){  // 间隔信息
            // 查找是否已存在该间隔节点
            QStandardItem* pBayItem = findBayItem(curItem.sName);
            if(!pBayItem){
                // 创建间隔节点
                pBayItem = new QStandardItem(curItem.sName);
                pBayItem->setCheckable(true);        // 启用勾选框
                pBayItem->setCheckState(Qt::Unchecked);
                pBayItem->setData(curItem.nCategory, Qt::UserRole+1);     // 存储类别
                pBayItem->setData(curItem.nEquipType, Qt::UserRole+2);    // 存储设备类型
                pBayItem->setData(curItem.uid, Qt::UserRole+3);           // 存储UUID

                // 存储到缓存中
                m_mapBayItems[curItem.sName] = pBayItem;
                _modelAll->appendRow(pBayItem);
            }
        }
    }

    // 再处理设备节点（nCategory == 0）
    for(auto &info:lst){
        auto curItem = info.item;
        if(curItem.nCategory == 0){  // 设备信息
            // 获取设备所属的间隔名称
            QString bayName = info.parent.sName;

            if(!bayName.isEmpty()){
                // 查找对应的间隔节点
                QStandardItem* pBayItem = findBayItem(bayName);

                if(pBayItem){
                    // 创建设备节点
                    QStandardItem *pItem = new QStandardItem(curItem.sName);
                    pItem->setCheckable(true);        // 启用勾选框
                    pItem->setCheckState(Qt::Unchecked);
                    pItem->setData(curItem.nCategory, Qt::UserRole+1);
                    pItem->setData(curItem.nEquipType, Qt::UserRole+2);
                    pItem->setData(curItem.uid, Qt::UserRole+3);

                    // 不再为母线或独立设备添加子设备
                    // 所有设备都作为间隔的直接子节点

                    pBayItem->appendRow(pItem);
                }
            }
        }
    }

    // 展开所有节点
    ui->treeView_all->expandAll();
}

void MonitorItemsDlg::onSelectItems(QList<RelationItem> lst)
{
    ui->stackedWidget->setCurrentIndex(0);
    resetSelect();
    for(auto& info:lst){
        QModelIndex itemIndex = findIndex(_modelAll,info.item.uid,Qt::UserRole+3);
        if(itemIndex.isValid())
        {
            QStandardItem *pItem = _modelAll->itemFromIndex(itemIndex);
            pItem->setCheckState(Qt::Checked);
        }
    }

}

void MonitorItemsDlg::onGenerateClicked()
{
    QString sName = ui->le_name->text();
    if (sName.isEmpty()) {
        ui->le_name->setFocus();
        return;
    }
    QList<RelationItem> lst;
    QList<QStandardItem*> lstItem = getTreeViewCheckedItems(ui->treeView_all);
    for(auto& pItem:lstItem){
        RelationItem info;
        auto pParent = pItem->parent();
        if(pParent){
            info.parent.nCategory = pParent->data(Qt::UserRole+1).toInt();
            info.parent.nEquipType = pParent->data(Qt::UserRole+2).toInt();
            info.parent.uid = pParent->data(Qt::UserRole+3).toUuid();
            info.parent.sName = pParent->text();
        }
        info.item.nCategory = pItem->data(Qt::UserRole+1).toInt();
        info.item.nEquipType = pItem->data(Qt::UserRole+2).toInt();
        info.item.uid = pItem->data(Qt::UserRole+3).toUuid();
        info.item.sName = pItem->text();

        auto lstChild = getAllChildren(pItem);
        for(auto &child:lstChild){
            RelationSturctItem stru;
            stru.nCategory = child->data(Qt::UserRole+1).toInt();
            stru.nEquipType = child->data(Qt::UserRole+2).toInt();
            stru.uid = child->data(Qt::UserRole+3).toUuid();
            stru.sName = child->text();
            info.subList.append(stru);
        }
        lst.append(info);
    }

    emit generateMonitor(sName,lst);
}

void MonitorItemsDlg::onMonitorCreated(QList<RelationItem> lst)
{
    /*ui->stackedWidget->setCurrentIndex(1);
    ui->listWidget_select->clear();

    for(auto& pair:lst){
        QListWidgetItem *item = new QListWidgetItem(pair.first);
        item->setData(Qt::UserRole,pair.second);
        ui->listWidget_select->addItem(item);
    }*/
}

void MonitorItemsDlg::onItemChanged(QStandardItem *item)
{
    QSignalBlocker blocker(_modelAll);

    if (item->isCheckable()) {
        Qt::CheckState newState = item->checkState();
        // 设置所有子项与父项相同的状态
        setChildrenCheckState(item, newState);
    }

    ui->treeView_all->repaint();
}

void MonitorItemsDlg::setChildrenCheckState(QStandardItem *parent, Qt::CheckState state) {
    for (int row = 0; row < parent->rowCount(); ++row) {
        QStandardItem *child = parent->child(row, 0); // 第一列
        if (child && child->isCheckable()) {
            child->setCheckState(state);
            setChildrenCheckState(child, state);
        }
    }
}

void MonitorItemsDlg::traverseSelectStandardItemModel(QStandardItemModel *model,Qt::CheckState check) {
    if (!model) return;

    // 遍历所有顶层项
    for (int row = 0; row < model->rowCount(); ++row) {
        for (int col = 0; col < model->columnCount(); ++col) {
            QStandardItem *item = model->item(row, col);
            item->setCheckState(check);
            traverseSelectStandardItem(item, 0,check);
        }
    }
}

void MonitorItemsDlg::traverseSelectStandardItem(QStandardItem *item, int depth,Qt::CheckState check) {
    if (!item) return;

    // 遍历子项
    for (int row = 0; row < item->rowCount(); ++row) {
        for (int col = 0; col < item->columnCount(); ++col) {
            QStandardItem *child = item->child(row, col);
            child->setCheckState(check);
            traverseSelectStandardItem(child, depth + 1,check);
        }
    }
}

QStandardItem* MonitorItemsDlg::findBayItem(const QString& bayName)
{
    // 先从缓存查找
    if(m_mapBayItems.contains(bayName)){
        return m_mapBayItems[bayName];
    }

    // 遍历查找
    for(int i = 0; i < _modelAll->rowCount(); ++i){
        QStandardItem* pItem = _modelAll->item(i);
        if(pItem->text() == bayName &&
            pItem->data(Qt::UserRole+1).toInt() == 1){  // 类别为间隔
            return pItem;
        }
    }
    return nullptr;
}

QList<QStandardItem*> MonitorItemsDlg::getCheckedItems(QStandardItem* parentItem) {
    QList<QStandardItem*> checkedItems;

    if (!parentItem) return checkedItems;

    for (int i = 0; i < parentItem->rowCount(); ++i) {
        QStandardItem* childItem = parentItem->child(i);

        if (childItem->checkState() == Qt::Checked) {
            checkedItems.append(childItem);
        }

        // 递归检查子项
        checkedItems.append(getCheckedItems(childItem));
    }

    return checkedItems;
}

// 主函数：获取treeView中所有checked项
QList<QStandardItem*> MonitorItemsDlg::getTreeViewCheckedItems(QTreeView* treeView) {
    QList<QStandardItem*> checkedItems;

    QStandardItemModel* model = qobject_cast<QStandardItemModel*>(treeView->model());
    if (!model) return checkedItems;

    QStandardItem* rootItem = model->invisibleRootItem();
    return getCheckedItems(rootItem);
}

void MonitorItemsDlg::resetSelect()
{
    traverseSelectStandardItemModel(_modelAll,Qt::Unchecked);
}