// HelloWindowsDesktop.cpp
// compile with: /D_UNICODE /DUNICODE /DWIN32 /D_WINDOWS /c

#include <windows.h>
#include <windowsx.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>
#include <CommCtrl.h>
#include <ShObjIdl.h>

#include <strsafe.h>

#include "resource.h"

#include <fstream>
#include <iterator>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <codecvt>

#include <combaseapi.h>

#pragma comment( lib, "gdiplus.lib" ) 
#include <gdiplus.h> 

// AltSign
#include "DeviceManager.hpp"
#include "Error.hpp"

#include "AltServerApp.h"

#include <pplx/pplxtasks.h>

#pragma comment(linker,"\"/manifestdependency:type='win32' \
name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \
processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

extern std::string StringFromWideString(std::wstring wideString);
extern std::wstring WideStringFromString(std::string string);

#define odslog(msg) { std::stringstream ss; ss << msg << std::endl; OutputDebugStringA(ss.str().c_str()); }

std::string make_uuid()
{
	GUID guid;
	CoCreateGuid(&guid);

	std::ostringstream os;
	os << std::hex << std::setw(8) << std::setfill('0') << guid.Data1;
	os << '-';
	os << std::hex << std::setw(4) << std::setfill('0') << guid.Data2;
	os << '-';
	os << std::hex << std::setw(4) << std::setfill('0') << guid.Data3;
	os << '-';
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[0]);
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[1]);
	os << '-';
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[2]);
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[3]);
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[4]);
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[5]);
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[6]);
	os << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(guid.Data4[7]);

	std::string s(os.str());
	return s;
}

std::string temporary_directory()
{
	wchar_t rawTempDirectory[1024];

	int length = GetTempPath(1024, rawTempDirectory);

	std::wstring wideString(rawTempDirectory);

	std::wstring_convert<std::codecvt_utf8<wchar_t>> conv1;
	std::string tempDirectory = conv1.to_bytes(wideString);

	return tempDirectory;
}

std::vector<unsigned char> readFile(const char* filename)
{
	// open the file:
	std::ifstream file(filename, std::ios::binary);

	// Stop eating new lines in binary mode!!!
	file.unsetf(std::ios::skipws);

	// get its size:
	std::streampos fileSize;

	file.seekg(0, std::ios::end);
	fileSize = file.tellg();
	file.seekg(0, std::ios::beg);

	// reserve capacity
	std::vector<unsigned char> vec;
	vec.reserve(fileSize);

	// read the data:
	vec.insert(vec.begin(),
		std::istream_iterator<unsigned char>(file),
		std::istream_iterator<unsigned char>());

	return vec;
}

// Global variables

// The main window class name.
static TCHAR szWindowClass[] = _T("DesktopApp");

// The string that appears in the application's title bar.
static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");

HINSTANCE hInst;

// Forward declarations of functions included in this code module:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK LoginDlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam);

std::optional<std::string> _ipaFilepath;

int CALLBACK WinMain(
	_In_ HINSTANCE hInstance,
	_In_ HINSTANCE hPrevInstance,
	_In_ LPSTR     lpCmdLine,
	_In_ int       nCmdShow
)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);
	wcex.style = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc = WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, IDI_APPLICATION);
	wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wcex.lpszMenuName = NULL;
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, IDI_APPLICATION);

	if (!RegisterClassEx(&wcex))
	{
		MessageBox(NULL,
			_T("Call to RegisterClassEx failed!"),
			_T("Windows Desktop Guided Tour"),
			NULL);

		return 1;
	}

	// Store instance handle in our global variable
	hInst = hInstance;

	// The parameters to CreateWindow explained:
	// szWindowClass: the name of the application
	// szTitle: the text that appears in the title bar
	// WS_OVERLAPPEDWINDOW: the type of window to create
	// CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
	// 500, 100: initial size (width, length)
	// NULL: the parent of this window
	// NULL: this application does not have a menu bar
	// hInstance: the first parameter from WinMain
	// NULL: not used in this application
	/*HWND hWnd = CreateWindow(
		szWindowClass,
		szTitle,
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT,
		500, 100,
		NULL,
		NULL,
		hInstance,
		NULL
	);*/

	HWND hWnd = CreateWindowEx(
		WS_EX_CLIENTEDGE,
		szWindowClass,
		szTitle,
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		500,
		300,
		HWND_MESSAGE,
		NULL,
		hInstance,
		NULL
	);

	if (!hWnd)
	{
		MessageBox(NULL,
			_T("Call to CreateWindow failed!"),
			_T("Windows Desktop Guided Tour"),
			NULL);

		return 1;
	}

	MessageBox(NULL, _T("SideServer for Microsoft Windows is not functional, please follow https://wiki.sidestore.io/guides/getting-started/ instead. SideServer will now exit"), _T("https://wiki.sidestore.io/guides/getting-started/"), NULL);

	return 1;
	
	// The parameters to ShowWindow explained:
	// hWnd: the value returned from CreateWindow
	// nCmdShow: the fourth parameter from WinMain
	ShowWindow(hWnd, nCmdShow);
	//ShowWindow(hWnd, SW_HIDE);
	UpdateWindow(hWnd);

	AltServerApp::instance()->Start(hWnd, hInst);

	// Main message loop:
	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return (int)msg.wParam;
}

