#include "taskstatuspage.h"

#include "tw/treeview.h"

#include "tw/colors.h"

#include "tfarmcontroller.h"

#include "application.h"

#include "tw/mainshell.h"

#include "tw/textfield.h"

#include "tw/label.h"

#include "tw/scrollbar.h"

#include "tw/event.h"

#include "textlist.h"

#include "tw/message.h"

#include "pixmaps.h"

#include <vector></vector>

using namespace std;

using namespace TwConsts;

namespace

{

class TaskTreeItemRoot : public TTreeViewItem

{

public:

	TaskTreeItemRoot(TTreeViewItem *parent = 0) : TTreeViewItem(parent) {}

	wstring getName() const { return toWideString("tasks"); }

	TDimension getIconSize() const { return TDimension(32, 30); }

	void drawIcon(TTreeView *w, const TPoint &origin)

	{

		TRect rect(origin, getIconSize());

		rect = rect.enlarge(-3);

		w->rectwrite(tasks_icon, rect.getP00());

	}

};

class TaskTreeItem : public TTreeViewItem

{

public:

	TaskTreeItem(TTreeViewItem *parent, string &id, string &name, TaskState status)

		: TTreeViewItem(parent), m_id(id)

	{

		/*

          setIsLeaf(true);

          if(task.m_parentId =="")

            setIsLeaf(false);

*/

		m_name = " <" + m_id + "> " + name;

		m_status = status;

	}

	wstring getName() const

	{

		return toWideString(m_name);

	}

	string getId() const

	{

		return m_id;

	}

	TDimension getIconSize() const { return TDimension(24, 22); }

	void drawIcon(TTreeView *w, const TPoint &origin)

	{

		TRect rect(origin, getIconSize());

		rect = rect.enlarge(-3);

		switch (m_status) {

		case Suspended:

			w->rectwrite(casm_suspended, rect.getP00());

			break;

		case Waiting:

			w->rectwrite(casm_waiting, rect.getP00());

			break;

		case Running:

			w->rectwrite(casm_computing, rect.getP00());

			break;

		case Completed:

			w->rectwrite(casm_done, rect.getP00());

			break;

		case Aborted:

			w->rectwrite(casm_done_with_errors, rect.getP00());

			break;

			//case TaskUnknown:

		}

	}

	string m_name;

	string m_id;

	TaskState m_status;

};

class SubtaskTreeItem : public TaskTreeItem

{

public:

	SubtaskTreeItem(TaskTreeItem *parent, string &id, string &name, TaskState status)

		: TaskTreeItem(parent, id, name, status)

	{

		setIsLeaf(true);

	}

	void drawIcon(TTreeView *w, const TPoint &origin)

	{

		TRect rect(origin, getIconSize());

		rect = rect.enlarge(-3);

		switch (m_status) {

		case Suspended:

			w->rectwrite(suspended, rect.getP00());

			break;

		case Waiting:

			w->rectwrite(waiting, rect.getP00());

			break;

		case Running:

			w->rectwrite(computing, rect.getP00());

			break;

		case Completed:

			w->rectwrite(done, rect.getP00());

			break;

		case Aborted:

			w->rectwrite(done_with_errors, rect.getP00());

			break;

			//case TaskUnknown:

		}

	}

};

class TaskTree : public TTreeView

{

	TaskStatusPage *m_statusPage;

	TPopupMenu *m_popupMenu;

	TPopupMenu *m_globalPopupMenu;

public:

	TaskTree(TaskStatusPage *parent, string name = "taskTree")

		: TTreeView(parent, name), m_statusPage(parent)

	{

		m_popupMenu = new TPopupMenu(this);

		TPopupMenuItem *item = new TPopupMenuItem(m_popupMenu, "remove");

		TGuiCommand("remove").setAction(new TCommandAction<tasktree>(this, onRemove));</tasktree>

		TGuiCommand("remove").add(item);

		item = new TPopupMenuItem(m_popupMenu, "restart");

		TGuiCommand("restart").setAction(new TCommandAction<tasktree>(this, onRestart));</tasktree>

		TGuiCommand("restart").add(item);

		m_globalPopupMenu = new TPopupMenu(this);

		TPopupMenuItem *item1 = new TPopupMenuItem(m_globalPopupMenu, "restart all");

		TGuiCommand("restart all").setAction(new TCommandAction<tasktree>(this, onRestartAll));</tasktree>

		TGuiCommand("restart all").add(item1);

	}

