/*
 * DeleteModuleCmd.cpp
 *
 *  Created on: 2012-10-9
 *      Author: liujunxia
 */
#include <QtDebug>

#include "DeleteModuleCmd.h"
#include "CopyModuleCmd.h"
#include "ModuleGraphicsItem.h"
#include "ModuleConnectGraphicsItem.h"
#include "PaiWorkflowDataModel.h"
#include "GlobalModuleBackup.h"
#include "PAIConst.h"
#include "GlobalWorkflowItems.h"
#include "ModuleInformation.h"
#include "ModuleConnection.h"
#include "CModuleInfoAndStyle.h"
#include "WorkflowSceneManager.h"
#include "WorkFlowFile.h"
#include "PaiMessageBox.h"
#include "ConsoleGUIService.h"
#include <PELibraryModule.h>
using namespace pai::gui;
using namespace pai;
using namespace pai::graphics2d;
using namespace pai::workflow;

namespace pai
{
	bool lessThan(CModuleInfoAndStyle* pFirst, CModuleInfoAndStyle* pSecond)
	{
		return pFirst->GetModuleInformation()->GetStepID() < pSecond->GetModuleInformation()->GetStepID();
	}

	bool descend(int a, int b)
	{
		return a > b;
	}

	DeleteModuleCmd::DeleteModuleCmd(pai::graphics2d::WorkflowSceneManager *pSceneManager,
					pai::objectmodel::PaiWorkflowDataModel *pWorkflow,QList<QGraphicsItem*> list, QUndoCommand *parent)
	:QUndoCommand(parent)
	{
		m_pSceneManager = pSceneManager;
		m_pWorkflow = pWorkflow;
		m_stepIdList = GlobalWorkflowItems::GetInstance()->GetStepIdList(list);
		m_connectionList = GetDeletedModuleConnections(list);
	}

	DeleteModuleCmd::~DeleteModuleCmd()
	{
		m_stepIdList.clear();
		m_connectionList.clear();
	}

	void DeleteModuleCmd::undo()
	{
		if (NULL == m_pSceneManager)
		{
			return;
		}

		m_pSceneManager->SetFocusViewport();
		//确保线程池中线程结束
		m_pSceneManager->WaitThreadForDone();

		foreach(CModuleInfoAndStyle* pModuleInfoStyle, m_deletedModules)
		{
			CModuleInformation* pNewModuleInfo = new CModuleInformation();
			pNewModuleInfo->Clone(*(pModuleInfoStyle->GetModuleInformation()));

			int originalId = pNewModuleInfo->GetStepID();

			m_pWorkflow->AddModule(pNewModuleInfo);
			//在场景中添加模块
			m_pSceneManager->AddModule(pNewModuleInfo,m_pWorkflow->GetModuleStyle(pNewModuleInfo->GetStepID()));

			int currentId = pNewModuleInfo->GetStepID();

			if (currentId > originalId)
			{
				updateModuleInfos(originalId -1);
				updateConnectionLines(originalId - 1);
			}

			ModuleGraphicsItem* pModGraphics;
			if (currentId > originalId)
			{
				pModGraphics = GlobalWorkflowItems::GetInstance()->FindModule(m_pSceneManager, currentId +1);
				pModGraphics->GetModule()->SetStepID(originalId);
				pModGraphics->GetModuleStyle()->SetId(originalId);
			}
			else
			{
				pModGraphics = GlobalWorkflowItems::GetInstance()->FindModule(m_pSceneManager, currentId);
			}
			assert(pModGraphics != NULL);

			PaiModuleStyle* pStyle = pModGraphics->GetModuleStyle();
			int newId = pStyle->GetId();
			pStyle->Copy(*(pModuleInfoStyle->GetModuleStyle()));
			pStyle->SetId(newId);

			pModGraphics->GetModuleStyle()->SetPosition(pModuleInfoStyle->GetModulePos(), pModGraphics);
			pModGraphics->GetModuleStyle()->SetMousePressPos(pModuleInfoStyle->GetModuleStyle()->GetMousePressPos());
			pModGraphics->GetModuleStyle()->SetMouseReleasePos(pModuleInfoStyle->GetModuleStyle()->GetMouseReleasePos());
		}

		foreach(CModuleConnection connection, m_connectionList)
		{
			CModuleConnection* pNewConnection = new CModuleConnection();
			connection.CopyTo(*pNewConnection);
			m_pWorkflow->AddConnection(pNewConnection);
			m_pSceneManager->AddConnection(pNewConnection);
		}
		m_pSceneManager->StartSubmitValidateThread();
	}
	void DeleteModuleCmd::redo()
	{
		if (NULL == m_pSceneManager)
		{
			return;
		}

		m_pSceneManager->SetFocusViewport();

		qDeleteAll(m_deletedModules);
		m_deletedModules.clear();

		deleteModule();
	}

