#include <QMdiSubWindow>
#include <QMessageBox>
#include <QJsonObject>
#include <QStandardItem>
#include <QLibrary>
#include <QMetaMethod>
#include "drawingPanel.h"
#include "monitorPanel.h"
#include "diagramCavas.h"
#include "dataBase.h"
#include "graphicsItem/graphicsBaseItem.h"
#include "topologyManager.h"
#include "powerEntity.h"
#include "projectModelManager.h"
#include "baseProperty.h"
#include "diagramEditor/editPanel.h"
#include "graphicsDataModel/diagramEditorModel.h"
#include "basePropertyManager.h"
#include "cornerMonitorLauncher.h"
#include "loadMonitorPageDlg.h"

DiagramCavas::DiagramCavas(QWidget *parent)
    : QMdiArea(parent)
    ,_cornerButton(nullptr)
    ,_loadMonitorPageDlg(nullptr)
{
    _pageIndex = 0;
}

DiagramCavas::~DiagramCavas()
{

}

DrawingPanel* DiagramCavas::getPanel(QString sPage)
{
    if(m_mapDrawPanel.contains(sPage))
        return m_mapDrawPanel[sPage].first;
    return nullptr;
}

EditPanel* DiagramCavas::getEditPanel(QString sPage)
{
    if(m_mapEditPanel.contains(sPage))
        return m_mapEditPanel[sPage].first;
    return nullptr;
}

MonitorPanel* DiagramCavas::getMonitorPanel(QString sPage)
{
    if(m_mapMonitorPanel.contains(sPage))
        return m_mapMonitorPanel[sPage].first;
    return nullptr;
}

void DiagramCavas::updateSubPos()
{
    if(_cornerButton)
        _cornerButton->positionAtCorner();
}

void DiagramCavas::initial()
{
    //todo:读取数据并初始化
    QList<pageInfo> lst = DataBase::GetInstance()->getAllPage();
    for(auto &info:lst)
    {
        TopologyManager::instance().createDiagram(QString::number(info.id),info.name);
    }
    _cornerButton = new CornerMonitorLauncher(this);
    _cornerButton->showDlg();
    _loadMonitorPageDlg = new LoadMonitorPageDlg(this);
    connect(_cornerButton,&CornerMonitorLauncher::openLoadMonitorDlg,this,[&](){
        if(_loadMonitorPageDlg){
            updateMonitorListFromDB(1);
            _loadMonitorPageDlg->show();
        }
    });
    connect(_loadMonitorPageDlg,&LoadMonitorPageDlg::monitorSelected,this,&DiagramCavas::onSignal_monitorSelected);
}

void DiagramCavas::onSignal_addDrawingPanel(PowerEntity* pItem,DiagramMode mode,QString parent)
{
    if(mode == DM_baseModel || mode == DM_edit){
        DrawingPanel*  pPanel = new DrawingPanel(pItem,this,mode);
        _curPage = pItem->name();
        pPanel->setPageName(_curPage);
        pPanel->setWindowTitle(_curPage);
        QMdiSubWindow* pSub = this->addSubWindow(pPanel);
        m_mapDrawPanel.insert(_curPage,qMakePair(pPanel,pSub));
        pPanel->show();

        FixedPortsModel* pModel = pPanel->getModelController();
        pModel->setCavas(this);
        connect(pModel,&FixedPortsModel::activatePage,this,&DiagramCavas::onSignal_activatePage);
        connect(pModel,&FixedPortsModel::updateCurrentItems,this,&DiagramCavas::onSignal_updateCurItems);
        connect(pModel,&FixedPortsModel::itemSelected,this,&DiagramCavas::onSignal_selectedItems);
        connect(pPanel,&DrawingPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete);
    }
    else if(mode == DM_run){
        MonitorPanel* pPanel = new MonitorPanel(pItem,this,mode);
        _curPage = pItem->name();
        pPanel->setPageName(_curPage);
        pPanel->setWindowTitle(_curPage);
        pPanel->setParentPage(parent);
        QMdiSubWindow* pSub = this->addSubWindow(pPanel);
        m_mapMonitorPanel.insert(_curPage,qMakePair(pPanel,pSub));
        pPanel->show();

        FixedPortsModel* pModel = pPanel->getModelController();
        pModel->setCavas(this);
        connect(pModel,&FixedPortsModel::activatePage,this,&DiagramCavas::onSignal_activatePage);
        connect(pPanel,&MonitorPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete);
        connect(pModel,&FixedPortsModel::monitorCreated,this,&DiagramCavas::onSignal_monitorCreated);
        connect(pModel,&FixedPortsModel::monitorItems,this,&DiagramCavas::onSignal_monitorItemCreated);
    }
    calculateLauncherVisible();
}

