#include "InstallerMain.h"

#include "InstallerUtil.h"

#include "PerformInstall.h"

#include "CCriticalSection.h"

#define WMU_INSTALLER_DONE		WM_USER+2

#define PBAR_RANGE_HIGH			100

#define PBAR_RANGE_LOW			0

ICopyMethod *g_pCopyMethod = NULL;

HANDLE g_hCopyThread = NULL;

copy_thread_args_t g_thread_args = {NULL, NULL, NULL, false, false};

CCriticalSection g_update_window;

class TrackProgress : public ICopyProgress

{

public:

	void Initialize(HWND hTextBar, HWND hCurBar, HWND hTotalBar, size_t total_size)

	{

		m_hTextBar = hTextBar;

		m_hCurBar = hCurBar;

		m_hTotalBar = hTotalBar;

		m_TotalSize = total_size;

		m_TotalDone = 0;

		RedrawProgressBars(0.0, 0.0);

	}

	void Finished()

	{

		RedrawProgressBars(100.0, 100.0);

	}

public:

	void StartingNewFile(const TCHAR *filename)

	{

		TCHAR buffer[255];

		if (g_update_window.TryEnter())

		{

			UTIL_Format(buffer, sizeof(buffer) / sizeof(TCHAR), _T("Copying: %s"), filename);

			SendMessage(m_hTextBar, WM_SETTEXT, 0, (LPARAM)buffer);

			UpdateWindow(m_hTextBar);

			g_update_window.Leave();

		}

	}

	void UpdateProgress(size_t bytes, size_t total_bytes)

	{

		float fCur = (float)bytes / (float)total_bytes;

		float fTotal = ((float)m_TotalDone + (float)bytes) / (float)m_TotalSize;

		RedrawProgressBars(fCur, fTotal);

	}

	void FileDone(size_t total_size)

	{

		m_TotalDone += total_size;

		RedrawProgressBars(0.0, (float)m_TotalDone / (float)m_TotalSize);

	}

private:

	void RedrawProgressBar(HWND hBar, float fPerc)

	{

		/* Get a percentage point in the range */

		float fPointInRange = (float)(PBAR_RANGE_HIGH - PBAR_RANGE_LOW) * fPerc;

		int iPointInRange = (int)fPointInRange;

		/* Scale it */

		iPointInRange += PBAR_RANGE_LOW;

		if (g_update_window.TryEnter())

		{

			SendMessage(hBar,

				PBM_SETPOS,

				iPointInRange,

				0);

			g_update_window.Leave();

		}

	}

	void RedrawProgressBars(float fCurrent, float fTotal)

	{

		RedrawProgressBar(m_hCurBar, fCurrent);

		RedrawProgressBar(m_hTotalBar, fTotal);

	}

private:

	size_t m_TotalSize;

	size_t m_TotalDone;

	HWND m_hTextBar;

	HWND m_hCurBar;

	HWND m_hTotalBar;

} s_ProgressTracker;

void CancelPerformInstall()

{

	delete g_thread_args.pFileList;

	g_thread_args.pFileList = NULL;

}

void SetInstallMethod(ICopyMethod *pCopyMethod)

{

	g_pCopyMethod = pCopyMethod;

}

bool CopyStructureRecursively(ICopyMethod *pCopyMethod,

							  CFileList *pFileList,

							  const TCHAR *basepath,

							  const TCHAR *local_path,

							  TCHAR *errbuf,

							  size_t maxchars)

