#include "casmsubmitpage.h"
#include "tfilepath.h"
#include "tconvert.h"
#include "tsystem.h"

#include "tw/mainshell.h"
#include "tw/textfield.h"
#include "tw/label.h"
#include "tw/optionmenu.h"
#include "tw/button.h"
#include "tw/checkbox.h"

#include "filebrowserpopup.h"
#include "casmconfigpanel.h"
#include "casmfileinfo.h"
#include "tfarmcontroller.h"
#include "application.h"
#include "util.h"

#include "tw/message.h"

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

class CasmSubmitPage::Data
{
public:
	Data(CasmSubmitPage *cspage);
	~Data()
	{
		delete m_casmTask;
	}

	void configureNotify(const TDimension &size);

	void browseCasmFiles();
	void submit();
	void loadCasm(const TFilePath &fp);

	CasmSubmitPage *m_cspage;

	TLabel *m_taskNameLabel;
	TTextField *m_taskNameTextField;
	TCheckBox *m_submitAsSuspended;
	TButton *m_submit;

	TLabel *m_filepathLabel;
	TTextField *m_filepathTextField;

	TButton *m_casmBrowseBtn;

	CasmConfigPanel *m_configPanel;

	CasmTask *m_casmTask;
};

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

CasmSubmitPage::Data::Data(CasmSubmitPage *cspage)
	: m_cspage(cspage), m_casmTask(0)
{
	m_taskNameLabel = new TLabel(cspage);
	m_taskNameLabel->setText("Task Name:");

	m_submitAsSuspended = new TCheckBox(cspage, "Submit as Suspended");

	m_taskNameTextField = new TTextField(cspage);

	m_filepathLabel = new TLabel(cspage);
	m_filepathLabel->setText("File Path:");

	m_filepathTextField = new TTextField(cspage);
	m_casmBrowseBtn = new TButton(cspage);
	m_casmBrowseBtn->setTitle("...");
	tconnect(*m_casmBrowseBtn, this, &CasmSubmitPage::Data::browseCasmFiles);

	m_submit = new TButton(cspage);
	m_submit->setTitle("Submit");
	tconnect(*m_submit, this, &CasmSubmitPage::Data::submit);

	m_configPanel = new CasmConfigPanel(cspage);
}

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

void CasmSubmitPage::Data::configureNotify(const TDimension &size)
{
	int x0 = 20;
	int y = size.ly - 1 - 10;
	int x = x0;

	m_taskNameLabel->setGeometry(x, y - 15, x + 100, y);
	m_taskNameTextField->setGeometry(x + 104, y - 15, x + 250, y);
	x += 280;
	m_submitAsSuspended->setGeometry(x, y - 15, x + 120, y);
	x += 150;
	m_submit->setGeometry(x, y - 15, x + 80, y);
	x = x0;
	y -= 40;

	m_filepathLabel->setGeometry(x, y - 15, x + 100, y);
	m_filepathTextField->setGeometry(x + 104, y - 15, x + 650, y);
	m_casmBrowseBtn->setGeometry(x + 660, y - 15, x + 680, y);
	x = x0;
	y -= 40;

	m_configPanel->setGeometry(0, 0, size.lx - 1, y);
}

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

void CasmSubmitPage::Data::browseCasmFiles()
{
	static FileBrowserPopup *popup = 0;

	if (!popup) {
		vector<string> fileTypes;
		fileTypes.push_back("casm");
		popup = new FileBrowserPopup(m_cspage, fileTypes);

		popup->setOkAction(
			new TFileBrowserPopupAction<CasmSubmitPage::Data>(this, &CasmSubmitPage::Data::loadCasm));
	}

	if (!popup)
		return;

	TFilePath fp = Application::instance()->getCurrentFolder();
	if (fp != TFilePath())
		popup->setCurrentDir(fp);

	TDimension d = TMainshell::getMainshell()->getSize();
#ifdef WIN32
	HDC hdc = GetDC(0);
	d.lx = GetDeviceCaps(hdc, HORZRES);
	d.ly = GetDeviceCaps(hdc, VERTRES);
	ReleaseDC(0, hdc);
#endif

	d -= popup->getSize();
	//TDimension d = TMainshell::getMainshell()->getSize() - popup->getSize();
	popup->popup(TPoint(d.lx / 2, d.ly / 2));
	popup->setCaption("Load Casm");
}

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

