#include "serverstatuspage.h"

#include "tfarmcontroller.h"

#include "application.h"

#include "textlist.h"

#include "tw/mainshell.h"

#include "tw/textfield.h"

#include "tw/event.h"

#include "tw/message.h"

#include <vector></vector>

#include <set></set>

using namespace std;

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

class ServerList : public TTextList

{

public:

	ServerList(TWidget *parent);

	void rightButtonDown(const TMouseEvent &e);

	void onDeactivate();

	void onActivate();

	TPopupMenuItem *m_activationItem;

	TPopupMenu *m_popupMenu;

};

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

ServerList::ServerList(TWidget *parent)

	: TTextList(parent, "servers")

{

	m_popupMenu = new TPopupMenu(this);

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

	TGuiCommand("deactivate").setAction(new TCommandAction<serverlist>(this, onDeactivate));</serverlist>

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

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

	TGuiCommand("activate").setAction(new TCommandAction<serverlist>(this, onActivate));</serverlist>

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

}

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

void ServerList::rightButtonDown(const TMouseEvent &e)

{

	leftButtonDown(e);

	TTextListItem *item = getSelectedItem(0);

	if (item) {

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

		ServerState state;

		try {

			state = controller->queryServerState2(item->getId());

		} catch (TException &e) {

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

			return;

		}

		if (state != Offline) {

			TGuiCommand("activate").disable();

			TGuiCommand("deactivate").enable();

		} else {

			TGuiCommand("activate").enable();

			TGuiCommand("deactivate").disable();

		}

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

		m_popupMenu->popup(pos);

	}

}

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

void ServerList::onDeactivate()

{

	TTextListItem *item = getSelectedItem(0);

	if (item) {

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

		try {

			controller->deactivateServer(item->getId());

		} catch (TException &e) {

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

		}

	}

}

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

void ServerList::onActivate()

{

	TTextListItem *item = getSelectedItem(0);

	if (item) {

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

		try {

			controller->activateServer(item->getId());

		} catch (TException &e) {

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

		}

	}

}

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

class ServerStatusPage::Data

{

public:

	Data(ServerStatusPage *parent)

	{

		m_serverList = new ServerList(parent);

		m_serverList->setSelAction(new TTextListAction<data>(</data>

			this, &Data::onServerSelection));

		m_name = new TTextField(parent, "name");

		m_ipAddress = new TTextField(parent, "ipAddress");

		m_portNumber = new TTextField(parent, "portNumber");

		m_tasks = new TTextField(parent, "tasks");

		m_state = new TTextField(parent, "state");

		m_cpuCount = new TTextField(parent, "cpuCount");

		m_totPhysMem = new TTextField(parent, "totalPhysMemory");

		m_nameLbl = new TLabel(parent, "name");

		m_ipAddressLbl = new TLabel(parent, "ipAddress");

		m_portNumberLbl = new TLabel(parent, "portNumber");

		m_tasksLbl = new TLabel(parent, "tasks");

		m_stateLbl = new TLabel(parent, "state");

		m_cpuCountLbl = new TLabel(parent, "cpuCount");

		m_totPhysMemLbl = new TLabel(parent, "totalPhysMemory");

	}

	~Data() {}

	void onServerSelection(int index)

	{

		TTextListItem *item = m_serverList->getSelectedItem(0);

		if (item) {

			showServerInfo(item->getId());

		}

	}

	void showServerInfo(const string &id)