void DiagramCavas::onSignal_addGraphicsItem(modelStateInfo& info)
{
    QMdiSubWindow* actWindow = activeSubWindow();
    if(!actWindow)
        return;
    QWidget* pWindow= currentSubWindow()->widget();
    DrawingPanel* pPanel = dynamic_cast<DrawingPanel*>(pWindow);

    if(pPanel)
        pPanel->onSignal_addGraphicsItem(info);
}

void DiagramCavas::onSignal_addPage()
{
    //onSignal_addDrawingPanel(QString("Page_")+QString::number(++_pageIndex));
}

void DiagramCavas::onSignal_savePage()
{
    QWidget* pWindow= currentSubWindow()->widget();
    BaseDrawingPanel* pPanel = dynamic_cast<BaseDrawingPanel*>(pWindow);
    if(pPanel)
    {
        if(pPanel->getMode() == DM_run)
        {
            auto pMonitor = dynamic_cast<MonitorPanel*>(pPanel);
            if(pMonitor){
                if(DataBase::GetInstance()->getPageIdByName(pMonitor->getParentPage()) == -1){
                    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先保存工程模型"));
                    return;
                }
                auto pEntity = pMonitor->getEntity();
                if(pEntity){
                    if(DataBase::GetInstance()->getMonitorIdByName(pEntity->name()).isNull())        //不存在，创建
                        DataBase::GetInstance()->insertMonitor(QUuid(pEntity->id()),pEntity->name(),pEntity->name(),pMonitor->getParentPage(),pMonitor->getMonitorInfo());
                    else
                        DataBase::GetInstance()->updateMonitor(pEntity->name(),pMonitor->getMonitorInfo());
                    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"保存成功"));
                }

            }
        }
        else if(pPanel->getMode() == DM_edit)
        {
            auto pDrawPanel = dynamic_cast<MonitorPanel*>(pPanel);
            _curPage = pPanel->pageName();
            QMessageBox msgBox;
            msgBox.setText(QString::fromWCharArray(L"提示"));
            msgBox.setInformativeText(QString::fromWCharArray(L"内容已修改,是否保存?"));
            msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Cancel);
            msgBox.setDefaultButton(QMessageBox::Save);
            int ret = msgBox.exec();

            switch (ret) {
            case QMessageBox::Save:                 //todo:已存在更新
            {
                QMap<QUuid,GraphicsProjectModelItem*> map = pPanel->getModelController()->allItems();
                QList<QString>      updatedModel;       //更新过图标的模型
                for(auto pItem:map)
                {
                    BaseProperty* pData = dynamic_cast<BaseProperty*>(pItem->getProperty());
                    if(pData){
                        QString sMeta = pData->metaModelName();
                        QString sModel = pData->modelName();
                        if(!updatedModel.contains(sModel)){
                            ProjectModelManager::instance().updateSetting(sMeta,sModel,true);       //更新使用的图标数据
                            updatedModel.append(sModel);
                        }

                        if(pItem->itemChanged() || pData->dataChanged())
                        {
                            pItem->updateConnectData();     //更新连接状态
                            pItem->setItemChanged(false);
                        }
                    }
                }

                if(DataBase::GetInstance()->getPageIdByName(_curPage) == -1)        //不存在，创建
                    DataBase::GetInstance()->insertPage(_curPage,_curPage,QJsonObject(),pPanel->getDiagramInfo(),QString("page"),1);
                else
                    DataBase::GetInstance()->updatePage(_curPage,_curPage,pPanel->getDiagramInfo());
                int pageId = DataBase::GetInstance()->getPageIdByName(_curPage);
                pPanel->saveNodes(pageId);

            }
            break;
            case QMessageBox::Cancel:
                // Cancel was clicked
                break;
            default:
                // should never be reached
                break;
            }
        }
    }
}

