#include "WindowAppTaskView.h"
#include "DialogTaskPou.h"
#include "TaskManager.h"
#include "PouManager.h"
#include "WindowAppMdiFrame.h"
#include "DialogTaskOption.h"
#include "WindowAppTaskMonitorView.h"
#include "WindowAppBlockBase.h"
#include "VPGlobal.h"
#include "GvlManager.h"

// 各个列的索引序号

// Pou Table
#define TABLE_POU_INDEX_NAME			0
#define TABLE_POU_INDEX_STATUS			1
#define TABLE_POU_INDEX_EXECTIME		2
#define TABLE_POU_INDEX_EXECCOUNT		3
#define TABLE_POU_INDEX_ERRORCOUNT		4
#define TABLE_POU_COLUMN_COUNT			5

// Tool Table
#define TABLE_TOOL_INDEX_NAME			0
#define TABLE_TOOL_INDEX_STATUS			1
#define TABLE_TOOL_INDEX_RETVALUE		2
#define TABLE_TOOL_INDEX_EXECTIME		3
#define TABLE_TOOL_INDEX_EXECCOUNT		4
#define TABLE_TOOL_INDEX_ERRORCOUNT		5
#define TABLE_TOOL_COLUMN_COUNT			6


WindowAppTaskView::WindowAppTaskView(const QString& strTitle, QWidget* parent)
	: QWidget(parent)
	, m_strTitle(strTitle)
	, m_pTask(nullptr)
{
	ui.setupUi(this);

	// UI元素初始化
	this->initUI();
}

WindowAppTaskView::~WindowAppTaskView()
{
	RELEASE(m_pTask);
}


/// <summary>
/// 根据用户选择的初始化参数构建新的任务，并向TaskManager注册
/// </summary>
/// <param name="option"></param>
void WindowAppTaskView::addNewTask(const TASK_OPTION& option)
{
	// m_pTask = g_pTaskManager->addNewTask(option,this);

	RELEASE(m_pTask);

	m_pTask = new TASK(option);

	// 向Task Manager注册
	g_pTaskManager->registerTask(m_pTask, this);

	// 在Task Monitor View中添加Task信息
	VPGlobal::getTaskMonitorView()->addNewTask(m_pTask);

	this->addTaskVarToSystemGvl(m_pTask);
}


/// <summary>
/// 直接根据Task指针直接生成任务
/// </summary>c 
/// <param name="newTask"></param>
void WindowAppTaskView::addNewTask(TASK* newTask)
{
	m_pTask = newTask;

	g_pTaskManager->registerTask(m_pTask, this);

	// 在Task Monitor View中添加Task信息
	VPGlobal::getTaskMonitorView()->addNewTask(m_pTask);

	this->addTaskVarToSystemGvl(m_pTask);
}


/// <summary>
/// 为Task添加对应的Pou
/// </summary>
/// <param name="selPous"></param>
void WindowAppTaskView::addTaskPous(const QVector<POU*>& selPous)
{
	// 首先检查选择的Pou是否有被其他Task选用了的情况
	//（每个Pou同一时间只能让一个Task执行）
	for (POU* pou : selPous)
	{
		if (pou->isSelByTask())
		{
			Utility::VPCriticalMessageBox(pou->pouName() + " is already running in Task[" + pou->m_pParentTask->strName + "]!");
			return;
		}
	}

	// 将选择的Pou信息保存到数据结构中
	g_pTaskManager->addTaskPous(m_strTitle, selPous);

	// 添加对应的Tab界面和Pou表格信息
	for (POU* pou : selPous)
	{
		// 添加新的Tab
		this->addNewTab(pou);

		int nCount = ui.tablePOU->rowCount();
		ui.tablePOU->setRowCount(nCount + 1);

		QVector<QTableWidgetItem*>	pNewItems;

		QTableWidgetItem* newItem = new QTableWidgetItem(pou->pouName());
		ui.tablePOU->setItem(nCount, TABLE_POU_INDEX_NAME, newItem);
		pNewItems.push_back(newItem);

		newItem = new QTableWidgetItem(emExecStatus.key((short)pou->execParams.nStatus));
		ui.tablePOU->setItem(nCount, TABLE_POU_INDEX_STATUS, newItem);
		pNewItems.push_back(newItem);

		newItem = new QTableWidgetItem(QString::number(pou->execParams.nExecTime));
		ui.tablePOU->setItem(nCount, TABLE_POU_INDEX_EXECTIME, newItem);
		pNewItems.push_back(newItem);

		newItem = new QTableWidgetItem(QString::number(pou->execParams.nExecCount));
		ui.tablePOU->setItem(nCount, TABLE_POU_INDEX_EXECCOUNT, newItem);
		pNewItems.push_back(newItem);

		newItem = new QTableWidgetItem(QString::number(pou->execParams.nErrorCount));
		ui.tablePOU->setItem(nCount, TABLE_POU_INDEX_ERRORCOUNT, newItem);
		pNewItems.push_back(newItem);

		for (int i = 0; i < TABLE_POU_COLUMN_COUNT; i++)
		{
			ui.tablePOU->item(nCount, i)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
		}

		// 添加两者序号的对应关系
		m_RowIndexs.insert(ui.tablePOU->rowCount() - 1, ui.tabPouStatus->count() - 1);
		// 保存Pou对应的每一个表格指针，用于更新
		m_pouToTableWidgetItems.insert(pou->pouName(), pNewItems);

		// 将本Pou和Task绑定
		pou->m_pParentTask = m_pTask;
	}

	// Tab添加完毕后，默认激活第一个
	ui.tabPouStatus->setCurrentIndex(0);
}