	void DeleteModuleCmd::deleteModule()
	{
		//删除连线前，确保线程池中线程结束
		m_pSceneManager->WaitThreadForDone();
		GlobalModuleBackup* moduleBack = ::GetGlobalModuleBackup();
		deleteConnection();
		try
		{
			if (m_stepIdList.count() > 0)
			{
				qSort(m_stepIdList.begin(), m_stepIdList.end(), descend);
			}

			foreach(int stepId, m_stepIdList)
			{
				workflow::CModuleInformation *pModule = m_pWorkflow->GetModuleByStepID(stepId);
				if(!pModule) continue;
				CModuleInfoAndStyle* pModuleInfoStyle = new CModuleInfoAndStyle();

				CModuleInformation* pInfo = new CModuleInformation();
				pInfo->Clone(*(pModule));

				PaiModuleStyle* pStyle = new PaiModuleStyle();
				pStyle->Copy(*(m_pWorkflow->GetModuleStyle(stepId)));

				pModuleInfoStyle->SetModuleInformation(pInfo);
				pModuleInfoStyle->SetModuleStyle(pStyle);
				pModuleInfoStyle->SetModulePos(pStyle->GetPosition());

				m_deletedModules << pModuleInfoStyle;
			}

			foreach(int stepId, m_stepIdList)
			{
				workflow::CModuleInformation *pModule = m_pWorkflow->GetModuleByStepID(stepId);
				if(!pModule) continue;
				moduleBack->RemoveBackupModule(m_pWorkflow->GetID(),pModule);
				PELibraryModule* amodule=dynamic_cast<PELibraryModule*>(pModule->GetModule());
				if(amodule&&amodule->parDialog) {
					amodule->parDialog->setParent(NULL);
				}
				m_pSceneManager->DeleteModule(stepId);
				m_pWorkflow->RemoveModule(m_pWorkflow->GetModuleByStepID(stepId));
				moduleBack->UpdateBackupModuleStepIDs(m_pWorkflow->GetID());
			}

			if (m_deletedModules.count() > 0)
			{
				qSort(m_deletedModules.begin(), m_deletedModules.end(), lessThan);
			}
			//删除连线成功，开启提交校验
			m_pSceneManager->StartSubmitValidateThread();
		}
		catch(pai::error::generic_error & e)
		{
            QString strMessage = QString("Exception occured when deleting Modules. ").append(e.what());
            PaiMessageBox::Critical(NULL, PAI_NAME, strMessage);
			pai::log::Error(_FLF(QObject::tr("QUndoCommand::ShowMessage ").toStdString()+strMessage.toStdString()));
		}
	}

	void DeleteModuleCmd::deleteConnection()
	{
		foreach(CModuleConnection connection, m_connectionList)
		{
			for (unsigned int i = 0; i < m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->size(); i++)
			{
				if (connection == *(m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(i)))
				{
					m_pSceneManager->DeleteConnection(m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(i));
					m_pWorkflow->RemoveConnection(m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(i));
					break;
				}
			}
		}
	}

	void DeleteModuleCmd::updateConnectionLines(int startId)
	{
		//改变connection中sourceid和destid
		for (unsigned int j = 0; j < m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->size(); j++)
		{
			if (m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(j)->GetDestId() > startId)
				m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(j)->SetDestId(
						m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(j)->GetDestId() + 1);
			if (m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(j)->GetSourceId() > startId)
				m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(j)->SetSourceId(
						m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(j)->GetSourceId() + 1);
		}
	}

	void DeleteModuleCmd::updateModuleInfos(int startId)
	{
		//:改变module 和 Style的Id
		for (unsigned int j = 0; j < m_pWorkflow->GetWorkflowFile()->GetModuleInfos()->size(); j++)
		{
			if (m_pWorkflow->GetWorkflowFile()->GetModuleInfos()->at(j)->GetStepID() > startId)
				m_pWorkflow->GetWorkflowFile()->GetModuleInfos()->at(j)->SetStepID(
						m_pWorkflow->GetWorkflowFile()->GetModuleInfos()->at(j)->GetStepID() + 1);
			if (m_pWorkflow->GetModuleStyles()->at(j)->GetId() > startId)
			{
				m_pWorkflow->GetModuleStyles()->at(j)->SetId(m_pWorkflow->GetModuleStyles()->at(j)->GetId() + 1);
			}
		}
	}

	QList<workflow::CModuleConnection> DeleteModuleCmd::GetDeletedModuleConnections(QList<QGraphicsItem*> selectedItems)
	{
		QList<workflow::CModuleConnection> connectionList;

		foreach (QGraphicsItem *pItem, selectedItems)
		{
			ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
			if (!pModule)
			{
				ModuleConnectGraphicsItem *pconnectItem = dynamic_cast<ModuleConnectGraphicsItem*>(pItem);
				if (pconnectItem)
				{
					workflow::CModuleConnection* pConnection = pconnectItem->GetConnection();
					if (!connectionList.contains(*pConnection))
					{
						workflow::CModuleConnection connectionBackup;
						pConnection->CopyTo(connectionBackup);
						connectionList << connectionBackup;
					}
				}
				continue;
			}

			int deletedModuleId = pModule->GetModule()->GetId();
			for (unsigned int i = 0; i < m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->size(); i++)
			{
				workflow::CModuleConnection* pConnection = m_pWorkflow->GetWorkflowFile()->GetModuleConnections()->at(i);

				if (pConnection->GetDestId() == deletedModuleId || pConnection->GetSourceId() == deletedModuleId)
				{
					if (!connectionList.contains(*pConnection))
					{
						workflow::CModuleConnection connectionBackup;
						pConnection->CopyTo(connectionBackup);
						connectionList << connectionBackup;
					}
				}
			}
		}
		return connectionList;
	}
}