void DiagramCavas::onSignal_loadPage(PowerEntity* p)
{
    if(!m_mapDrawPanel.contains(p->name()))
    {
        onSignal_addDrawingPanel(p);
        QJsonObject context = DataBase::GetInstance()->getPageContextByName(p->name());
        m_mapDrawPanel[p->name()].first->loadNodes(context);
    }
    else        //已存在
    {
        m_mapDrawPanel[p->name()].first->show();
    }
}

void DiagramCavas::onSignal_loadEdit(const QString& sProject,QUuid uid)
{
    if(!m_mapEditPanel.contains(sProject))
    {
        //todo:加载数据
        onSignal_addEditWizard(sProject,uid,false);
        m_mapEditPanel[sProject].first->loadBaseSetting(uid);
    }
    else        //已存在
    {
        //todo:新建或加载时删除old
        m_mapEditPanel[sProject].first->show();
    }
}

void DiagramCavas::onSignal_loadMonitor(PowerEntity* p,QString sParent)
{
    if(!m_mapMonitorPanel.contains(p->name()))
    {
        onSignal_addDrawingPanel(p,DiagramMode::DM_run,sParent);
        QJsonObject context = DataBase::GetInstance()->getMonitorContextByTag(p->name());
        m_mapMonitorPanel[p->name()].first->loadNodes(context);
    }
    else        //已存在
    {
        m_mapMonitorPanel[p->name()].first->show();
    }
}

void DiagramCavas::runPage(const QString sName)
{
    QString pageName = sName+QString("_run");
    if(!m_mapDrawPanel.contains(pageName))
    {
        //onSignal_addDrawingPanel(pageName,DM_run);
        QJsonObject context = DataBase::GetInstance()->getPageContextByName(sName);
        //m_mapDrawPanel[pageName]->loadNodes(context);
    }
    else        //已存在
    {
        //m_mapDrawPanel[pageName]->show();
    }
}

void DiagramCavas::onSignal_runPage()
{
    runPage(_curPage);
}

void DiagramCavas::onSignal_deletePage()
{

}

void DiagramCavas::onSignal_activatePage(const QString& name)
{
    _curPage = name;
}

void DiagramCavas::onSignal_panelDelete(const QString& name,int nType)
{
    if(nType == 0){
        EditPanel* pPanel = m_mapEditPanel.take(name).first;
        BasePropertyManager::instance().clearEditorData();          //关闭前清空当前单例     todo:测试其他单例
        this->removeSubWindow(pPanel);
        delete pPanel;
    }
    else if(nType == 1){
        DrawingPanel* pPanel = m_mapDrawPanel.take(name).first;
        this->removeSubWindow(pPanel);
        delete pPanel;
    }
    else if(nType == 2){
        MonitorPanel* pPanel = m_mapMonitorPanel.take(name).first;
        this->removeSubWindow(pPanel);
        delete pPanel;
    }
    calculateLauncherVisible();
}