{

	TCHAR file_path[MAX_PATH];

	const TCHAR *file;

	CFileList *pSubList;

	if (!pCopyMethod->SetCurrentFolder(local_path, errbuf, maxchars))

	{

		return false;

	}

	/* Copy files */

	while ((file = pFileList->PeekCurrentFile()) != NULL)

	{

		if (local_path == NULL)

		{

			UTIL_PathFormat(file_path,

				sizeof(file_path) / sizeof(TCHAR),

				_T("%s\\%s"),

				basepath,

				file);

		}

		else

		{

			UTIL_PathFormat(file_path,

				sizeof(file_path) / sizeof(TCHAR), 

				_T("%s\\%s\\%s"),

				basepath,

				local_path,

				file);

		}

		if (!pCopyMethod->SendFile(file_path, errbuf, maxchars))

		{

			return false;

		}

		pFileList->PopCurrentFile();

	}

	/* Now copy folders */

	while ((pSubList = pFileList->PeekCurrentFolder()) != NULL)

	{

		if (g_thread_args.m_bIsUpgrade)

		{

			/* :TODO: put this somewhere else because it technically 

			 * means the progress bars get calculated wrong 

			 */

			if (tstrcasecmp(pSubList->GetFolderName(), _T("cfg")) == 0

				|| tstrcasecmp(pSubList->GetFolderName(), _T("configs")) == 0)

			{

				pFileList->PopCurrentFolder();

				continue;

			}

		}

		/* Try creating the folder */

		if (!pCopyMethod->CreateFolder(pSubList->GetFolderName(), errbuf, maxchars))

		{

			return false;

		}

		TCHAR new_local_path[MAX_PATH];

		if (local_path == NULL)

		{

			UTIL_PathFormat(new_local_path,

				sizeof(new_local_path) / sizeof(TCHAR),

				_T("%s"),

				pSubList->GetFolderName());

		}

		else

		{

			UTIL_PathFormat(new_local_path,

				sizeof(new_local_path) / sizeof(TCHAR),

				_T("%s\\%s"),

				local_path,

				pSubList->GetFolderName());

		}

		if (!CopyStructureRecursively(pCopyMethod,

				pSubList,

				basepath, 

				new_local_path, 

				errbuf, 

				maxchars))

		{

			return false;

		}

		pFileList->PopCurrentFolder();

		/* Set the current folder again for the next operation */

		if (!pCopyMethod->SetCurrentFolder(local_path, errbuf, maxchars))

		{

			return false;

		}

	}

	return true;

}

DWORD WINAPI T_CopyFiles(LPVOID arg)

{

	bool result = 

		CopyStructureRecursively(g_thread_args.pCopyMethod,

		g_thread_args.pFileList,

		g_thread_args.basepath,

		NULL,

		g_thread_args.error,

		sizeof(g_thread_args.error) / sizeof(TCHAR));

	PostMessage(g_thread_args.hWnd, WMU_INSTALLER_DONE, result ? TRUE : FALSE, 0);

	return 0;

}

bool StartFileCopy(HWND hWnd)

{

	g_thread_args.m_bWasCancelled = false;

	g_thread_args.hWnd = hWnd;

	if ((g_hCopyThread = CreateThread(NULL, 

		0, 

		T_CopyFiles, 

		NULL, 

		0,

		NULL))

		== NULL)

	{

		MessageBox(

			hWnd,

			_T("Could not initialize copy thread."),

			_T("SourceMod Installer"),

			MB_OK|MB_ICONERROR);

		return false;

	}

	return true;

}

void StopFileCopy()

{

	g_thread_args.m_bWasCancelled = true;

	g_pCopyMethod->CancelCurrentCopy();

	if (g_hCopyThread != NULL)

	{

		g_update_window.Enter();

		WaitForSingleObject(g_hCopyThread, INFINITE);

		g_update_window.Leave();

		CloseHandle(g_hCopyThread);

		g_hCopyThread = NULL;

	}

}

bool RequestCancelInstall(HWND hWnd)

{

	StopFileCopy();

	int val = MessageBox(

		hWnd,

		_T("Are you sure you want to cancel the install?"),

		_T("SourceMod Installer"),

		MB_YESNO|MB_ICONQUESTION);

	if (val == IDYES)

	{

		return true;

	}

	if (g_thread_args.pFileList == NULL)

	{

		return false;

	}

	/* Start the thread, note our return value is opposite */

	return !StartFileCopy(hWnd);

}

bool StartInstallProcess(HWND hWnd)