/// <summary>
/// 为Task中的Pou添加Tool
/// 此时后台的数据结构数据是完整齐全的，只是需要在相关的表格中添加对应的行
/// </summary>
/// <param name="pTask"></param>
/// <param name="pPou"></param>
/// <param name="pTool"></param>
void WindowAppTaskView::addTaskPouTool(const POU* pPou, const TOOL* pTool)
{
	// 首先找到对应Pou所在的Table
	QTableWidget* pToolTable = m_pouToTables.value(pPou->pouName());

	if (pToolTable != nullptr)
	{
		// Table中增加一行新的工具信息
		this->addNewTabTool(pToolTable, pTool);
	}
}


/// <summary>
/// 添加 Task 的内部变量到系统全局变量组
/// </summary>
/// <param name="pTask"></param>
void WindowAppTaskView::addTaskVarToSystemGvl(const TASK* pTask)
{
	Q_UNUSED(pTask);

	//////////////////////////////////////////////////////////////////////////
	QString strExecCount = m_pTask->strName + EXEC_COUNT_POSTFIX;
	VARIABLE* pNewVariable = new VARIABLE(
		GROUP_NAME_SYSTEM,
		false,
		strExecCount,
		"int",
		"0",
		strExecCount,
		g_pGvlManager->getAllGvls()->find(GROUP_NAME_SYSTEM).value()->Variables.size(),
		true
	);

	g_pGvlManager->addNewVariable(GROUP_NAME_SYSTEM, pNewVariable);
	VARIABLE* pVar = g_pGvlManager->getVariableByName(GROUP_NAME_SYSTEM, strExecCount);
	pVar->value.setValueByAddress((void**)&m_pTask->execParams.nExecCount);


	QString strErrorCount = m_pTask->strName + ERROR_COUNT_POSTFIX;
	pNewVariable = new VARIABLE(
		GROUP_NAME_SYSTEM,
		false,
		strErrorCount,
		"int",
		"0",
		strErrorCount,
		g_pGvlManager->getAllGvls()->find(GROUP_NAME_SYSTEM).value()->Variables.size(),
		true
	);

	g_pGvlManager->addNewVariable(GROUP_NAME_SYSTEM, pNewVariable);
	pVar = g_pGvlManager->getVariableByName(GROUP_NAME_SYSTEM, strErrorCount);
	pVar->value.setValueByAddress((void**)&m_pTask->execParams.nErrorCount);

}


/// <summary>
/// 从系统全局变量组删除 Task 的内部变量
/// </summary>
/// <param name="pTask"></param>
void WindowAppTaskView::delTaskVar(const TASK* pTask)
{
	Q_UNUSED(pTask);
}


/// <summary>
/// 2022-3-5增加，Pou界面中删除了Tool的时候，Task需要同步一下
/// </summary>
/// <param name="strPouName"></param>
/// <param name="strToolName"></param>
void WindowAppTaskView::onDelPouTool(const POU* pPou, const TOOL* pTool)
{
	if (!pTool->isIndexedTool())
	{
		return;
	}

	// 首先找到对应Pou所在的Table
	QTableWidget* pToolTable = m_pouToTables.value(pPou->pouName());

	if (pToolTable != nullptr)
	{
		this->delTabTool(pToolTable, pTool);

		m_toolToTableWidgetItems.remove(pTool);
		// m_toolToTableRow.remove(pTool);

		// qDebug() << "WindowAppTaskView::onDelPouTool - Delete PouTool[" << pTool->strInstanceName << "] from task["	<< m_strTitle << "]";
	}
}


