#pragma once

#include "commonresourceconstants.h"
#include "Maindialog.h"

#include <boost/enable_shared_from_this.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include "boost/thread.hpp"
#include <fstream>
#include <vector>
#include "FileSystem.h"
#include "format_string.h"
#include <atlsync.h>
#include "Progress.h"
#include "SharedHelpers.h"
#include "FileDeployer.h"
#include "ComModule.h"
#include "InfluxDbHelper.h"

class Bootstrapper : public boost::enable_shared_from_this<Bootstrapper>, public IInstallerSite
{
	boost::condition_variable done;
	boost::mutex mut;

	CHandle latestProcess;		// A shared file that contains the PID of the latest instance of this module
	const DWORD mainThreadId;

	int windowDelay;
	int cancelDelay;
	bool editMode;
	bool service;
	bool force;
	bool fullCheck;
	bool isUninstall;
	bool isFailIfNotUpToDate;
	bool debug;
	bool windowed;
	bool dontStartApp;
	bool perUser;
	bool adminInstallDetected;
	bool userCancelled;
	bool isNop;
	bool requestedInstall; // indicates that the -install command line flag was used
	bool performedNewInstall;
	bool performedUpdateInstall;
	bool performedBootstrapperUpdateAndQuit;
	time_t startTime;
	time_t userCancelledTime;
	DWORD startTickCounter;
	int stage;
	std::vector<std::string> errors;
	unsigned long reportStatGuid;

	std::string moduleVersionNumber;		// The version number of this module

	bool silentMode;
	// only used if silentMode is true, which means we don't show dialog at all
	CEvent robloxReady;
	// this mean that bootstrapper should not run anything except preDeploy
	bool noRun;
	bool waitOnStart;

	virtual std::string Type() = 0;
	virtual std::string BinaryType() { return ""; }
	std::string baseHost;
	std::string installHost;		// HTTP host for getting installation components
	std::string installVersion;		// version string of latest installer
	std::string browserTrackerId;	// passed in from website
	int exitCode;

	//will be used to track all versions of this component to do proper clean up
	std::list<std::string> prevVersions;

	int influxdbLottery;

	std::wstring prevVersionRegKey();
	std::wstring prevVersionValueKey(int index);
	void loadPrevVersions();
	void storePrevVersions();

	void postData(std::fstream &data);
	void LogMACaddress();

	void showWindowAfterDelay()
	{
		{
			boost::unique_lock<boost::mutex> lock(mut);
			if (done.timed_wait(lock, boost::get_system_time() + boost::posix_time::time_duration(0, 0, windowDelay)))
				return;
		}

		LOG_ENTRY1("Bootstrapper::showWindowAfterDelay showing window, thread id = %d", ::GetCurrentThreadId());
		if (!this->isSilentMode())
		{
			dialog->ShowWindow(CMainDialog::WindowTimeDelayShow);
		}
	}

	void showCancelAfterDelay()
	{
		{
			boost::unique_lock<boost::mutex> lock(mut);
			if (done.timed_wait(lock, boost::get_system_time() + boost::posix_time::time_duration(0, 0, cancelDelay)))
				return;
		}
		dialog->ShowCancelButton(CMainDialog::CancelTimeDelayShow);
	}

	
	void userCancel();
	void checkCancel();

	bool isIEUpToDate();
	void checkIEPrerequisit();
	void checkDirectXPrerequisit();
	bool isDirectXUpToDate();
	void checkOSPrerequisit();
	void checkCPUPrerequisit();

	void parseCmdLine();
	void run();
	void install();
	void uninstall();
	void uninstall(bool isPerUser);

	bool checkBootstrapperVersion();
	void shutdownRobloxApp(std::wstring appExeName);
	void checkDiskSpace();
	bool shutdownProgress(int& time, int pos, int max);
	void deleteVersionFolder(std::string version);

	void setLatestProcess();
	bool isLatestProcess();

	void deleteVersionsDirectoryContents();
	void forceUninstallMFCStudio();
	void forceMFCStudioCleanup();

	// If size is set to 0, size will not be included in the log.
	// Reporting eventually boils down to http requests, which will be made
	// with normal strings (not unicode strings), so this method also uses
	// normal strings to that the caller will consider and handle unicode as needed.
	void reportDurationAndSizeEvent(const char* category, const char* result, DWORD duration, DWORD size);
	void reportFinishingHelper(const char* category, const char* result);