#define ID_MENU_LAUNCH_AT_LOGIN 104
#define ID_MENU_CLOSE 103
#define ID_MENU_CHECK_FOR_UPDATES 105

#define NO_DEVICES 200
#define FIRST_DEVICE 201

#define NO_APPS 300
#define FIRST_APP 301

std::shared_ptr<Device> _selectedDevice;
std::vector<std::shared_ptr<Device>> _connectedDevices;
HMENU _enableJITMenu = NULL;

std::map<std::string, std::vector<InstalledApp>> _installedAppsByDevice;
std::mutex _installedAppsLock;

//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return

static HMENU hPopupMenu = NULL;

std::optional<std::string> OpenFile()
{
	std::optional<std::string> filepath = std::nullopt;

	HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
	if (!SUCCEEDED(hr))
	{
		return filepath;
	}

	IFileOpenDialog* pFileOpen;
	hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL, IID_IFileOpenDialog, reinterpret_cast<void**>(&pFileOpen));
	if (SUCCEEDED(hr))
	{
		COMDLG_FILTERSPEC rgSpec[] = {
			{ L"iOS Applications", L"*.ipa"},
		};
		pFileOpen->SetFileTypes(ARRAYSIZE(rgSpec), rgSpec);

		hr = pFileOpen->Show(NULL);
		if (SUCCEEDED(hr))
		{
			IShellItem* pItem;
			hr = pFileOpen->GetResult(&pItem);
			if (SUCCEEDED(hr))
			{
				PWSTR pszFilePath;
				hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);

				if (SUCCEEDED(hr))
				{
					filepath = StringFromWideString(pszFilePath);
					CoTaskMemFree(pszFilePath);
				}

				pItem->Release();
			}
		}

		pFileOpen->Release();
	}

	CoUninitialize();

	return filepath;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	PAINTSTRUCT ps;
	HDC hdc;
	TCHAR greeting[] = _T("Click to Log In.");

	switch (message)
	{
	case (WM_MENUSELECT):
	{
		if (_enableJITMenu != (HMENU)lParam)
		{
			// _enableJITMenu is not the active menu, so ignore.
			return 0;
		}

		int index = LOWORD(wParam);
		if (index >= _connectedDevices.size())
		{
			// Invalid index, return.
			return 0;
		}

		auto device = _connectedDevices[index];
		auto name = WideStringFromString(device->name());

		_installedAppsLock.lock();

		bool alreadyFetched = (_installedAppsByDevice.count(device->identifier()) > 0);
		if (!alreadyFetched)
		{
			// Prevent us from fetching apps again before first fetch completes.
			_installedAppsByDevice[device->identifier()] = {};
		}

		_installedAppsLock.unlock();

		if (alreadyFetched)
		{
			// We've already fetched apps for this device, so return.
			odslog("Already fetched apps for " << device->name() << ", ignoring...");
			return 0;
		}

		HMENU appsMenu = GetSubMenu(_enableJITMenu, index);
		HMENU cachedEnableJITMenu = _enableJITMenu;
		odslog("Fetching installed apps for " << device->name() << "...");

		DeviceManager::instance()->FetchInstalledApps(device)
		.then([appsMenu, cachedEnableJITMenu, index, device](std::vector<InstalledApp> installedApps) {
			if (cachedEnableJITMenu != _enableJITMenu)
			{
				// Current "Enable JIT" menu is different than the one 
				// used to start the fetch, so consider this fetch cancelled.
				return;
			}

			odslog("Fetched " << installedApps.size() << " apps for " << device->name() << "!");
			RemoveMenu(appsMenu, 0, MF_BYPOSITION);

			std::sort(installedApps.begin(), installedApps.end());

			for (int j = 0; j < installedApps.size(); j++)
			{
				auto installedApp = installedApps[j];

				int menuIndex = FIRST_APP + j | (index << 12);
				AppendMenu(appsMenu, MF_STRING, menuIndex, WideStringFromString(installedApp.name()).c_str());
			}

			_installedAppsLock.lock();
			_installedAppsByDevice[device->identifier()] = installedApps;
			_installedAppsLock.unlock();
		})
		.then([=](pplx::task<void> task) {
			try
			{
				task.get();
			}
			catch (Error& e)
			{
				odslog("Error fetching installed apps for " << StringFromWideString(name) << ": " << e.localizedDescription());

				RemoveMenu(appsMenu, 0, MF_BYPOSITION);
				AppendMenu(appsMenu, MF_STRING | MF_GRAYED | MF_DISABLED, NO_DEVICES, WideStringFromString(e.localizedDescription()).c_str());
			}
			catch (std::exception& e)
			{
				odslog("Error fetching installed apps for " << StringFromWideString(name) << ": " << e.what());

				RemoveMenu(appsMenu, 0, MF_BYPOSITION);
				AppendMenu(appsMenu, MF_STRING | MF_GRAYED | MF_DISABLED, NO_DEVICES, WideStringFromString(e.what()).c_str());
			}
		});

		return 0;
	}
	case (WM_USER + 1):
	{
		switch (lParam)
		{
		case WM_LBUTTONUP:
		{
			// Get the position of the cursor
			POINT pCursor;
			GetCursorPos(&pCursor);

			bool isSideloadingIPA = GetKeyState(VK_SHIFT) & 0x8000; // Must check high-order bits for pressed down/up value.

			HMENU installMenu = CreatePopupMenu();
			_enableJITMenu = CreatePopupMenu();

			hPopupMenu = CreatePopupMenu();

			_installedAppsLock.lock();
			_installedAppsByDevice = {};
			_installedAppsLock.unlock();

			auto devices = DeviceManager::instance()->availableDevices();
			_connectedDevices = devices;

			if (devices.size() == 0)
			{
				AppendMenu(installMenu, MF_STRING | MF_GRAYED | MF_DISABLED, NO_DEVICES, L"No Connected Devices");
				AppendMenu(_enableJITMenu, MF_STRING | MF_GRAYED | MF_DISABLED, NO_DEVICES, L"No Connected Devices");
			}
			else
			{
				for (int i = 0; i < devices.size(); i++)
				{
					auto device = devices[i];
					auto name = WideStringFromString(device->name());

					AppendMenu(installMenu, MF_STRING, FIRST_DEVICE + i, name.c_str());

					HMENU appsMenu = CreatePopupMenu();
					AppendMenu(appsMenu, MF_STRING | MF_GRAYED | MF_DISABLED, NO_DEVICES, L"Loading...");
					AppendMenu(_enableJITMenu, MF_STRING | MF_POPUP, (UINT)appsMenu, name.c_str());
				}
			}

			if (AltServerApp::instance()->automaticallyLaunchAtLogin())
			{
				AppendMenu(hPopupMenu, MF_STRING | MF_CHECKED, ID_MENU_LAUNCH_AT_LOGIN, L"Automatically Launch at Startup");
			}
			else
			{
				AppendMenu(hPopupMenu, MF_STRING, ID_MENU_LAUNCH_AT_LOGIN, L"Automatically Launch at Startup");
			}
			
			const wchar_t* installTitle = isSideloadingIPA ? L"Sideload .ipa" : L"Install SideStore";
			AppendMenu(hPopupMenu, MF_STRING | MF_POPUP, (UINT)installMenu, installTitle);
			AppendMenu(hPopupMenu, MF_STRING | MF_POPUP, (UINT)_enableJITMenu, L"Enable JIT");

			AppendMenu(hPopupMenu, MF_STRING, ID_MENU_CHECK_FOR_UPDATES, L"Check for Updates...");
			AppendMenu(hPopupMenu, MF_STRING, ID_MENU_CLOSE, L"Close");

			// Popup the menu with cursor position as the coordinates to pop it up

			SetForegroundWindow(hWnd);

			int id = TrackPopupMenu(hPopupMenu, TPM_LEFTBUTTON | TPM_RIGHTALIGN | TPM_RETURNCMD, pCursor.x, pCursor.y, 0, hWnd, NULL);

			PostMessage(hWnd, WM_NULL, 0, 0);

			if (id == ID_MENU_CLOSE)
			{
				PostMessage(hWnd, WM_CLOSE, 0, 0);
			}
			else if (id == ID_MENU_LAUNCH_AT_LOGIN)
			{
				auto launchAtLogin = AltServerApp::instance()->automaticallyLaunchAtLogin();
				AltServerApp::instance()->setAutomaticallyLaunchAtLogin(!launchAtLogin);
			}
			else if (id == ID_MENU_CHECK_FOR_UPDATES)
			{
				AltServerApp::instance()->CheckForUpdates();
			}
			else if (id == NO_DEVICES || id == NO_APPS)
			{
				// Ignore
			}
			else if (id >= FIRST_APP)
			{
				// Enable JIT

				int appIndex = (id & 0xFFF) - FIRST_APP;
				int deviceIndex = (id >> 12);

				auto device = devices[deviceIndex];

				_installedAppsLock.lock();
				auto apps = _installedAppsByDevice[device->identifier()];
				_installedAppsLock.unlock();

				auto app = apps[appIndex];
				
				auto task = AltServerApp::instance()->EnableJIT(app, device);

				try {
					task.get();
				}
				catch (Error& error)
				{
					odslog("Error: " << error.domain() << " (" << error.code() << ").")
				}
				catch (std::exception& exception)
				{
					odslog("Exception: " << exception.what());
				}
			}
			else if (id >= FIRST_DEVICE)
			{
				// Install app

				int index = id - FIRST_DEVICE;

				auto device = devices[index];
				_selectedDevice = device;

				if (isSideloadingIPA)
				{
					_ipaFilepath = OpenFile();

					if (!_ipaFilepath.has_value())
					{
						break;
					}
				}
				else
				{
					_ipaFilepath = std::nullopt;
				}

				// Show Auth dialog.
				int result = DialogBox(NULL, MAKEINTRESOURCE(ID_LOGIN), hWnd, LoginDlgProc);
			}
		}
		default: break;
		}

		break;
	}
	case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);

		// Here your application is laid out.
		// For this introduction, we just print out "Hello, Windows desktop!"
		// in the top left corner.
		TextOut(hdc,
			5, 5,
			greeting, _tcslen(greeting));
		// End application-specific layout section.

		EndPaint(hWnd, &ps);
		break;

	case WM_DESTROY:
		AltServerApp::instance()->Stop();
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
		break;
	}

	return 0;
}