void DiagramCavas::onSignal_createEntity(EntityInfo info)
{
    PowerEntity* pEntity;
    pEntity = TopologyManager::instance().findEntity(info.sUuid);
    if(!pEntity)        //不存在创建
    {
        pEntity = TopologyManager::instance().createEntity(info.eType,info.sUuid,info.sName);
        PowerEntity* pParent = TopologyManager::instance().findEntity(info.sParentId);
        if(pParent)         //构建父子关系
        {
            pParent->addChild(pEntity);
        }

        switch (info.eType){
        case EntityType::Grid:
        case EntityType::Zone:
        case EntityType::Station:
            break;
        case EntityType::ConfigurationDiagram:
            onSignal_addDrawingPanel(pEntity);
            break;
        default:
            break;
        }
    }

}

void DiagramCavas::onSignal_changeEntity(EntityInfo info)
{

}

void DiagramCavas::onSignal_deleteEntity(EntityInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findEntity(info.sUuid);
    if(pEntity)
    {
        switch (info.eType){
        case EntityType::Grid:
        case EntityType::Zone:
        case EntityType::Station:
            TopologyManager::instance().deleteEntity(info.sUuid);
            break;
        case EntityType::ConfigurationDiagram:
            removePanel(pEntity);
            TopologyManager::instance().deleteEntity(info.sUuid);
            break;
        default:
            break;
        }
    }
}

void DiagramCavas::onSignal_selectEntity(EntityInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findEntity(info.sUuid);
    if(pEntity)
    {
        switch (info.eType){
        case EntityType::Grid:
        case EntityType::Zone:
        case EntityType::Station:
            break;
        default:
            break;
        }
    }
    else            //不存在,从数据库中load
    {

    }
}

void DiagramCavas::onSignal_createDiagram(DiagramInfo info,DiagramMode mode)
{
    PowerEntity* pEntity;
    ModelFunctionType type;
    if(mode == DM_run)
        type = ModelFunctionType::RuntimeModel;
    else if(mode == DM_edit)
        type = ModelFunctionType::ProjectModel;
    pEntity = TopologyManager::instance().findDiagram(info.id.toString(),type);
    if(!pEntity)        //不存在创建
    {
        pEntity = TopologyManager::instance().createDiagram(info.id.toString(),info.sName,type);
        /*PowerEntity* pParent = TopologyManager::instance().findDiagram(info.parentId.toString());
        if(pParent)         //构建父子关系
        {
            pParent->addChild(pEntity);
        }*/

        onSignal_addDrawingPanel(pEntity,mode);
    }
}

void DiagramCavas::onSignal_changeDiagram(DiagramInfo info)
{

}

void DiagramCavas::onSignal_deleteDiagram(DiagramInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findDiagram(info.id.toString());
    if(pEntity)
    {
        removePanel(pEntity);
        TopologyManager::instance().deleteEntity(info.id.toString());
    }
}

void DiagramCavas::onSignal_selectDiagram(DiagramInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findDiagram(QString::number(info.id.toInt()));
    if(pEntity)
    {
        onSignal_loadPage(pEntity);
    }
    else            //不存在,从数据库中load
    {

    }
}

void DiagramCavas::removePanel(PowerEntity* pEntity)
{
    QMap<QString,QPair<DrawingPanel*,QMdiSubWindow*>>::Iterator iter;
    for(iter = m_mapDrawPanel.begin(); iter != m_mapDrawPanel.end();++iter)
    {
        if(pEntity->name() == iter.value().first->pageName())
        {
            DrawingPanel* pPanel = m_mapDrawPanel.take(iter.key()).first;

            QWidget* pWindow = static_cast<QWidget*>(pPanel);
            setActiveSubWindow(iter->second);
            closeActiveSubWindow();
            //removeSubWindow(pPanel);
            //todo：记录删除组态图，从数据库中删除
            delete pPanel;
            break;
        }
    }
}

void DiagramCavas::calculateLauncherVisible()
{
    if(_cornerButton){
        if (m_mapDrawPanel.isEmpty() && m_mapEditPanel.isEmpty() && m_mapMonitorPanel.isEmpty()) {
            _cornerButton->setVisible(true);
        } else {
            _cornerButton->setVisible(false);
        }
    }
}

