/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsTypes.h"
#include "SceneViewer.h"
#include "SceneSync.h"

#include "../MaxMain/plMaxCFGFile.h"

#include "../MaxMain/resource.h"

// For ShellExecute
#include <shellapi.h>

static const char *kDebugClientExe = "plClient_dbg.exe";
static const char *kReleaseClientExe = "plClient.exe";

static const char *kSemaphoreName = "PlasmaSceneViewer";
static const char *kPipeName = "\\\\.\\pipe\\PlasmaSceneViewer";

SceneViewer::SceneViewer() : fhDlg(NULL)
{
	// Get the plugin CFG dir
	const char *plugFile = plMaxConfig::GetPluginIni();

	fUpdate = (GetPrivateProfileInt("SceneViewer", "Update", 1, plugFile) != 0);
	fUpdateFreq = GetPrivateProfileInt("SceneViewer", "UpdateFreq", 500, plugFile);
	fLoadOld = (GetPrivateProfileInt("SceneViewer", "LoadOld", 0, plugFile) != 0);
	fReleaseExe = (GetPrivateProfileInt("SceneViewer", "ReleaseExe", 1, plugFile) != 0);
}

SceneViewer::~SceneViewer()
{
	// Make sure the client is shut down
	ISetRunning(false);

	// Get the plugin CFG dir
	const char *plugFile = plMaxConfig::GetPluginIni();

	char buf[20];
	WritePrivateProfileString("SceneViewer", "Update", fUpdate ? "1" : "0", plugFile);
	WritePrivateProfileString("SceneViewer", "UpdateFreq", itoa(fUpdateFreq, buf, 10), plugFile);
	WritePrivateProfileString("SceneViewer", "LoadOld", fLoadOld ? "1" : "0", plugFile);
	WritePrivateProfileString("SceneViewer", "ReleaseExe", fReleaseExe ? "1" : "0", plugFile);
}

SceneViewer &SceneViewer::Instance()
{
	static SceneViewer theInstance;
	return theInstance;
}

void SceneViewer::Show()
{
	// If the dialog is already created, make sure it is visible
	if (fhDlg)
	{
		if (IsIconic(fhDlg))
			ShowWindow(fhDlg, SW_RESTORE);
	}
	else
	{
		fhDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_SCENEVIEWER), GetCOREInterface()->GetMAXHWnd(), ForwardDlgProc);
	}
}

// Toggles the client and SceneSync
bool SceneViewer::IToggleRunning()
{
	fRunning = !fRunning;
	return ISetRunning(fRunning);
}

// Starts/Stops the client and SceneSync
bool SceneViewer::ISetRunning(bool running)
{
	if (running)
	{
		// The client actually is running, hmmm
		if (SceneSync::Instance().IsClientRunning())
			return true;

		// If we're not loading old data, or we are but it's not there, try to create some.
		if (!fLoadOld || !SceneSync::Instance().CanLoadOldResMgr())
		{
			// If creation fails, fail
			if (!SceneSync::Instance().CreateClientData())
				return false;
		}

		char path[MAX_PATH];
		SceneSync::Instance().GetOutputDir(path);
		strcat(path, "dat\\");

		// Start the client
		char *options = TRACKED_NEW char[strlen(path)+2+strlen(kSemaphoreName)+strlen(kPipeName)+6];
		sprintf(options, "-s %s %s \"%s\"", kSemaphoreName, kPipeName, path);

		int ret = (int)ShellExecute(NULL,
									"open",
									fReleaseExe ? kReleaseClientExe : kDebugClientExe,
									options,
									plMaxConfig::GetClientPath(),
									SW_SHOWNORMAL);
		delete [] options;

		// Client start failed
		if (ret < 32)
			return false;

		// Start client sync
		SceneSync::Instance().SetUpdateFreq(fUpdateFreq);
		SceneSync::Instance().BeginClientSync(kSemaphoreName, kPipeName);

		return true;
	}
	else
	{
		if (SceneSync::Instance().IsClientRunning())
			SceneSync::Instance().EndClientSync(false);
		return true;
	}
}

BOOL SceneViewer::ForwardDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return Instance().DlgProc(hDlg, msg, wParam, lParam);
}