/// <summary>
/// 2022-3-5增加，Pou界面中调整了Tool顺序的时候，Task需要同步
/// (因为表格中不需要多余的操作，只需要重新全部添加一下即可)
/// </summary>
/// <param name="strPouName"></param>
void WindowAppTaskView::onMovePouTool(const POU* pPou)
{
	QTableWidget* pToolTable = m_pouToTables.value(pPou->pouName());

	// 清空表格
	pToolTable->clearContents();
	pToolTable->setRowCount(0);

	// 在表格中添加本Pou的Tool信息
	const QVector<TOOL*>& allTools = pPou->GetAllStandardTools();

	QVectorIterator<TOOL*> i(allTools);
	while (i.hasNext())
	{
		const TOOL* pTool = i.next();

		this->addNewTabTool(pToolTable, pTool);
	}
}


///// <summary>
///// 绑定本视图对应的Task数据结构
///// </summary>
///// <param name="newTask"></param>
//void WindowAppTaskView::bindTask(const TASK& newTask)
//{
//	m_Task = newTask;
//
//	// 将本Task添加进数据结构中
//	g_pTaskManager->addTask(&m_Task);
//}


/// <summary>
/// UI元素初始化
/// </summary>
void WindowAppTaskView::initUI()
{
	// 初始化Pou表格
	this->initPouTable();

	// 初始化工具栏
	this->initToolBar();

	// 初始化Tab页面
	this->initTab();

	// 设置总体布局
	QVBoxLayout* viewLayout = new QVBoxLayout();
	viewLayout->addWidget(m_TaskToolbar);
	viewLayout->addWidget(ui.tablePOU);
	viewLayout->addWidget(ui.labelTool);
	viewLayout->addWidget(ui.tabPouStatus);
	viewLayout->setContentsMargins(0, 0, 0, 0);
	viewLayout->setSpacing(3);
	viewLayout->setStretch(1, 1);
	viewLayout->setStretch(2, 1);
	viewLayout->setStretchFactor(ui.tablePOU, 1);
	viewLayout->setStretchFactor(ui.tabPouStatus, 4);
	this->setLayout(viewLayout);

	connect(this, SIGNAL(sigUpdateTaskStatus()), this, SLOT(updateTaskStatus()));
	connect(this, SIGNAL(sigUpdateTaskTable()), this, SLOT(updateTaskTable()));
	connect(this, SIGNAL(sigUpdateAllTables(const POU*, const TOOL*)), this, SLOT(updateAllTables(const POU*, const TOOL*)));
	connect(this, SIGNAL(sigUpdatePouTable(const POU*)), this, SLOT(updatePouTable(const POU*)));
	connect(this, SIGNAL(sigUpdatePouStatus(const POU*)), this, SLOT(updatePouStatus(const POU*)));
	connect(this, SIGNAL(sigUpdateToolStatus(const POU*, const TOOL*)), this, SLOT(updateToolStatus(const POU*, const TOOL*)));
}


/// <summary>
/// 初始化Pou表格
/// </summary>
void WindowAppTaskView::initPouTable()
{
	// 列数
	ui.tablePOU->setColumnCount(TABLE_POU_COLUMN_COUNT);

	// 设置表头文字
	QStringList headers;
	headers
		<< ("Pou Name")
		<< ("Execution Status")
		<< ("Execution Time(ms)")
		<< ("Execution Count")
		<< ("Error Count");
	ui.tablePOU->setHorizontalHeaderLabels(headers);
	// 2021-8-12 增加，此处不设置一个初始化大小的话，首次显示表格的时候会有问题
	// ui.tablePOU->horizontalHeader()->setDefaultSectionSize(800);
	ui.tablePOU->horizontalHeader()->setStretchLastSection(true);

	//设置表头字体
	QFont font = ui.tablePOU->horizontalHeader()->font();
	font.setBold(true);
	ui.tablePOU->horizontalHeader()->setFont(font);
	// 设置文字左对齐
	ui.tablePOU->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
	// 设置为不可编辑
	ui.tablePOU->setEditTriggers(QAbstractItemView::NoEditTriggers);
	// 设置为整行选中模式
	ui.tablePOU->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui.tablePOU->setSelectionMode(QAbstractItemView::SingleSelection);
	// 设置最左侧的序号不用显示
	ui.tablePOU->verticalHeader()->setVisible(false);
	//设置行高
	ui.tablePOU->verticalHeader()->setDefaultSectionSize(10);
	//点击表时不对表头行光亮（获取焦点）
	ui.tablePOU->horizontalHeader()->setHighlightSections(false);
	// 设置表头为红色
	//ui.tablePOU->horizontalHeader()->setStyleSheet("QHeaderView::section{background:red;}");

	// 绑定双击事件
	connect(ui.tablePOU, SIGNAL(cellDoubleClicked(int, int)), this, SLOT(onDoubleClickedTableRow(int, int)));
}