void CasmSubmitPage::Data::submit()
{
	if (m_filepathTextField->getText() == toWideString("")) {
		TMessage::error("You must load a file");
		return;
	}

	CasmTask *casm = m_configPanel->getTask();

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

	string nativeCmdLine("runcasm ");
	nativeCmdLine += casm->m_casmFile;
	nativeCmdLine += " ";

	if (casm->m_setupFile != "") {
		nativeCmdLine += "-setup ";
		nativeCmdLine += casm->m_setupFile;
		nativeCmdLine += " ";
	}

	nativeCmdLine += casm->getCommandLine();

	string casmName = TFilePath(casm->m_casmFile).getName();

	int stepCount = casm->m_end - casm->m_start + 1;

	TFarmTaskGroup task(
		casmName, nativeCmdLine, TSystem::getUserName(),
		TSystem::getHostName(), stepCount);

	int ra = casm->m_start;

	for (;;) {
		CasmTask subcasm(*casm);

		string cmdLine("runcasm ");
		int rb = tmin(ra + casm->m_taskChunksize - 1, casm->m_end);

		subcasm.m_start = ra;
		subcasm.m_end = rb;

		cmdLine += subcasm.m_casmFile;
		cmdLine += " ";

		if (subcasm.m_setupFile != "") {
			cmdLine += "-setup ";
			cmdLine += subcasm.m_setupFile;
			cmdLine += " ";
		}

		cmdLine += subcasm.getCommandLine();
		cmdLine += " -nowait ";

		try {
			string name = casmName + " " + toString(ra) + "-" + toString(rb);
			stepCount = rb - ra + 1;

			task.addTask(new TFarmTask(
				name, cmdLine, TSystem::getUserName(), TSystem::getHostName(), stepCount));
		} catch (TException &e) {
			TMessage::error(toString(e.getMessage()));
		}

		if (rb == casm->m_end)
			break;
		ra = rb + 1;
	}

	try {
		controller->addTask(task, m_submitAsSuspended->isSelected());
	} catch (TException &e) {
		TMessage::error(toString(e.getMessage()));
	}
}

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

#ifdef WIN32

void DisplayStruct(LPNETRESOURCE lpnr)
{
	string info;
	if (lpnr->lpLocalName) {
		info += lpnr->lpLocalName;
		info += " = ";
	}
	info += lpnr->lpRemoteName;

	MessageBox(NULL, info.c_str(), "Connection info", 0);
}