void DiagramCavas::onCreateTestBaseModelDiagram()
{
    PowerEntity* pEntity;
    QUuid id = QUuid::createUuid();
    pEntity = TopologyManager::instance().findDiagram(id.toString());
    if(!pEntity)        //不存在创建
    {
        pEntity = TopologyManager::instance().createDiagram(id.toString(),"测试1");

        onSignal_addDrawingPanel(pEntity,DM_baseModel);
        DrawingPanel* pPanel = getPanel(pEntity->name());
        pPanel->getModelController()->addTestData();
    }
}

void DiagramCavas::resizeEvent(QResizeEvent* event)
{
    if(_cornerButton)
        _cornerButton->positionAtCorner();
}

/*******************************************************/

void DiagramCavas::onSignal_createEditPanel(QString sName,QUuid uid)
{
    onSignal_addEditWizard(sName,uid);
}

void DiagramCavas::onSignal_prepareOpenSetting(QString sProject)
{
    EditPanel* pPanel = getEditPanel(sProject);
    if(pPanel){
        pPanel->showWizard();
    }
}

void DiagramCavas::onSignal_prepareSaveEdit(QString sProject)
{
    QString sName = sProject;
    if(sProject == "currentPage"){
        sName = _curPage;
    }
    EditPanel* pPanel = getEditPanel(sName);
    if(pPanel){
        pPanel->prepareSaveEditor();
    }
}

void DiagramCavas::onSignal_prepareDeleteEditor(const QString& sProject,QUuid uid)
{
    EditPanel* pPanel = getEditPanel(sProject);
    if(pPanel){
        pPanel->close();
    }
}

EditPanel* DiagramCavas::onSignal_addEditPanel(QString sName)
{
    EditPanel*  pPanel = new EditPanel(this);
    pPanel->setProjectName(sName);
    pPanel->setTag(sName);
    _curPage = sName;
    pPanel->setWindowTitle(_curPage);
    pPanel->setCavas(this);
    connect(pPanel,&EditPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete);

    QMdiSubWindow* pSub = this->addSubWindow(pPanel);
    m_mapEditPanel.insert(_curPage,qMakePair(pPanel,pSub));
    pPanel->show();
    return pPanel;
}

void DiagramCavas::onSignal_addEditWizard(QString name,QUuid uid,bool val)
{
    EditPanel* pPanel = onSignal_addEditPanel(name);
    pPanel->setUuid(uid);
    if(val)
        pPanel->showWizard();
}

void DiagramCavas::onSignal_wizardFinished(QString sName,QMap<QUuid,GraphicsBaseModelItem*> mapItem,QList<EditBaseItem*> mapBlock)
{
    PowerEntity* pEntity;
    QUuid id = QUuid::createUuid();
    pEntity = TopologyManager::instance().findDiagram(id.toString());
    if(!pEntity)        //不存在创建
    {
        pEntity = TopologyManager::instance().createDiagram(id.toString(),sName);

        onSignal_addDrawingPanel(pEntity,DM_baseModel);
        DrawingPanel* pPanel = getPanel(pEntity->name());
        TopologyManager::instance().cloneEditorToBase();        //拷贝拓扑结构
        auto pModel = pPanel->getModelController();
        if(pModel){
            pModel->onWizardFinished(mapItem,mapBlock);
        }
    }
}