	void rightButtonDown(const TMouseEvent &e)

	{

		leftButtonDown(e);

		TTreeViewItem *item = getSelectedItem();

		TaskTreeItem *taskItem = dynamic_cast<tasktreeitem *="">(item);</tasktreeitem>

		if (taskItem) {

			TPoint pos = getAbsolutePosition() + TPoint(e.m_pos.x, getSize().ly - e.m_pos.y);

			m_popupMenu->popup(pos);

		}

		TaskTreeItemRoot *taskItemRoot = dynamic_cast<tasktreeitemroot *="">(item);</tasktreeitemroot>

		if (taskItemRoot) {

			TPoint pos = getAbsolutePosition() + TPoint(e.m_pos.x, getSize().ly - e.m_pos.y);

			m_globalPopupMenu->popup(pos);

		}

	}

	void onSelect(TTreeViewItem *item)

	{

		TaskTreeItem *taskItem = dynamic_cast<tasktreeitem *="">(item);</tasktreeitem>

		if (taskItem)

			m_statusPage->showTaskInfo(taskItem->getId());

	}

	void onExpand(TTreeViewItem *item)

	{

		string id = "";

		TaskTreeItem *i = dynamic_cast<tasktreeitem *="">(item);</tasktreeitem>

		if (i)

			id = i->getId();

		item->clearItems();

		TFarmController *controller = Application::instance()->getController();

		vector<string> tasks;</string>

		try {

			controller->getTasks(id, tasks);

			vector<string>::iterator it = tasks.begin();</string>

			for (int j = 0; it != tasks.end(); ++it, ++j) {

				string taskId = *it;

				if (taskId != "") {

					TFarmTask task;

					string parentId, name;

					TaskState status;

					controller->queryTaskShortInfo(taskId, parentId, name, status);

					if (!item->getItem(name))

						if (parentId == "")

							item->addItem(new TaskTreeItem(0, taskId, name, status));

						else

							item->addItem(new SubtaskTreeItem(0, taskId, name, status));

				}

			}

			/*

        int count = tasks.size();

        for (int j = 0; j< count; ++j)

          if(tasks[j] != "")

          {

            TFarmTask task;

            controller->queryTaskInfo(tasks[j], task);

            //TMainshell::errorMessage("dopo queryTaskInfo" + tasks[j]);

            if(!item->getItem(task.m_name))

              if(task.m_parentId == "")

                item->addItem(new TaskTreeItem(0, task));

              else

                item->addItem(new SubtaskTreeItem(0, task));

          }

*/

		} catch (TException &e) {

			TMessage::error(toString(e.getMessage()));

		}

	}

	void onCollapse(TTreeViewItem *item)

	{

		/*

      string id = "";

      TaskTreeItem *taskItem = dynamic_cast<tasktreeitem*> (item);</tasktreeitem*>

      if(taskItem) 

*/

		item->clearItems();

	}

	void onRemove()

	{

		string id = "";

		TaskTreeItem *taskTreeItem = dynamic_cast<tasktreeitem *="">(getSelectedItem());</tasktreeitem>

		if (taskTreeItem)

			id = taskTreeItem->getId();

		TFarmController *controller = Application::instance()->getController();

		try {

			controller->removeTask(id);

			update();

		} catch (TException &e) {

			TMessage::error(toString(e.getMessage()));

		}

	}

	void onRestart()

	{

		string id = "";

		TaskTreeItem *taskTreeItem = dynamic_cast<tasktreeitem *="">(getSelectedItem());</tasktreeitem>

		if (taskTreeItem)

			id = taskTreeItem->getId();

		TFarmController *controller = Application::instance()->getController();

		try {

			controller->restartTask(id);

			update();

		} catch (TException &e) {

			TMessage::error(toString(e.getMessage()));

		}

	}

	void onRestartAll()

	{

		TFarmController *controller = Application::instance()->getController();

		try {

			vector<string> tasks;</string>

			controller->getTasks("", tasks);

			int i = 0;

			for (; i < (int)tasks.size(); i++)

				controller->restartTask(tasks[i]);

			update();

		} catch (TException &e) {

			TMessage::error(toString(e.getMessage()));

		}

	}

	void update(TTreeViewItem *item)