BOOL SceneViewer::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_INITDIALOG:
		{
			fhDlg = hDlg;

			// Set the exe to use
			HWND hExeCombo = GetDlgItem(hDlg, IDC_EXE);
			ComboBox_AddString(hExeCombo, "Release");
			ComboBox_AddString(hExeCombo, "Debug");
			ComboBox_SetCurSel(hExeCombo, fReleaseExe ? 0 : 1);

			// Set the client path
			const char *path = plMaxConfig::GetClientPath(false, true);
			ICustEdit *edit = GetICustEdit(GetDlgItem(hDlg, IDC_CLIENT_PATH));
			edit->SetText((char*)path);

			// Set the "Load old data" checkbox
			HWND hLoadOld = GetDlgItem(hDlg, IDC_REUSE_DATA);
			Button_SetCheck(hLoadOld, fLoadOld ? BST_CHECKED : BST_UNCHECKED);
			Button_Enable(hLoadOld, SceneSync::Instance().CanLoadOldResMgr());

			// Set the update controls
			float val = float(fUpdateFreq) / 1000.f;
			ISpinnerControl *spin = SetupFloatSpinner(hDlg, IDC_SPINNER, IDC_EDIT, 0.1, 1.f, val);
			spin->Enable(fUpdate);
			CheckDlgButton(hDlg, IDC_UPDATE, fUpdate ? BST_CHECKED : BST_UNCHECKED);

			IEnableSetupControls(!SceneSync::Instance().IsClientRunning());
		}
		return TRUE;

	case WM_COMMAND:
		// Start/Stop SceneViewer
		if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_START)
		{
			IToggleRunning();
			IEnableSetupControls(!SceneSync::Instance().IsClientRunning());
			return TRUE;
		}
		// Close dialog
		else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
		{
			DestroyWindow(hDlg);
			fhDlg = NULL;
			return TRUE;
		}
		// Browse for directory
		else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_DIR)
		{
			const char *path = plMaxConfig::GetClientPath(true);
			if (path)
			{
				ICustEdit *edit = GetICustEdit(GetDlgItem(hDlg, IDC_CLIENT_PATH));
				edit->SetText((char*)path);
			}

			return TRUE;
		}
		// "Load old data" selection changed
		else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_REUSE_DATA)
		{
			fLoadOld = (Button_GetCheck((HWND)lParam) == BST_CHECKED);
			return TRUE;
		}
		// Release/Debug exe selection changed
		else if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_EXE)
		{
			int sel = ComboBox_GetCurSel((HWND)lParam);
			fReleaseExe = (sel == 0);
			return TRUE;
		}
		else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_UPDATE)
		{
			fUpdate = (SendMessage((HWND)lParam, BM_GETCHECK, 0, 0) == BST_CHECKED);

			ISpinnerControl *spin = GetISpinner(GetDlgItem(hDlg, IDC_SPINNER));
			spin->Enable(fUpdate);
			ReleaseISpinner(spin);

			// If update was turned on, send out an update message so any dirty objects
			// will be reconverted right away
			if (fUpdate)
				SceneSync::Instance().SetUpdateFreq(fUpdateFreq);

			return TRUE;
		}
		break;
		
	// Update frequency changed
	case CC_SPINNER_CHANGE:
		if (LOWORD(wParam) == IDC_SPINNER)
		{
			ISpinnerControl *spin = (ISpinnerControl*)lParam;
			float val = spin->GetFVal();
			fUpdateFreq = int(val*1000.f);
			SceneSync::Instance().SetUpdateFreq(fUpdateFreq);
		}
		return TRUE;

	// Type in directory
	case WM_CUSTEDIT_ENTER:
		if (wParam == IDC_CLIENT_PATH)
		{
			ICustEdit *edit = GetICustEdit((HWND)lParam);

			char path[MAX_PATH];
			edit->GetText(path, sizeof(path));
			plMaxConfig::SetClientPath(path);
		}
		return TRUE;
	}

	return FALSE;
}

void SceneViewer::IEnableSetupControls(bool enable)
{
	ICustEdit *edit = GetICustEdit(GetDlgItem(fhDlg, IDC_CLIENT_PATH));
	edit->Enable(enable);

	EnableWindow(GetDlgItem(fhDlg, IDC_DIR), enable);
	EnableWindow(GetDlgItem(fhDlg, IDC_EXE), enable);
	EnableWindow(GetDlgItem(fhDlg, IDC_REUSE_DATA), enable);

	SetWindowText(GetDlgItem(fhDlg, IDC_START), enable ? "Start" : "Stop");
}