#include "tconvert.h"

#include "tfarmcontroller.h"

#include "ttcpip.h"

#include "texception.h"

#include "tfarmproxy.h"

#include "tfilepath_io.h"

namespace

{

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

class Controller : public TFarmController, public TFarmProxy

{

public:

	Controller(const QString &hostName, const QString &addr, int port)

		: TFarmProxy(hostName, addr, port) {}

	// TFarmController interface implementation

	QString addTask(const TFarmTask &task, bool suspended);

	void removeTask(const QString &id);

	void suspendTask(const QString &id);

	void activateTask(const QString &id);

	void restartTask(const QString &id);

	void getTasks(vector<qstring> &tasks);</qstring>

	void getTasks(const QString &parentId, vector<qstring> &tasks);</qstring>

	void getTasks(const QString &parentId, vector<taskshortinfo> &tasks);</taskshortinfo>

	void queryTaskInfo(const QString &id, TFarmTask &task);

	void queryTaskShortInfo(

		const QString &id,

		QString &parentId,

		QString &name,

		TaskState &status);

	void attachServer(const QString &name, const QString &addr, int port);

	void detachServer(const QString &name, const QString &addr, int port);

	void taskSubmissionError(const QString &taskId, int errCode);

	void taskProgress(

		const QString &taskId,

		int step,

		int stepCount,

		int frameNumber,

		FrameState state);

	void taskCompleted(const QString &taskId, int exitCode);

	// fills the servers vector with the names of the servers

	void getServers(vector<serveridentity> &servers);</serveridentity>

	// returns the state of the server whose id has been specified

	ServerState queryServerState2(const QString &id);

	// fills info with the infoes about the server whose id has been specified

	void queryServerInfo(const QString &id, ServerInfo &info);

	// activates the server whose id has been specified

	void activateServer(const QString &id);

	// deactivates the server whose id has been specified

	// once deactivated, a server is not available for task rendering

	void deactivateServer(const QString &id, bool completeRunningTasks = true);

};

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

QString Controller::addTask(const TFarmTask &task, bool suspended)

{

	int i, count = task.getTaskCount();

	QString data("addTask@TFarmTask_2");

	data += ",";

	data += task.m_name;

	data += ",";

	data += task.getCommandLine(true);

	data += ",";

	data += task.m_user;

	data += ",";

	data += task.m_hostName;

	data += ",";

	data += QString::number(suspended);

	data += ",";

	data += QString::number(task.m_stepCount);

	data += ",";

	data += QString::number(task.m_priority);

	data += ",";

	data += QString::number(task.m_platform);

	data += ",";

	int depCount = task.m_dependencies->getTaskCount();

	data += QString::number(depCount);

	i = 0;

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

		data += ",";

		data += task.m_dependencies->getTaskId(i);

	}

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

		TFarmTask &tt = const_cast<tfarmtask &="">(task);</tfarmtask>

		TFarmTask *subtask = tt.getTask(i);

		data += ",";

		data += subtask->m_name;

		data += ",";

		data += subtask->getCommandLine(true);

		data += ",";

		data += subtask->m_user;

		data += ",";

		data += subtask->m_hostName;

		data += ",";

		data += QString::number(subtask->m_stepCount);

		data += ",";

		data += QString::number(subtask->m_priority);

	}

	QString reply = sendToStub(data);

	//MessageBox(NULL, data.c_str(), "ciao", 0);

	return reply;

}

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

void Controller::removeTask(const QString &id)

{

	QString data("removeTask");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

}

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

void Controller::suspendTask(const QString &id)

{

	QString data("suspendTask");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

}

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

void Controller::activateTask(const QString &id)

{

	QString data("activateTask");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

}

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

void Controller::restartTask(const QString &id)

{

	QString data("restartTask");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

}

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

void Controller::getTasks(vector<qstring> &tasks)</qstring>

{

	QString data("getTasks@vector");

	QString reply = sendToStub(data);

	// la stringa restituita contiene le informazioni desiderate separate da ","

	vector<qstring> argv;</qstring>

	extractArgs(reply, argv);

	tasks.clear();

	std::vector<qstring>::iterator it = argv.begin();</qstring>

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

		tasks.push_back(*it);

}

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