	{

		if (!item->isOpen())

			return;

		TFarmController *controller = Application::instance()->getController();

		string taskId;

		TaskTreeItem *task = dynamic_cast<tasktreeitem *="">(item);</tasktreeitem>

		if (task)

			taskId = task->getId();

		vector<taskshortinfo> subTasks;</taskshortinfo>

		try {

			controller->getTasks(taskId, subTasks);

		} catch (TException &e) {

			TMessage::error(toString(e.getMessage()));

			return;

		}

		vector<ttreeviewitem *=""> toBeDeleted;</ttreeviewitem>

		int count = item->getItemCount();

		for (int i = 0; i < count; ++i) {

			TaskTreeItem *subTask = dynamic_cast<tasktreeitem *="">(item->getItem(i));</tasktreeitem>

			if (subTask) {

				vector<taskshortinfo>::iterator it = subTasks.begin();</taskshortinfo>

				for (; it != subTasks.end(); ++it) {

					string id = it->m_id;

					if (id == subTask->getId())

						break;

				}

				if (it != subTasks.end()) {

					subTask->m_status = it->m_status;

					update(subTask);

				} else

					toBeDeleted.push_back(subTask);

			}

		}

		vector<ttreeviewitem *="">::iterator it = toBeDeleted.begin();</ttreeviewitem>

		while (it != toBeDeleted.end()) {

			if (getSelectedItem() == *it) {

				TTreeViewItem *task = dynamic_cast<ttreeviewitem *="">((*it)->getParent());</ttreeviewitem>

				if (task)

					select(task);

			}

			item->removeItem(*it++);

		}

#ifdef PRIMA

		TFarmController *controller = Application::instance()->getController();

		vector<ttreeviewitem *=""> toBeDeleted;</ttreeviewitem>

		int count = item->getItemCount();

		for (int i = 0; i < count; ++i) {

			TaskTreeItem *task = dynamic_cast<tasktreeitem *="">(item->getItem(i));</tasktreeitem>

			if (task) {

				TFarmTask taskInfo;

				try {

					string parentId, name;

					TaskState status;

					controller->queryTaskShortInfo(task->getId(), parentId, name, status);

					if (status == TaskUnknown)

						toBeDeleted.push_back(task);

					else {

						task->m_status = status;

						update(task);

					}

				} catch (TException &e) {

					TMainshell::errorMessage(e.getMessage());

					return;

				}

			}

		}

		vector<ttreeviewitem *="">::iterator it = toBeDeleted.begin();</ttreeviewitem>

		while (it != toBeDeleted.end()) {

			if (getSelectedItem() == *it) {

				TTreeViewItem *task = dynamic_cast<ttreeviewitem *="">((*it)->getParent());</ttreeviewitem>

				if (task)

					select(task);

			}

			item->removeItem(*it++);

		}

#endif

	}

	void update()

	{

		TFarmController *controller = Application::instance()->getController();

		TTreeViewItem *item = getItem(0);

		if (!item->isOpen())

			return;

		if (item)

			update(item);

		//aggiungo i nuovi

		vector<string> tasks;</string>

		try {

			controller->getTasks("", tasks);

		} catch (TException &e) {

			TMessage::error(toString(e.getMessage()));

			return;

		}

		vector<string>::iterator it = tasks.begin();</string>

		for (; it != tasks.end(); it++) {

			bool old = false;

			int count = item->getItemCount();

			for (int i = 0; i < count; ++i) {

				TaskTreeItem *task = dynamic_cast<tasktreeitem *="">(item->getItem(i));</tasktreeitem>

				if (task)

					old = (*it == task->getId());

				if (old)

					break;

			}

			if (!old) {

				if (*it != "") {

					TFarmTask task;

					try {

						string parentId, name;

						TaskState status;

						controller->queryTaskShortInfo(*it, parentId, name, status);

						item->addItem(new TaskTreeItem(0, *it, name, status));

					} catch (TException &e) {

						TMessage::error(toString(e.getMessage()));

						return;

					}

				}

			}

		}

		updateVisibleItems();

		invalidate();

	}

};

}; //namespace

//==============================================================================

class TaskStatusPage::Data

{

public:

	Data(TaskStatusPage *parent);

	void showTaskInfo(const TFarmTask &task);

	void configureNotify(const TDimension &size);

	void clearFields();

	TFarmTask m_currTask;

	TaskTree *m_tree;

	TTextField *m_taskId, *m_cmdLine, *m_server,

		*m_byUser, *m_onMachine, *m_priority,

		*m_submissionDate, *m_startDate, *m_completionDate,