	void ReportToInfluxDbImpl(const std::string& json);

	virtual bool EarlyInstall(bool isUninstall) { return false; }

protected:

	HINSTANCE hInstance;
	HWND launchedAppHwnd;

	boost::scoped_ptr<CMainDialog> dialog;
	boost::scoped_ptr<FileDeployer> deployer;
	CRegKey classesKey;

	//TODO move this into client part
	std::wstring robloxAppArgs;	// If empty, then don't launch RobloxApp.exe

	InfluxDb influxDb;

	Bootstrapper(HINSTANCE hInstance);

	static void dummyProgress(int pos, int max) {}
	static void createDirectory(const TCHAR* dir);

	void setStage(int s) { stage = s; }
	bool isPerUser() const { return perUser; }
	bool isDontStartApp() { return dontStartApp; }
	CMainDialog *Dialog() { return dialog.get(); }
	void setInstallVersion(std::string version) { installVersion = version; }

	std::wstring GetSelfName() const;

	virtual void initialize();
	virtual void createDialog() {} ;

	// lets make sure that this guy will be 100% client only (RCC won't run this code)
	virtual HRESULT SheduleRobloxUpdater() { return S_OK; };
	virtual HRESULT UninstallRobloxUpdater() { return S_OK; };
	// will load settings from server
	virtual void LoadSettings() {}
	virtual bool CanRunBgTask() { return true; }

	virtual void SetupInfluxDb();
	virtual std::string InfluxDbUrl() { return ""; }
	virtual std::string InfluxDbDatabase() { return ""; }
	virtual std::string InfluxDbUser() { return ""; }
	virtual std::string InfluxDbPassword() { return ""; }
	virtual int InfluxDbReportHundredthsPercentage() { return 0; }
	virtual int InfluxDbInstallHundredthsPercentage() { return 0; }
	void ReportToInfluxDb(int throttle, const std::string& json, bool blocking = false);
	void ReportInstallMetricsToInfluxDb(bool isUpdate, const std::string& result, const std::string& message);

	virtual void SetupGoogleAnalytics() {}
	virtual bool ValidateInstalledExeVersion() { return false; }
	virtual bool IsInstalledVersionUptodate() { return true; }

	virtual bool IsPreDeployOn() { return false; }
	virtual bool NeedPreDeployRun() { return false; }
	virtual void RunPreDeploy() {}
	virtual bool ForceNoDialogMode() { return false; }
	virtual bool GetLogChromeProtocolFix() { return false; }
	virtual bool GetUseNewVersionFetch() { return false; }
	virtual bool GetUseDataDomain() { return true; }
	virtual bool CreateEdgeRegistry() { return true; }
	virtual bool DeleteEdgeRegistry() { return false; }

	std::string fetchVersionGuid(std::string product);
	virtual std::string fetchVersionGuidFromWeb(std::string product);
	void writeAppSettings();

	void CreateProcess(const TCHAR* module, const TCHAR* args, PROCESS_INFORMATION& pi);
	void RegisterElevationPolicy(const TCHAR* appName, const TCHAR* appPath);
	void RegisterUninstall(const TCHAR *productName);
	void RegisterProtocolHandler(const std::wstring& protocolScheme, const std::wstring& exePath, const std::wstring& installKeyRegPath);
	void UnregisterProtocolHandler(const std::wstring& protocolScheme);
	bool isInstalled(std::wstring productKey);
	void CreateShortcuts(bool forceDesktopIconCreation, const TCHAR *linkName, const TCHAR *exeName, const TCHAR *params);
	void DeleteOldVersionsDirectories();
	void DoDeployComponents(const std::vector<std::pair<std::wstring, std::wstring> > &files, bool isUpdating, bool commitData);

	bool deleteDirectory(const std::wstring &refcstrRootDirectory, bool childrenOnly = false);
	std::string queryInstalledInstallHost();

	std::string queryInstalledVersion(const std::wstring& RegistryPath);
	std::string queryInstalledVersion() { return queryInstalledVersion(GetRegistryPath()); }

	std::wstring getInstalledBootstrapperPath(const std::wstring& RegistryPath);
	std::wstring getInstalledBootstrapperPath() { return getInstalledBootstrapperPath(GetRegistryPath()); }

	void deploySelf(bool commitData);
	void message(const std::string& message);