void Controller::getTasks(const QString &parentId, vector<qstring> &tasks)</qstring>

{

	QString data("getTasks@string@vector");

	data += ",";

	data += parentId;

	QString reply = sendToStub(data);

	// la stringa restituita contiene le informazioni deiderate separate da ","

	vector<qstring> argv;</qstring>

	extractArgs(reply, argv);

	tasks.clear();

	std::vector<qstring>::iterator it = argv.begin();</qstring>

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

		tasks.push_back(*it);

}

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

void Controller::getTasks(const QString &parentId, vector<taskshortinfo> &tasks)</taskshortinfo>

{

	QString data("getTasks@string@vector$TaskShortInfo");

	data += ",";

	data += parentId;

	QString reply = sendToStub(data);

	// la stringa restituita contiene le informazioni desiderate separate da ","

	vector<qstring> argv;</qstring>

	extractArgs(reply, argv);

	tasks.clear();

	std::vector<qstring>::iterator it = argv.begin();</qstring>

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

		QString id = *it++;

		QString name = *it++;

		TaskState status;

		status = (TaskState)(*it).toInt();

		tasks.push_back(TaskShortInfo(id, name, status));

	}

}

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

void Controller::queryTaskInfo(const QString &id, TFarmTask &task)

{

	QString data("queryTaskInfo_2");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

	// la stringa restituita contiene le informazioni desiderate separate da ","

	vector<qstring> argv;</qstring>

	int count = extractArgs(reply, argv);

	if (reply == "")

		return;

	assert(argv.size() > 15);

	int incr = 0;

	task.m_name = argv[incr++];

	task.parseCommandLine(argv[incr++]);

	task.m_priority = argv[incr++].toInt();

	task.m_user = argv[incr++];

	task.m_hostName = argv[incr++];

	task.m_id = argv[incr++];

	task.m_parentId = argv[incr++];

	task.m_status = (TaskState)argv[incr++].toInt();

	task.m_server = argv[incr++];

	task.m_submissionDate = QDateTime::fromString(argv[incr++]);

	task.m_startDate = QDateTime::fromString(argv[incr++]);

	task.m_completionDate = QDateTime::fromString(argv[incr++]);

	task.m_successfullSteps = argv[incr++].toInt();

	task.m_failedSteps = argv[incr++].toInt();

	task.m_stepCount = argv[incr++].toInt();

	if (incr < count) {

		task.m_platform = (TFarmPlatform)argv[incr++].toInt();

		int depCount = 0;

		depCount = argv[incr++].toInt();

		if (depCount > 0) {

			task.m_dependencies = new TFarmTask::Dependencies;

			for (int i = 0; i < depCount; ++i)

				task.m_dependencies->add(argv[incr++]);

		}

	}

}

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

void Controller::queryTaskShortInfo(

	const QString &id, QString &parentId,

	QString &name, TaskState &status)

{

	QString data("queryTaskShortInfo");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

	// la stringa restituita contiene le informazioni desiderate separate da ","

	vector<qstring> argv;</qstring>

	extractArgs(reply, argv);

	assert(argv.size() == 3);

	parentId = argv[0];

	name = argv[1];

	status = (TaskState)argv[2].toInt();

}

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

void Controller::attachServer(const QString &name, const QString &addr, int port)

{

	QString data("attachServer");

	data += ",";

	data += name;

	data += ",";

	data += addr;

	data += ",";

	data += QString::number(port);

	QString reply = sendToStub(data);

}

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

void Controller::detachServer(const QString &name, const QString &addr, int port)

{

	QString data("detachServer");

	data += ",";

	data += name;

	data += ",";

	data += addr;

	data += ",";

	data += QString::number(port);

	QString reply = sendToStub(data);

}

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

void Controller::taskSubmissionError(const QString &taskId, int errCode)

{

	QString data("taskSubmissionError");

	data += ",";

	data += taskId;

	data += ",";

	data += QString::number(errCode);

	QString reply = sendToStub(data);

}

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