{

	if (g_pCopyMethod->CheckForExistingInstall())

	{

		int val = MessageBox(

			hWnd, 

			_T("It looks like a previous SourceMod installation exists.  Select \"Yes\" to skip copying configuration files.  Select \"No\" to perform a full re-install."),

			_T("SourceMod Installer"), 

			MB_YESNO|MB_ICONQUESTION);

		if (val == 0 || val == IDYES)

		{

			g_thread_args.m_bIsUpgrade = true;

		}

		else

		{

			g_thread_args.m_bIsUpgrade = false;

		}

	}

#if 0

	TCHAR cur_path[MAX_PATH];

	if (_tgetcwd(cur_path, sizeof(cur_path)) == NULL)

	{

		MessageBox(

			hWnd,

			_T("Could not locate current directory!"),

			_T("SourceMod Installer"),

			MB_OK|MB_ICONERROR);

		return false;

	}

#endif

#if 0

	UTIL_PathFormat(source_path,

		sizeof(source_path) / sizeof(TCHAR),

		_T("%s\\files"),

		cur_path);

#else

	UTIL_PathFormat(g_thread_args.basepath,

		sizeof(g_thread_args.basepath) / sizeof(TCHAR),

		_T("C:\\real\\done\\base"));

#endif

	if (GetFileAttributes(g_thread_args.basepath) == INVALID_FILE_ATTRIBUTES)

	{

		MessageBox(

			hWnd,

			_T("Could not locate the source installation files!"),

			_T("SourceMod Installer"),

			MB_OK|MB_ICONERROR);

		return false;

	}

	delete g_thread_args.pFileList;

	g_thread_args.pFileList = CFileList::BuildFileList(_T(""), g_thread_args.basepath);

	s_ProgressTracker.Initialize(

		GetDlgItem(hWnd, IDC_PROGRESS_CURCOPY),

		GetDlgItem(hWnd, IDC_PROGRESS_CURRENT),

		GetDlgItem(hWnd, IDC_PROGRESS_TOTAL),

		(size_t)g_thread_args.pFileList->GetRecursiveSize());

	g_pCopyMethod->TrackProgress(&s_ProgressTracker);

	g_thread_args.pCopyMethod = g_pCopyMethod;

	return StartFileCopy(hWnd);

}

INT_PTR CALLBACK PerformInstallHandler(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

{

	switch (message)

	{

	case WM_INITDIALOG:

		{

			SetToGlobalPosition(hDlg);

			return (INT_PTR)TRUE;

		}

	case WM_COMMAND:

		{

			if (LOWORD(wParam) == ID_INSTALL_CANCEL

				|| LOWORD(wParam) == ID_CLOSE)

			{

				if (RequestCancelInstall(hDlg))

				{

					CancelPerformInstall();

					UpdateGlobalPosition(hDlg);

					EndDialog(hDlg, NULL);

				}

				return (INT_PTR)TRUE;

			}

			else if (LOWORD(wParam) == ID_INSTALL_START)

			{

				HWND hButton = GetDlgItem(hDlg, ID_INSTALL_START);

				EnableWindow(hButton, FALSE);

				StartInstallProcess(hDlg);

			}

			break;

		}

	case WMU_INSTALLER_DONE:

		{

			if (wParam == TRUE)

			{

				s_ProgressTracker.Finished();

				MessageBox(hDlg,

					_T("SourceMod was successfully installed!  Please visit http://www.sourcemod.net/ for documentation."),

					_T("SourceMod Installer"),

					MB_OK);

				CancelPerformInstall();

				UpdateGlobalPosition(hDlg);

				EndDialog(hDlg, NULL);

				return (INT_PTR)TRUE;

			}

			else if (!g_thread_args.m_bWasCancelled)

			{

				TCHAR buffer[500];

				UTIL_Format(buffer, 

					sizeof(buffer) / sizeof(TCHAR), 

					_T("Encountered error: %s"),

					g_thread_args.error);

				int res = MessageBox(hDlg,

					buffer,

					_T("SourceMod Installer"),

					MB_ICONERROR|MB_RETRYCANCEL);

				if (res == IDRETRY)

				{

					StartFileCopy(hDlg);

				}

				else

				{

					CancelPerformInstall();

					UpdateGlobalPosition(hDlg);

					EndDialog(hDlg, NULL);

					return (INT_PTR)TRUE;

				}

			}

			break;

		}

	}

	return (INT_PTR)FALSE;

}

void *DisplayPerformInstall(HWND hWnd)

{

	INT_PTR val;

	if ((val = DialogBox(

		g_hInstance, 

		MAKEINTRESOURCE(IDD_PERFORM_INSTALL),

		hWnd,

		PerformInstallHandler)) == -1)

	{

		return NULL;

	}

	return (void *)val;

}