/// <summary>
/// 初始化工具栏
/// </summary>
void WindowAppTaskView::initToolBar()
{
	m_TaskToolbar = new QToolBar(this);
	m_TaskToolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);

	QAction* actionAddPou = new QAction(QIcon(":/image/ZoomOut.png"), ("Add Pou"));
	QAction* actionPouUp = new QAction(QIcon(":/image/Up.png"), ("Pou Move Up"));
	QAction* actionPouDown = new QAction(QIcon(":/image/Down.png"), ("Pou Move Down"));
	QAction* actionDelPou = new QAction(QIcon(":/image/Stop.png"), ("Delete Pou"));

	QAction* actionOption = new QAction(QIcon(":/image/Option.png"), ("Options"));
	QAction* actionRunOnce = new QAction(QIcon(":/image/RunOnce.png"), ("Run Once"));

	m_TaskToolbar->addAction(actionAddPou);
	m_TaskToolbar->addAction(actionPouUp);
	m_TaskToolbar->addAction(actionPouDown);
	m_TaskToolbar->addAction(actionDelPou);
	m_TaskToolbar->addSeparator();

	m_TaskToolbar->addAction(actionOption);
	m_TaskToolbar->addAction(actionRunOnce);

	m_TaskToolbar->setIconSize(QSize(16, 16));

	// 工具栏的消息响应
	connect(actionAddPou, &QAction::triggered, this, &WindowAppTaskView::onAddPou);
	connect(actionPouUp, &QAction::triggered, this, &WindowAppTaskView::onMoveUp);
	connect(actionPouDown, &QAction::triggered, this, &WindowAppTaskView::onMoveDown);
	connect(actionDelPou, &QAction::triggered, this, &WindowAppTaskView::onDelPou);

	connect(actionOption, &QAction::triggered, this, &WindowAppTaskView::onOption);
	connect(actionRunOnce, &QAction::triggered, this, &WindowAppTaskView::onRunonce);
}


/// <summary>
/// 初始化Tab页面
/// </summary>
void WindowAppTaskView::initTab()
{
	// 清空默认的Tab
	ui.tabPouStatus->clear();

	// 设置不可移动
	ui.tabPouStatus->setMovable(false);

	// 取消关闭按钮
	ui.tabPouStatus->setTabsClosable(false);
}


/// <summary>
/// Add Pou
/// </summary>
void WindowAppTaskView::onAddPou()
{
	// 显示变量选择对话框
	DialogTaskPou dlgTaskPou;
	int res = dlgTaskPou.exec();

	if (res != QDialog::Accepted)
	{
		return;
	}

	// 获取用户选择的Pou信息
	const QVector<POU*> selPous = dlgTaskPou.GetSelectedPous();

	// TODO: 此处是否需要在所有Pou选择完毕之后，把Pou中所有Tool的执行参数重置一下


	this->addTaskPous(selPous);
}