void Controller::taskProgress(

	const QString &taskId,

	int step,

	int stepCount,

	int frameNumber,

	FrameState state)

{

	QString data("taskProgress");

	data += ",";

	data += taskId;

	data += ",";

	data += QString::number(step);

	data += ",";

	data += QString::number(stepCount);

	data += ",";

	data += QString::number(frameNumber);

	data += ",";

	data += QString::number(state);

	QString reply = sendToStub(data);

}

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

void Controller::taskCompleted(const QString &taskId, int exitCode)

{

	QString data("taskCompleted");

	data += ",";

	data += taskId;

	data += ",";

	data += QString::number(exitCode);

	QString reply = sendToStub(data);

}

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

void Controller::getServers(vector<serveridentity> &servers)</serveridentity>

{

	QString data("getServers");

	QString reply = sendToStub(data);

	// la stringa restituita contiene le informazioni desiderate separate da ","

	vector<qstring> argv;</qstring>

	extractArgs(reply, argv);

	servers.clear();

	std::vector<qstring>::iterator it = argv.begin();</qstring>

	for (; it != argv.end(); it += 2)

		servers.push_back(ServerIdentity(*it, *(it + 1)));

}

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

ServerState Controller::queryServerState2(const QString &name)

{

	QString data("queryServerState2");

	data += ",";

	data += name;

	QString reply = sendToStub(data);

	ServerState serverState = (ServerState)reply.toInt();

	return serverState;

}

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

void Controller::queryServerInfo(const QString &id, ServerInfo &info)

{

	QString data("queryServerInfo");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

	if (reply != "") {

		// la stringa restituita contiene le informazioni desiderate separate da ","

		vector<qstring> argv;</qstring>

		extractArgs(reply, argv);

		info.m_name = argv[0];

		info.m_ipAddress = argv[1];

		info.m_portNumber = argv[2];

		info.m_state = (ServerState)argv[3].toInt();

		info.m_platform = argv[4];

		int cpuCount, totPhysMem, totVirtMem, availPhysMem, availVirtMem;

		cpuCount = argv[5].toInt();

		totPhysMem = argv[6].toInt();

		totVirtMem = argv[7].toInt();

		availPhysMem = argv[8].toInt();

		availVirtMem = argv[9].toInt();

		info.m_currentTaskId = argv[10];

		info.m_cpuCount = cpuCount;

		info.m_totPhysMem = totPhysMem;

		info.m_totVirtMem = totVirtMem;

		info.m_availPhysMem = availPhysMem;

		info.m_availVirtMem = availVirtMem;

	}

}

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

void Controller::activateServer(const QString &id)

{

	QString data("activateServer");

	data += ",";

	data += id;

	QString reply = sendToStub(data);

}

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

void Controller::deactivateServer(const QString &id, bool completeRunningTasks)

{

	QString data("deactivateServer");

	data += ",";

	data += id;

	data += ",";

	data += QString::number(completeRunningTasks);

	QString reply = sendToStub(data);

}

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

} // anonymous namespace

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

TFarmControllerFactory::TFarmControllerFactory()

{

}

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

int TFarmControllerFactory::create(const ControllerData &data,

								   TFarmController **controller)

{

	*controller = new Controller(data.m_hostName, data.m_ipAddress, data.m_port);

	return 0;

}

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

int TFarmControllerFactory::create(const QString &hostname, int port, TFarmController **controller)

{

	*controller = new Controller(hostname, "", port);

	return 0;

}

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

void loadControllerData(const TFilePath &fp, ControllerData &data)

{

	Tifstream is(fp);

	if (!is || !is.good()) {

		throw TException(

			L"Unable to get Farm Controller Data (looking for '" + fp.getWideString() + L"')");

	}

	while (!is.eof()) {

		char line[1024];

		is.getline(line, 1024);

		if (line[0] != '#' && QString(line) != "") {

			istrstream iss(line);

			char hostName[512];

			char ipAddr[80];

			int port;

			iss >> hostName >> ipAddr >> port;

			data.m_hostName = hostName;

			data.m_ipAddress = ipAddr;

			data.m_port = port;

			break;

		}

	}

}