void DiagramCavas::onSignal_unloadProject(const QString& sName)
{
    BasePropertyManager::instance().clearEditorData();

    for(auto &pair:m_mapEditPanel){
        EditPanel* pPanel = pair.first;
        this->removeSubWindow(pPanel);
        delete pPanel;
    }
    m_mapEditPanel.clear();
}
/*******************bay************************/
void DiagramCavas::onSignl_openCurrentBay()
{
    QWidget* pWindow= currentSubWindow()->widget();
    if(pWindow == nullptr){
        QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"当前无打开的工程模"));
    }
    DrawingPanel* pPanel = dynamic_cast<DrawingPanel*>(pWindow);
    if(pPanel)
    {
        if(pPanel->getMode() == DM_run)
        {

        }
        else if(pPanel->getMode() == DM_edit)
        {
            pPanel->getModelController()->onSignal_openBayManager();
        }
        else if(pPanel->getMode() == DM_baseModel)
        {

        }
    }
}
/*********************monitor**************************/
void DiagramCavas::onSignal_updateCurItems(QList<monitorRelationItem> lst,bool refresh)
{
    emit prepareUpdateItems(lst,refresh);
}

void DiagramCavas::onSignal_selectedItems(QList<monitorRelationItem> lst)
{
    emit prepareSelectItems(lst);
}

void DiagramCavas::onSignal_generate(QString sPage,QList<monitorRelationItem> lst)
{
    QWidget* pWindow= currentSubWindow()->widget();
    DrawingPanel* pPanel = dynamic_cast<DrawingPanel*>(pWindow);
    if(pPanel){
        pPanel->getModelController()->generateMonitor(sPage,lst);
    }
}

void DiagramCavas::onSignal_monitorCreated(QString sProj,QPair<QString,QUuid> pair)
{
    emit updateMonitorList(sProj,pair);
}

void DiagramCavas::onSignal_monitorItemCreated(QList<monitorRelationItem> lst)
{
    emit createdMonitorItems(lst);
}

void DiagramCavas::onSignal_monitorSelected(DiagramInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findDiagram(info.id.toString(),ModelFunctionType::RuntimeModel);
    if(pEntity)
    {
        onSignal_loadMonitor(pEntity,info.sBasePageName);
    }
}

void DiagramCavas::onSignal_saveMonitor(QList<QPair<QString,QUuid>> lst)
{
    for(auto &pair:lst){
        auto pMonitor = m_mapMonitorPanel.value(pair.first).first;
        if(pMonitor){
            if(DataBase::GetInstance()->getPageIdByName(pMonitor->getParentPage()) == -1){
                QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先保存工程模型"));
                return;
            }
        }
    }

    for(auto& pair:lst){
        auto pMonitor = m_mapMonitorPanel.value(pair.first).first;
        if(pMonitor){
            if(DataBase::GetInstance()->getMonitorIdByName(pair.first).isNull())        //不存在，创建
                DataBase::GetInstance()->insertMonitor(pair.second,pair.first,pair.first,pMonitor->getParentPage(),pMonitor->getMonitorInfo());
            else
                DataBase::GetInstance()->updateMonitor(pair.first,pMonitor->getMonitorInfo());
        }
    }
    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"保存成功"));
}

void DiagramCavas::updateMonitorListFromDB(int dest)
{
    if(dest != 0)
        _loadMonitorPageDlg->clearItems();

    QList<monitorPageInfo> lstMonitor = DataBase::GetInstance()->getAllMonitor();
    for(auto &info:lstMonitor)
    {
        auto p = TopologyManager::instance().findDiagram(info.uid.toString(),ModelFunctionType::RuntimeModel);
        if(!p){
            TopologyManager::instance().createDiagram(info.uid.toString(),info.name,ModelFunctionType::RuntimeModel);
            if(dest == 0)
                emit updateMonitorList(info.parent,qMakePair(info.name,info.uid));
            else{
                _loadMonitorPageDlg->updateItems(info.parent,qMakePair(info.name,info.uid));
            }
        }
        else{       //存在直接发送
            if(dest == 0)
                emit updateMonitorList(info.parent,qMakePair(info.name,info.uid));
            else{
                _loadMonitorPageDlg->updateItems(info.parent,qMakePair(info.name,info.uid));
            }
        }
    }
}