/// <summary>
/// Delete Pou
/// </summary>
void WindowAppTaskView::onDelPou()
{
	// 获取当前选中行
	int nSelRow = ui.tablePOU->currentRow();
	if (nSelRow < 0)
	{
		qDebug() << "[Error] WindowAppTaskView::onDelPou - No pou selected.";

		return;
	}

	QString strDelPouName = ui.tablePOU->item(nSelRow, TABLE_POU_INDEX_NAME)->text();

	// 2021-8-17 首先判断这个Pou是否在执行，执行中就不要删除了
	POU* pDelPou = g_pPouManager->getPouByName(strDelPouName);
	if (pDelPou->isRunningInTask())
	{
		Utility::VPCriticalMessageBox("Can't delete this block : this block is running in task[" + pDelPou->m_pParentTask->strName + "]");

		return;
	}

	// 从数据结构中删除
	g_pTaskManager->delTaskPou(m_strTitle, nSelRow);

	// 删除对应的Tab
	ui.tabPouStatus->removeTab(m_RowIndexs[nSelRow]);
	m_TabTables.remove(nSelRow);
	m_RowIndexs.remove(nSelRow);

	// 删除Pou对应的表格指针	
	m_pouToTableWidgetItems.remove(strDelPouName);

	// 删除Pou对应的Tool表格信息
	m_pouToTables.remove(strDelPouName);

	// 还需要删除对应的Tool表格指针
	QMap<QString, TOOL*> allTools = pDelPou->GetAllTools();
	QMapIterator<QString, TOOL*> i(allTools);
	while (i.hasNext())
	{
		const TOOL* pTool = i.next().value();

		m_toolToTableWidgetItems.remove(pTool);
	}

	// 确认无误后，最后从界面中删除Pou的一行
	ui.tablePOU->removeRow(nSelRow);

	// 清除本Pou的Task信息
	pDelPou->m_pParentTask = nullptr;
}


///// <summary>
///// Open Pou
///// </summary>
//void WindowAppTaskView::onOpenPou()
//{
//	// 获取当前选中行
//	int nSelRow = ui.tablePOU->currentRow();
//
//	// 获取PouName
//	QString strPou = ui.tablePOU->item(nSelRow, 0)->text();
//
//	// 打开对应的Pou页面
//	VPGlobal::getMdiFrame()->activeSubView(strPou);
//}


/// <summary>
/// Move up
/// </summary>
void WindowAppTaskView::onMoveUp()
{
	// 获取行号
	int rowIndex = ui.tablePOU->currentRow();
	if (rowIndex <= 0)
	{
		return;
	}

	int rowIndex2 = rowIndex - 1;

	// 交换两行，以及一系列动作
	swapRows(rowIndex, rowIndex2);
}


/// <summary>
/// Move Down
/// </summary>
void WindowAppTaskView::onMoveDown()
{
	// 获取行号
	int rowIndex = ui.tablePOU->currentRow();
	if (rowIndex < 0 || rowIndex == ui.tablePOU->rowCount() - 1)
	{
		return;
	}

	int rowIndex2 = rowIndex + 1;

	// 交换两行，以及一系列动作
	swapRows(rowIndex, rowIndex2);
}


/// <summary>
/// Option
/// </summary>
void WindowAppTaskView::onOption()
{
	// 如果任务在运行中，则不允许调整设置
	if (m_pTask->isRunning())
	{
		Utility::VPCriticalMessageBox(" Task [" + m_pTask->strName + "] is running, please stop first!");

		return;
	}

	DialogTaskOption dialogTaskOption(this->m_pTask);

	int res = dialogTaskOption.exec();

	if (res != QDialog::Accepted)
	{
		return;
	}

	// 设置调整完毕之后，需要更新一下Task Manager表格
	VPGlobal::getTaskMonitorView()->updateTaskOption(m_pTask);
}


/// <summary>
/// Runonce 
/// </summary>
void WindowAppTaskView::onRunonce()
{
	// 直接调用Task Manager执行任务
	g_pTaskManager->executeTask(m_strTitle, true);
}


/// <summary>
/// 调整大小的消息中改变所有表格的宽度
/// </summary>
/// <param name="event"></param>
void WindowAppTaskView::resizeEvent(QResizeEvent* event)
{
	Q_UNUSED(event);

	// qDebug() << "WindowAppVariableTable::resizeEvent";

	// Pou表格
	int nTotalSize = ui.tablePOU->size().width();
	if (nTotalSize < 800)
	{
		nTotalSize = 800;
	}
	ui.tablePOU->setColumnWidth(TABLE_POU_INDEX_NAME, nTotalSize * 0.30);
	ui.tablePOU->setColumnWidth(TABLE_POU_INDEX_STATUS, nTotalSize * 0.17);
	ui.tablePOU->setColumnWidth(TABLE_POU_INDEX_EXECTIME, nTotalSize * 0.17);
	ui.tablePOU->setColumnWidth(TABLE_POU_INDEX_EXECCOUNT, nTotalSize * 0.17);
	ui.tablePOU->setColumnWidth(TABLE_POU_INDEX_ERRORCOUNT, nTotalSize * 0.17);

	// 所有的Tool监控表格
	for (QTableWidget* pTabTable : m_TabTables)
	{
		int nTabTableSize = pTabTable->size().width();

		pTabTable->setColumnWidth(TABLE_TOOL_INDEX_NAME, nTabTableSize * 0.25);
		pTabTable->setColumnWidth(TABLE_TOOL_INDEX_STATUS, nTabTableSize * 0.15);
		pTabTable->setColumnWidth(TABLE_TOOL_INDEX_RETVALUE, nTabTableSize * 0.15);
		pTabTable->setColumnWidth(TABLE_TOOL_INDEX_EXECTIME, nTabTableSize * 0.15);
		pTabTable->setColumnWidth(TABLE_TOOL_INDEX_EXECCOUNT, nTabTableSize * 0.14);
		pTabTable->setColumnWidth(TABLE_TOOL_INDEX_ERRORCOUNT, nTabTableSize * 0.14);
	}
}