		*m_taskStatus, *m_failedSteps, *m_successfullSteps,

		*m_stepCount;

	TLabel *m_taskIdLbl, *m_cmdLineLbl, *m_serverLbl,

		*m_byUserLbl, *m_onMachineLbl, *m_priorityLbl,

		*m_submissionDateLbl, *m_startDateLbl, *m_completionDateLbl,

		*m_taskStatusLbl, *m_failedStepsLbl, *m_successfullStepsLbl,

		*m_stepCountLbl, *m_dependenciesLbl;

	TTextList *m_dependencies;

	TScrollbar *m_scrollVBar, *m_scrollHBar;

};

//------------------------------------------------------------------------------

TaskStatusPage::Data::Data(TaskStatusPage *parent)

{

	m_tree = new TaskTree(parent, "taskTree");

	m_taskId = new TTextField(parent, "taskId");

	m_cmdLine = new TTextField(parent, "cmdLine");

	m_server = new TTextField(parent, "server");

	m_byUser = new TTextField(parent, "byUser");

	m_onMachine = new TTextField(parent, "onMachine");

	m_priority = new TTextField(parent, "priority");

	m_submissionDate = new TTextField(parent, "submissionDate");

	m_startDate = new TTextField(parent, "startDate");

	m_completionDate = new TTextField(parent, "completionDate");

	m_taskStatus = new TTextField(parent, "taskStatus");

	m_stepCount = new TTextField(parent, "stepCount");

	m_failedSteps = new TTextField(parent, "failedSteps");

	m_successfullSteps = new TTextField(parent, "successfullSteps");

	m_dependencies = new TTextList(parent);

	m_taskIdLbl = new TLabel(parent, "task id");

	m_cmdLineLbl = new TLabel(parent, "command line");

	m_serverLbl = new TLabel(parent, "server");

	m_byUserLbl = new TLabel(parent, "submitted by");

	m_onMachineLbl = new TLabel(parent, "submitted on");

	m_priorityLbl = new TLabel(parent, "priority");

	m_submissionDateLbl = new TLabel(parent, "submission date");

	m_startDateLbl = new TLabel(parent, "start date");

	m_completionDateLbl = new TLabel(parent, "completion date");

	m_stepCountLbl = new TLabel(parent, "step count");

	m_failedStepsLbl = new TLabel(parent, "failed steps");

	m_successfullStepsLbl = new TLabel(parent, "successfull steps");

	m_dependenciesLbl = new TLabel(parent, "dependencies");

	m_taskStatusLbl = new TLabel(parent, "status");

	m_scrollVBar = new TScrollbar(parent, "vscroll");

	m_scrollHBar = new TScrollbar(parent, "hscroll");

	m_tree->setScrollbars(m_scrollHBar, m_scrollVBar);

}

//------------------------------------------------------------------------------

void TaskStatusPage::Data::showTaskInfo(const TFarmTask &task)

{

	switch (task.m_status) {

	case Waiting:

		m_taskStatus->setText("Waiting");

		break;

	case Running:

		m_taskStatus->setText("Running");

		break;

	case Completed:

		m_taskStatus->setText("Completed");

		break;

	case Aborted:

		m_taskStatus->setText("Failed");

		break;

	case TaskUnknown:

		clearFields();

		return;

	}

	m_taskId->setText(task.m_id);

	m_cmdLine->setText(task.m_cmdline);

	m_server->setText(task.m_server);

	m_byUser->setText(task.m_user);

	m_onMachine->setText(task.m_hostName);

	m_priority->setText(toString(task.m_priority));

	m_submissionDate->setText(task.m_submissionDate);

	m_startDate->setText(task.m_startDate);

	m_completionDate->setText(task.m_completionDate);

	m_stepCount->setText(toString(task.m_stepCount));

	m_failedSteps->setText(toString(task.m_failedSteps));

	m_successfullSteps->setText(toString(task.m_successfullSteps));

	m_dependencies->clearAll();

	if (task.m_dependencies) {

		int count = task.m_dependencies->getTaskCount(), i = 0;

		TFarmController *controller = Application::instance()->getController();

		for (; i < count; ++i) {

			string id, parentId, name;

			TaskState status;

			id = task.m_dependencies->getTaskId(i);

			try {

				controller->queryTaskShortInfo(id, parentId, name, status);

			} catch (TException &e) {

				TMessage::error(toString(e.getMessage()));

			}

			string label = "<" + id + "> " + name;

			m_dependencies->addItem(new TTextListItem(id, label));

		}

	}

	m_dependencies->invalidate();

}