INT_PTR CALLBACK LoginDlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
{
	HWND appleIDTextField = GetDlgItem(hwnd, IDC_EDIT1);
	HWND passwordTextField = GetDlgItem(hwnd, IDC_EDIT2);
	HWND installButton = GetDlgItem(hwnd, IDOK);

	switch (Message)
	{
	case WM_INITDIALOG:
	{
		Edit_SetCueBannerText(appleIDTextField, _T("Apple ID"));
		Edit_SetCueBannerText(passwordTextField, _T("Password"));

		Button_Enable(installButton, false);

		break;
	}

	case WM_CTLCOLORSTATIC:
	{
		if (GetDlgCtrlID((HWND)lParam) == IDC_DESCRIPTION)
		{
			HBRUSH success = (HBRUSH)GetStockObject(HOLLOW_BRUSH);
			SetBkMode((HDC)wParam, TRANSPARENT);
			return (BOOL)success;
		}

		break;
	}

	case WM_COMMAND:
		switch (HIWORD(wParam))
		{
		case EN_CHANGE:
		{
			/*PostMessage(hWnd, WM_CLOSE, 0, 0);
			break;*/

			int appleIDLength = Edit_GetTextLength(appleIDTextField);
			int passwordLength = Edit_GetTextLength(passwordTextField);

			if (appleIDLength == 0 || passwordLength == 0)
			{
				Button_Enable(installButton, false);
			}
			else
			{
				Button_Enable(installButton, true);
			}

			break;
		}
		}

		switch (LOWORD(wParam))
		{
		case IDOK:
		{
			wchar_t appleID[512];
			wchar_t password[512];

			Edit_GetText(appleIDTextField, appleID, 512);
			Edit_GetText(passwordTextField, password, 512);
			
			auto task = AltServerApp::instance()->InstallApplication(_ipaFilepath, _selectedDevice, StringFromWideString(appleID), StringFromWideString(password));

			EndDialog(hwnd, IDOK);

			try
			{
				task.get();
			}
			catch (Error& error)
			{
				odslog("Error: " << error.domain() << " (" << error.code() << ").")
			}
			catch (std::exception& exception)
			{
				odslog("Exception: " << exception.what());
			}

			odslog("Finished!");

			break;
		}

		case IDCANCEL:
			EndDialog(hwnd, IDCANCEL);
			break;
		}

		default:
			return FALSE;
	}
	return TRUE;
}