/// <summary>
/// 当双击一行的时候跳转到对应的Pou页面
/// </summary>
/// <param name="nRow"></param>
/// <param name="nCol"></param>
void WindowAppTaskView::onDoubleClickedTableRow(int nRow, int nCol)
{
	Q_UNUSED(nCol);

	// 获取PouName
	QString strPou = ui.tablePOU->item(nRow, 0)->text();

	// 打开对应的Pou页面
	VPGlobal::getMdiFrame()->activeSubView(strPou);
}


/// <summary>
/// 交换两行的数据
/// </summary>
/// <param name="selectRow"></param>
/// <param name="targetRow"></param>
void WindowAppTaskView::swapRows(int selectRow, int targetRow)
{
	// 表格中交换两行
	ui.tablePOU->blockSignals(true);

	QStringList selectRowLine, targetRowLine;

	for (int i = 0; i < TABLE_POU_COLUMN_COUNT; i++)
	{
		QString strSelect = ui.tablePOU->item(selectRow, i)->text();
		QString strTarget = ui.tablePOU->item(targetRow, i)->text();

		ui.tablePOU->item(selectRow, i)->setText(strTarget);
		ui.tablePOU->item(targetRow, i)->setText(strSelect);
	}

	this->blockSignals(false);

	// 从数据结构中移动
	g_pTaskManager->swapTaskPou(m_strTitle, selectRow, targetRow);

	// 表格序号移动
	qSwap(m_TabTables[selectRow], m_TabTables[targetRow]);

	// 调整序号对应关系
	int nTmp = m_RowIndexs.value(selectRow);
	m_RowIndexs[selectRow] = m_RowIndexs.value(targetRow);
	m_RowIndexs[targetRow] = nTmp;

	// 需要移动一下焦点
	ui.tablePOU->selectRow(targetRow);
}


/// <summary>
/// 添加新的Tool Tab
/// </summary>
/// <param name="strPouName"></param>
void WindowAppTaskView::addNewTab(POU* pPou)
{
	// 初始化Tab里的Table
	QTableWidget* newTable = this->initToolTable(pPou->pouName());

	// 保存此表格和Pou的对应关系
	m_pouToTables.insert(pPou->pouName(), newTable);

	// 保存此表格到数据结构
	m_TabTables.push_back(newTable);

	// 将表格嵌入到Tab中
	ui.tabPouStatus->addTab(newTable, pPou->pouName());
	// 激活此Tab
	ui.tabPouStatus->setCurrentIndex(ui.tabPouStatus->count() - 1);

	// 设置初始列宽
	int nTabTableSize = newTable->size().width();

	newTable->setColumnWidth(TABLE_TOOL_INDEX_NAME, nTabTableSize * 0.25);
	newTable->setColumnWidth(TABLE_TOOL_INDEX_STATUS, nTabTableSize * 0.15);
	newTable->setColumnWidth(TABLE_TOOL_INDEX_RETVALUE, nTabTableSize * 0.15);
	newTable->setColumnWidth(TABLE_TOOL_INDEX_EXECTIME, nTabTableSize * 0.15);
	newTable->setColumnWidth(TABLE_TOOL_INDEX_EXECCOUNT, nTabTableSize * 0.14);
	newTable->setColumnWidth(TABLE_TOOL_INDEX_ERRORCOUNT, nTabTableSize * 0.14);

	// 在表格中添加本Pou的Tool信息（按执行顺序）
	const QVector<TOOL*>& allTools = pPou->GetAllStandardTools();

	QVectorIterator<TOOL*> i(allTools);
	while (i.hasNext())
	{
		const TOOL* pTool = i.next();

		this->addNewTabTool(newTable, pTool);
	}
}