//------------------------------------------------------------------------------

void TaskStatusPage::Data::configureNotify(const TDimension &size)

{

	const int dx = 10;

	const int dy = 5;

	const int h = 20;

	const int lw = 120;

	const int leftSize = tmin(250, size.lx / 3);

	const int w = size.lx - leftSize - lw - dx * 3;

	int left = leftSize + dx;

	int y0 = size.ly - 30;

	int x0;

	//prima la parte a sx

	const int scbSize = 15;

	TRect rect = TRect(0, 0, leftSize, size.ly);

	int x = leftSize;

	m_tree->setGeometry(rect.x0, rect.y0 + scbSize, x - 1 - scbSize, rect.y1);

	m_scrollVBar->setGeometry(x - scbSize, rect.y0 + scbSize, x - 1, rect.y1);

	m_scrollHBar->setGeometry(rect.x0, rect.y0, x - 1 - scbSize, rect.y0 + scbSize - 1);

	// ora la parte a dx

	x0 = left;

	m_taskIdLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_taskId->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_taskStatusLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_taskStatus->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_cmdLineLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_cmdLine->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_serverLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_server->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_byUserLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_byUser->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_onMachineLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_onMachine->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_priorityLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_priority->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_submissionDateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_submissionDate->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_startDateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_startDate->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_completionDateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_completionDate->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_stepCountLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_stepCount->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_failedStepsLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_failedSteps->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_successfullStepsLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_successfullSteps->setGeometry(x0, y0, x0 + w, y0 + h);

	x0 = left;

	y0 -= h + dy;

	m_dependenciesLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

	x0 += lw + dx;

	m_dependencies->setGeometry(x0, y0 - 3 * h, x0 + w, y0 + h);

}

//------------------------------------------------------------------------------

void TaskStatusPage::Data::clearFields()

{

	m_taskStatus->setText("");

	m_taskId->setText("");

	m_cmdLine->setText("");

	m_server->setText("");

	m_byUser->setText("");

	m_onMachine->setText("");

	m_priority->setText("");

	m_submissionDate->setText("");

	m_startDate->setText("");

	m_completionDate->setText("");

	m_stepCount->setText("");

	m_failedSteps->setText("");

	m_successfullSteps->setText("");

	m_dependencies->clearAll();

}

//==============================================================================

TaskStatusPage::TaskStatusPage(TWidget *parent)

	: TabPage(parent, "Tasks")

{

	m_data = new Data(this);

}

//------------------------------------------------------------------------------

TaskStatusPage::~TaskStatusPage()

{

}

//------------------------------------------------------------------------------

void TaskStatusPage::configureNotify(const TDimension &size)

{

	m_data->configureNotify(size);

}

//------------------------------------------------------------------------------

void TaskStatusPage::rightButtonDown(const TMouseEvent &e)

{

}

//------------------------------------------------------------------------------

void TaskStatusPage::onActivate()

{

	if (m_data->m_tree && m_data->m_tree->getItemCount() < 1) {

		TaskTreeItemRoot *root = new TaskTreeItemRoot();

		root->setIsLeaf(false);

		m_data->m_tree->clearItems();

		m_data->m_tree->addItem(root);

	}

	m_data->m_tree->update();

	invalidate();

}

//------------------------------------------------------------------------------

void TaskStatusPage::onDeactivate()

{

}

//------------------------------------------------------------------------------

void TaskStatusPage::showTaskInfo(const string &id)

{

	TFarmController *controller = Application::instance()->getController();

	try {

		TFarmTask task;

		controller->queryTaskInfo(id, task);

		if (task != m_data->m_currTask) {

			m_data->m_currTask = task;

			m_data->showTaskInfo(task);

		}

	} catch (TException &e) {

		TMessage::error(toString(e.getMessage()));

	}

}

//------------------------------------------------------------------------------

void TaskStatusPage::update()

{

	m_data->m_tree->update();

	string id = "";

	TaskTreeItem *item = dynamic_cast<tasktreeitem *="">(m_data->m_tree->getSelectedItem());</tasktreeitem>

	if (item)

		id = item->getId();

	if (id != "")

		showTaskInfo(id);

	else

		m_data->clearFields();

	invalidate();

}

//------------------------------------------------------------------------------