	void deleteLegacyShortcuts();

	void validateAndFixChromeState();

	HWND GetHwndFromPID(DWORD pid);

public:
	simple_logger<wchar_t> logger;

	virtual ~Bootstrapper(void);
	
	static boost::shared_ptr<Bootstrapper> Create(HINSTANCE hInstance, Bootstrapper*(*newBootstrapper)(HINSTANCE));
	static bool hasSse2();
	
	virtual std::wstring programDirectory() const;			  // Local location for installing components to
	std::wstring programDirectory(bool isPerUser) const;   // Local location for installing components to
	std::wstring baseProgramDirectory(bool isPerUser) const; //place where all installed versions are
	bool hasReturnValue() const { return isFailIfNotUpToDate; }
	bool hasLegacyStudioDesktopShortcut();
	bool isSilentMode() const { return silentMode; }
	bool isWindowed() const { return windowed; }
	bool WaitForCompletion() { DWORD result = WaitForSingleObject(robloxReady, 30*60*1000); return (result == WAIT_TIMEOUT); }
	int ExitCode() const { return exitCode; }
	void cleanKey(const std::wstring regPathToDelete, CRegKey &hk);
	std::string BrowserTrackerId() { return browserTrackerId; }
	HWND getLaunchedAppHwnd() { return launchedAppHwnd; }

	// IInstallerSite
	virtual std::string BaseHost() { return baseHost; }
	virtual std::string InstallHost() { return installHost; }
	virtual std::string InstallVersion() { return installVersion; }
	virtual simple_logger<wchar_t> &Logger() { return logger; }
	virtual void progressBar(int pos, int max);
	virtual void CheckCancel() { checkCancel(); }
	virtual void Error(const std::exception& e) { error(e); }
	virtual std::wstring ProgramDirectory() { return programDirectory(); }
	virtual bool UseNewCdn() { return false; }
	virtual bool ReplaceCdnTxt() { return false; }

	void Close();
	void postLogFile(bool uploadApp);
	bool hasErrors() const { return errors.size()>0; }
	bool hasLongUserCancel() const { return userCancelled && ((userCancelledTime - startTime) > 60); } 
	bool hasUserCancel() const { return userCancelled; }
	bool stopRequested() const { return userCancelled || hasErrors(); }
	void error(const std::exception& e);

	DWORD GetElapsedTime();
	void ReportElapsedEvent(bool startingGameClient);
	virtual void RegisterEvent(const TCHAR *eventName) {};
	virtual void FlushEvents() {};
	// Returns true if we want to enhance remote event reporting with
	// information needed to separate different bootstrapper use cases
	// (e.g. to be able to separate installs vs plays vs check-if-up-to-date).
	virtual bool PerModeLoggingEnabled() { return false; }
	void ReportFinishing(const char* status);

	virtual std::wstring GetRegistryPath() const = 0;
	virtual std::wstring GetRegistrySubPath() const = 0;
	virtual const wchar_t* GetVersionFileName() const = 0;
	virtual const wchar_t* GetGuidName() const = 0;
	virtual const wchar_t* GetStartAppMutexName() const = 0;
	virtual const wchar_t* GetBootstrapperMutexName() const = 0;
	virtual const wchar_t* GetFriendlyName() const = 0;
	virtual const wchar_t* GetProtocolHandlerUrlScheme() const = 0;

	virtual void DoInstallApp() {};
	virtual void DoUninstallApp(CRegKey &hk) {}; //component specific uninstall actions
	virtual std::wstring GetRobloxAppFileName() const { return std::wstring(_T("")); }
	virtual std::wstring GetBootstrapperFileName() const { return std::wstring(_T("")); }
	virtual std::wstring GetProductCodeKey() const { return std::wstring(_T("")); }
	virtual void DeployComponents(bool isUpdating, bool commitData) {};
	virtual void StartRobloxApp(bool fromInstall) {}
	virtual bool IsPlayMode() { return false; }
	virtual bool HasUnhideGuid() {return false; }
	virtual bool ProcessProtocolHandlerArgs(const std::map<std::wstring, std::wstring>& args) { return false; }
	virtual bool ProcessArg(wchar_t** args, int &pos, int count) { return false; }

};

int BootstrapperMain(HINSTANCE hInstance, int nCmdShow, Bootstrapper*(*newBootstrapper)(HINSTANCE));