/// <summary>
/// 添加Tool信息到Tab表格
/// </summary>
/// <param name="pTable"></param>
/// <param name="pTool"></param>
void WindowAppTaskView::addNewTabTool(QTableWidget* pTable, const TOOL* pTool)
{
	m_toolToTableWidgetItems.remove(pTool);

	// 填充Tool表格，并且保存每一个需要更新的数据表格
	QVector<QTableWidgetItem*>	pNewItems;

	int nCount = pTable->rowCount();
	pTable->setRowCount(nCount + 1);

	QTableWidgetItem* newItem = new QTableWidgetItem(pTool->strInstanceName);
	pTable->setItem(nCount, TABLE_TOOL_INDEX_NAME, newItem);
	pNewItems.push_back(newItem);

	newItem = new QTableWidgetItem(emExecStatus.key((short)pTool->execParams.nStatus));
	pTable->setItem(nCount, TABLE_TOOL_INDEX_STATUS, newItem);
	pNewItems.push_back(newItem);

	newItem = new QTableWidgetItem(emRetValue.key((short)pTool->execParams.nRetValue));
	pTable->setItem(nCount, TABLE_TOOL_INDEX_RETVALUE, newItem);
	pNewItems.push_back(newItem);

	newItem = new QTableWidgetItem(QString::number(pTool->execParams.nExecTime));
	pTable->setItem(nCount, TABLE_TOOL_INDEX_EXECTIME, newItem);
	pNewItems.push_back(newItem);

	newItem = new QTableWidgetItem(QString::number(pTool->execParams.nExecCount));
	pTable->setItem(nCount, TABLE_TOOL_INDEX_EXECCOUNT, newItem);
	pNewItems.push_back(newItem);

	newItem = new QTableWidgetItem(QString::number(pTool->execParams.nErrorCount));
	pTable->setItem(nCount, TABLE_TOOL_INDEX_ERRORCOUNT, newItem);
	pNewItems.push_back(newItem);

	for (int i = 0; i < TABLE_TOOL_COLUMN_COUNT; i++)
	{
		pTable->item(nCount, i)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
	}

	m_toolToTableWidgetItems.insert(pTool, pNewItems);
}


/// <summary>
/// 删除Tab表格中的Tool信息
/// </summary>
/// <param name="pTable"></param>
/// <param name="pTool"></param>
void WindowAppTaskView::delTabTool(QTableWidget* pTable, const TOOL* pTool)
{
	QTableWidgetItem* pToolNameItem = m_toolToTableWidgetItems.value(pTool)[TABLE_TOOL_INDEX_NAME];
	
	int row = pTable->row(pToolNameItem);

	pTable->removeRow(row);
}


/// <summary>
/// 初始化Tab里的Table
/// </summary>
QTableWidget* WindowAppTaskView::initToolTable(const QString& strPouName)
{
	Q_UNUSED(strPouName);

	QTableWidget* newTable = new QTableWidget();

	// 列数
	newTable->setColumnCount(TABLE_TOOL_COLUMN_COUNT);

	// 设置表头文字
	QStringList headers;
	headers
		<< ("Tool Name")
		<< ("Execution Status")
		<< ("Return Value")
		<< ("Execution Time(ms)")
		<< ("Execution Count")
		<< ("Error Count");
	newTable->setHorizontalHeaderLabels(headers);
	newTable->horizontalHeader()->setStretchLastSection(true);

	//设置表头字体
	QFont font = ui.tablePOU->horizontalHeader()->font();
	font.setBold(true);
	newTable->horizontalHeader()->setFont(font);
	// 设置文字左对齐
	newTable->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
	// 设置为不可编辑
	newTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
	// 设置为整行选中模式
	newTable->setSelectionBehavior(QAbstractItemView::SelectRows);
	newTable->setSelectionMode(QAbstractItemView::SingleSelection);
	// 设置最左侧的序号不用显示
	newTable->verticalHeader()->setVisible(false);
	//设置行高
	newTable->verticalHeader()->setDefaultSectionSize(10);
	//点击表时不对表头行光亮（获取焦点）
	newTable->horizontalHeader()->setHighlightSections(false);

	return newTable;

}


/// <summary>
/// 根据最新的执行结果刷新界面
/// </summary>
void WindowAppTaskView::updateAllTables(const POU* pRunningPou, const TOOL* pRunningTool)
{
	// qDebug() << "WindowAppTaskView::updateAllTables";
	WindowAppBlockBase* pPortItem = const_cast<POU*>(pRunningPou)->GetToolItem(const_cast<TOOL*>(pRunningTool));
	pPortItem->update();


	// 刷新Tool表格
	this->updateToolTable(pRunningTool);

	// 刷新Pou表格
	this->updatePouTable(pRunningPou);

	// 刷新Task表格中的对应行
	this->updateTaskTable();
}