BOOL WINAPI EnumerateFunc(LPNETRESOURCE lpnr)
{
	DWORD dwResult, dwResultEnum;
	HANDLE hEnum;
	DWORD cbBuffer = 16384;  // 16K is a good size
	DWORD cEntries = -1;	 // enumerate all possible entries
	LPNETRESOURCE lpnrLocal; // pointer to enumerated structures
	DWORD i;
	//
	// Call the WNetOpenEnum function to begin the enumeration.
	//
	dwResult = WNetOpenEnum(RESOURCE_CONNECTED /*RESOURCE_GLOBALNET*/, // all network resources
							RESOURCETYPE_ANY,						   // all resources
							0,										   // enumerate all resources
							lpnr,									   // NULL first time the function is called
							&hEnum);								   // handle to the resource

	if (dwResult != NO_ERROR) {
		//
		// Process errors with an application-defined error handler.
		//
		//NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetOpenEnum");
		return FALSE;
	}
	//
	// Call the GlobalAlloc function to allocate resources.
	//
	lpnrLocal = (LPNETRESOURCE)GlobalAlloc(GPTR, cbBuffer);

	do {
		//
		// Initialize the buffer.
		//
		ZeroMemory(lpnrLocal, cbBuffer);
		//
		// Call the WNetEnumResource function to continue
		//  the enumeration.
		//
		dwResultEnum = WNetEnumResource(hEnum,		// resource handle
										&cEntries,  // defined locally as -1
										lpnrLocal,  // LPNETRESOURCE
										&cbBuffer); // buffer size
		//
		// If the call succeeds, loop through the structures.
		//
		if (dwResultEnum == NO_ERROR) {
			for (i = 0; i < cEntries; i++) {
				// Call an application-defined function to
				//  display the contents of the NETRESOURCE structures.
				//
				DisplayStruct(&lpnrLocal[i]);

				// If the NETRESOURCE structure represents a container resource,
				//  call the EnumerateFunc function recursively.

				if (RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage & RESOURCEUSAGE_CONTAINER))
					if (!EnumerateFunc(&lpnrLocal[i]))
						return FALSE;
				//TextOut(hdc, 10, 10, "EnumerateFunc returned FALSE.", 29);
			}
		}
		// Process errors.
		//
		else if (dwResultEnum != ERROR_NO_MORE_ITEMS) {
			//NetErrorHandler(hwnd, dwResultEnum, (LPSTR)"WNetEnumResource");
			break;
		}
	}
	//
	// End do.
	//
	while (dwResultEnum != ERROR_NO_MORE_ITEMS);
	//
	// Call the GlobalFree function to free the memory.
	//
	GlobalFree((HGLOBAL)lpnrLocal);
	//
	// Call WNetCloseEnum to end the enumeration.
	//
	dwResult = WNetCloseEnum(hEnum);

	if (dwResult != NO_ERROR) {
		//
		// Process errors.
		//
		//NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetCloseEnum");
		return FALSE;
	}

	return TRUE;
}

#endif

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

void CasmSubmitPage::Data::loadCasm(const TFilePath &fp)
{
	if (!TFileStatus(fp).doesExist()) {
		string msg = toString(fp.getWideString()) + "\n";
		msg += "File not found\n";
		msg += "Please verify that the path and file name are correct";
		m_filepathTextField->setText("");
		TMessage::error(msg);
		return;
	}

	Application::instance()->setCurrentFolder(fp.getParentDir());

	string uncString = convertToUncString(fp);

	m_filepathTextField->setText(uncString);
	m_taskNameTextField->setText(TFilePath(uncString).getName());

#ifdef WIN32
	int x = uncString.find("\\", 2);
	while (x != string::npos) {
		uncString.replace(x, 1, "/", 0, 1);
		x = uncString.find("\\", x + 1);
	}
#endif

	TFilePath uncFilePath = TFilePath(uncString);
	CasmFileInfo casmFileInfo(uncFilePath);
	int start, end;
	bool interlaced;
	casmFileInfo.getFrameRange(start, end, interlaced);

	if (m_casmTask)
		delete m_casmTask;
	m_casmTask = new CasmTask;

	m_casmTask->m_casmFile = uncString;
	m_casmTask->m_start = start;
	m_casmTask->m_end = end;
	m_casmTask->m_step = 1;

	m_configPanel->setTask(m_casmTask);
}

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

CasmSubmitPage::CasmSubmitPage(TWidget *parent)
	: TabPage(parent, "SubmitCasm")
{
	m_data = new CasmSubmitPage::Data(this);
}

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

CasmSubmitPage::~CasmSubmitPage()
{
}

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

void CasmSubmitPage::configureNotify(const TDimension &size)
{
	m_data->configureNotify(size);
}

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

void CasmSubmitPage::onActivate()
{
}

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

void CasmSubmitPage::onDeactivate()
{
}