	{

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

		ServerInfo info;

		try {

			controller->queryServerInfo(id, info);

		} catch (TException &e) {

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

		}

		switch (info.m_state) {

		case Ready:

			m_state->setText("Ready");

			break;

		case Busy:

			m_state->setText("Busy");

			break;

		case NotResponding:

			m_state->setText("Not Responding");

			break;

		case Down:

			m_state->setText("Down");

			break;

		case Offline:

			m_state->setText("Offline");

			break;

		case ServerUnknown:

			m_state->setText("");

			m_name->setText("");

			m_ipAddress->setText("");

			m_portNumber->setText("");

			m_tasks->setText("");

			m_cpuCount->setText("");

			m_totPhysMem->setText("");

			return;

		}

		m_name->setText(info.m_name);

		m_ipAddress->setText(info.m_ipAddress);

		m_portNumber->setText(info.m_portNumber);

		if (info.m_currentTaskId == "")

			m_tasks->setText("");

		else {

			TFarmTask task;

			try {

				controller->queryTaskInfo(info.m_currentTaskId, task);

				m_tasks->setText("<" + task.m_id + "> " + task.m_name);

			} catch (TException &e) {

				m_tasks->setText("");

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

			}

		}

		if (info.m_state != Down) {

			m_cpuCount->setText(toString(info.m_cpuCount));

			m_totPhysMem->setText(toString((long)info.m_totPhysMem));

		} else {

			m_cpuCount->setText("");

			m_totPhysMem->setText("");

		}

	}

	void addServer(const ServerIdentity &sid)

	{

		m_serverList->addItem(new TTextListItem(sid.m_id, sid.m_name));

	}

	void 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

		m_serverList->setGeometry(0, 0, leftSize /*100*/, size.ly - 1);

		// ora la parte a dx

		x0 = left;

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

		x0 += lw + dx;

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

		x0 = left;

		y0 -= h + dy;

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

		x0 += lw + dx;

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

		x0 = left;

		y0 -= h + dy;

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

		x0 += lw + dx;

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

		x0 = left;

		y0 -= h + dy;

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

		x0 += lw + dx;

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

		x0 = left;

		y0 -= h + dy;

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

		x0 += lw + dx;

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

		x0 = left;

		y0 -= h + dy;

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

		x0 += lw + dx;

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

		x0 = left;

		y0 -= h + dy;

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

		x0 += lw + dx;

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

	}

	TTextList *m_serverList;

	TTextField *m_name, *m_ipAddress, *m_portNumber, *m_tasks,

		*m_state, *m_cpuCount, *m_totPhysMem;

	TLabel *m_nameLbl, *m_ipAddressLbl, *m_portNumberLbl, *m_tasksLbl,

		*m_stateLbl, *m_cpuCountLbl, *m_totPhysMemLbl;

};

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

void ServerStatusPage::onActivate()

{

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

	try {

		vector<serveridentity> servers;</serveridentity>

		controller->getServers(servers);

		vector<serveridentity>::iterator it = servers.begin();</serveridentity>

		for (; it != servers.end(); ++it)

			m_data->addServer(*it);

	} catch (TException &e) {

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

	}

}

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

void ServerStatusPage::onDeactivate()

{

}

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

ServerStatusPage::ServerStatusPage(TWidget *parent)

	: TabPage(parent, "Servers")

{

	m_data = new Data(this);

}

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

ServerStatusPage::~ServerStatusPage()

{

}

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

void ServerStatusPage::configureNotify(const TDimension &size)

{

	m_data->configureNotify(size);

}

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

void ServerStatusPage::update()

{

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

	vector<serveridentity> servers;</serveridentity>

	try {

		controller->getServers(servers);

	} catch (TException &e) {

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

		return;

	}

	vector<serveridentity>::iterator it = servers.begin();</serveridentity>

	vector<serveridentity> newServers;</serveridentity>

	std::set<int> oldServers;</int>

	TTextList *sl = m_data->m_serverList;

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

		int index;

		if ((index = sl->itemToIndex(it->m_id)) == -1)

			newServers.push_back(*it);

		else

			oldServers.insert(index);

	}

	int i = 0, count = sl->getItemCount();

	for (; i < count; ++i)

		if (oldServers.find(i) == oldServers.end()) {

			string itemId = sl->getItem(i)->getId();

			/*      

      if(sl->isSelected(itemId))

        sl->select((i+1)%sl->getItemCount(), true);

        */

			sl->removeItem(itemId);

		}

	it = newServers.begin();

	for (; it != newServers.end(); it++)

		sl->addItem(new TTextListItem(it->m_id, it->m_name));

	TTextListItem *item = m_data->m_serverList->getSelectedItem(0);

	if (item)

		m_data->showServerInfo(item->getId());

	invalidate();

}