/// <summary>
/// 单独更新Task状态
/// </summary>
void WindowAppTaskView::updateTaskStatus()
{
	VPGlobal::getTaskMonitorView()->updateTaskStatus(m_pTask);
}


/// <summary>
/// 单独更新Pou状态
/// </summary>
/// <param name="pRunningPou"></param>
void WindowAppTaskView::updatePouStatus(const POU* pRunningPou)
{
	m_pouToTableWidgetItems.value(pRunningPou->pouName())[TABLE_POU_INDEX_STATUS]
		->setText(emExecStatus.key((short)pRunningPou->execParams.nStatus));
}


/// <summary>
/// 单独更新Tool状态
/// </summary>
/// <param name="pRunningTool"></param>
void WindowAppTaskView::updateToolStatus(const POU* pPou, const TOOL* pRunningTool)
{
	m_toolToTableWidgetItems.value(pRunningTool)[TABLE_TOOL_INDEX_STATUS]
		->setText(emExecStatus.key((short)pRunningTool->execParams.nStatus));

	WindowAppBlockBase* pPortItem = const_cast<POU*>(pPou)->GetToolItem(const_cast<TOOL*>(pRunningTool));
	pPortItem->update();
}


/// <summary>
/// 刷新Task表格中的对应行
/// </summary>
void WindowAppTaskView::updateTaskTable()
{
	// 调用TaskMonitorView直接更新
	VPGlobal::getTaskMonitorView()->updateTask(m_pTask);
}


/// <summary>
/// 刷新Pou表格
/// </summary>
void WindowAppTaskView::updatePouTable(const POU* pRunningPou)
{
	if (m_pouToTableWidgetItems.contains(pRunningPou->pouName()))
	{
		QVector<QTableWidgetItem*>& pItems = m_pouToTableWidgetItems[pRunningPou->pouName()];
		const EXEC_PARAMS& params = pRunningPou->execParams;

		pItems[TABLE_POU_INDEX_STATUS]->setText(emExecStatus.key((short)params.nStatus));
		//pItems[TABLE_POU_INDEX_EXECTIME]->setText(QString::number(params.nExecTime));
		if (params.nExecTime != 0)
		{
			pItems[TABLE_POU_INDEX_EXECTIME]->setText(QString::number(params.nExecTime) + " (" + QString::number(1000.0 / (params.nExecTime + 0.0001), 'f', 1) + "fps)");
		}
		pItems[TABLE_POU_INDEX_EXECCOUNT]->setText(QString::number(params.nExecCount));
		pItems[TABLE_POU_INDEX_ERRORCOUNT]->setText(QString::number(params.nErrorCount));
	}
	else
	{
		qDebug() << "[Warning] WindowAppTaskView::updatePouTable - Ingonre, reason: can't find " 
			<< pRunningPou->pouName() << " table.";
	}

}


/// <summary>
/// 刷新Tool表格
/// </summary>
void WindowAppTaskView::updateToolTable(const TOOL* pRunningTool)
{
	if (m_toolToTableWidgetItems.contains(pRunningTool))
	{
		// 根据Tool的执行状态更新这个表格对应的数据
		QVector<QTableWidgetItem*>& pItems = m_toolToTableWidgetItems[pRunningTool];
		const EXEC_PARAMS& params = pRunningTool->execParams;

		pItems[TABLE_TOOL_INDEX_STATUS]->setText(emExecStatus.key((short)params.nStatus));
		pItems[TABLE_TOOL_INDEX_RETVALUE]->setText(emRetValue.key((short)params.nRetValue));
		if (params.nExecTime != 0)
		{
			pItems[TABLE_TOOL_INDEX_EXECTIME]->setText(QString::number(params.nExecTime) + " (" + QString::number(1000.0 / (params.nExecTime + 0.0001), 'f', 1) + "fps)");
		}
	
		pItems[TABLE_TOOL_INDEX_EXECCOUNT]->setText(QString::number(params.nExecCount));
		pItems[TABLE_TOOL_INDEX_ERRORCOUNT]->setText(QString::number(params.nErrorCount));
	}
	else
	{
		qDebug() << "[Warning] WindowAppTaskView::updatePouTable - Ingonre, reason: can't find " << pRunningTool->strInstanceName << " table.";
	}
}