#include "GameOverlay.h"

GameOverlay::GameOverlay()
{
}
GameOverlay::~GameOverlay()
{
	ImGui_ImplDX9_Shutdown();
	ImGui_ImplWin32_Shutdown();
	ImGui::DestroyContext();

	if (g_pd3dDevice) g_pd3dDevice->Release();
	if (pD3D) pD3D->Release();
	DestroyWindow(OverWindow);
	UnregisterClass(ClassName.c_str(), wc.hInstance);

	UnhookWindowsHookEx(hMouseHook);
}

extern LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT WINAPI GameOverlay::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
		return true;

	switch (msg)
	{
		case WM_SIZE:
			if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
			{
				ImGui_ImplDX9_InvalidateDeviceObjects();
				g_d3dpp.BackBufferWidth = LOWORD(lParam);
				g_d3dpp.BackBufferHeight = HIWORD(lParam);
				HRESULT hr = g_pd3dDevice->Reset(&g_d3dpp);
				if (hr == D3DERR_INVALIDCALL)
					IM_ASSERT(0);
				ImGui_ImplDX9_CreateDeviceObjects();
			}
			return 0;
		case WM_SYSCOMMAND:
			if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
				return 0;
			break;
		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}
LRESULT CALLBACK GameOverlay::MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
{
	GameOverlay *g = (GameOverlay*)GetWindowLongPtr(OverWindow, GWLP_USERDATA);
	if (g->IsOpen) // bool
	{
		ImGuiIO& io = ImGui::GetIO();
		MOUSEHOOKSTRUCT* pMouseStruct = (MOUSEHOOKSTRUCT *)lParam;
		if (pMouseStruct != NULL) {
			switch (wParam)
			{
				case WM_LBUTTONDOWN:
					io.MouseDown[0] = true;
					break;
				case WM_LBUTTONUP:
					io.MouseDown[0] = false;
					io.MouseReleased[0] = true;
					break;
				case WM_RBUTTONDOWN:
					io.MouseDown[1] = true;
					break;
				case WM_RBUTTONUP:
					io.MouseDown[1] = false;
					io.MouseReleased[1] = true;
					break;
			}
		}
	}
	return CallNextHookEx(hMouseHook, nCode, wParam, lParam);
}

bool GameOverlay::Inti(string ClassName, string WindowTitle)
{
	if (_inti)
		return false;

	this->ClassName = ClassName;
	this->WindowTitle = WindowTitle;

	RECT rc;
	HWND newhwnd = FindWindowEx(FindWindow("TXGuiFoundation", NULL), NULL, "AEngineRenderWindowClass", NULL);
	if (newhwnd != NULL)
	{
		GetWindowRect(newhwnd, &rc);
		//s_width = rc.right - rc.left;
		//s_height = rc.bottom - rc.top;
	}
	else
	{
		//ExitProcess(0);
	}

	// Create application window
	//wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L, 0L, (HMODULE)GetModuleHandle(NULL), NULL, NULL, NULL, NULL, ClassName.c_str(), NULL };
	ZeroMemory(&wc, sizeof(WNDCLASSEX));
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WndProc;
	wc.hInstance = 0L;
	wc.hCursor = NULL;
	// wc.hbrBackground = (HBRUSH)RGB(0, 0, 0);
	wc.hbrBackground = NULL;
	wc.lpszClassName = ClassName.c_str();
	RegisterClassEx(&wc);
	OverWindow = CreateWindow(ClassName.c_str(), WindowTitle.c_str(), WS_EX_TOPMOST | WS_POPUP, 100, 100, 1280, 800, NULL, NULL, wc.hInstance, NULL);

	SetWindowLong(OverWindow, GWL_EXSTYLE, (int)GetWindowLong(OverWindow, GWL_EXSTYLE) | WS_EX_LAYERED | WS_EX_TRANSPARENT);
	SetLayeredWindowAttributes(OverWindow, RGB(0, 0, 0), 255, ULW_COLORKEY | LWA_ALPHA);

	// Trick to get the class inside static funcs
	SetWindowLongPtr(OverWindow, GWLP_USERDATA, (LONG_PTR)this);

	// Initialize Direct3D
	if ((pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
	{
		UnregisterClass(ClassName.c_str(), wc.hInstance);
		return false;
	}
	ZeroMemory(&g_d3dpp, sizeof(g_d3dpp));
	g_d3dpp.Windowed = TRUE;
	g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	g_d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
	g_d3dpp.EnableAutoDepthStencil = TRUE;
	g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // Present with vsync
	//g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // Present without vsync, maximum unthrottled framerate

	// Create the D3DDevice
	if (pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, OverWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &g_d3dpp, &g_pd3dDevice) < 0)
	{
		pD3D->Release();
		UnregisterClass(ClassName.c_str(), wc.hInstance);
		return false;
	}

	// Setup Dear ImGui context
	IMGUI_CHECKVERSION();
	ImGui::CreateContext();
	ImGuiIO& io = ImGui::GetIO();
	io.DeltaTime = 1.0f / 60.0f;
	//io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;  // Enable Keyboard Controls

	// Setup Dear ImGui style
	ImGui::StyleColorsDark();
	//ImGui::StyleColorsClassic();

	// Setup Platform/Renderer bindings
	ImGui_ImplWin32_Init(OverWindow);
	ImGui_ImplDX9_Init(g_pd3dDevice);

	// Load Fonts
	// - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
	// - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
	// - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
	// - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
	// - Read 'misc/fonts/README.txt' for more instructions and details.
	// - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
	//io.Fonts->AddFontDefault();
	//io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
	//io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
	//io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
	//io.Fonts->AddFontFromFileTTF("../../misc/fonts/ProggyTiny.ttf", 10.0f);
	//ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
	//IM_ASSERT(font != NULL);

	hMouseHook = SetWindowsHookEx(WH_MOUSE, MouseProc, 0, GetWindowThreadProcessId(OverWindow, NULL));
	return true;
}

void GameOverlay::InternalRendering()
{
	bool show_demo_window = true;
	bool show_another_window = false;
	ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 0.0f);

	// Start the Dear ImGui frame
	ImGui_ImplDX9_NewFrame();
	ImGui_ImplWin32_NewFrame();
	ImGui::NewFrame();

	// 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
	if (show_demo_window)
		ImGui::ShowDemoWindow(&show_demo_window);

	// 2. Show a simple window that we create ourselves. We use a Begin/End pair to created a named window.
	{
		static float f = 0.0f;
		static int counter = 0;

		ImGui::Begin(WindowTitle.c_str(), &IsOpen);                          // Create a window called "Hello, world!" and append into it.

		ImGui::Text("This is some useful text.");               // Display some text (you can use a format strings too)
		ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
		ImGui::Checkbox("Another Window", &show_another_window);

		ImGui::SliderFloat("float", &f, 0.0f, 1.0f);            // Edit 1 float using a slider from 0.0f to 1.0f
		ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color

		if (ImGui::Button("Button"))                            // Buttons return true when clicked (most widgets return true when edited/activated)
			counter++;
		ImGui::SameLine();
		ImGui::Text("counter = %d", counter);

		ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
		ImGui::End();
	}

	// 3. Show another simple window.
	if (show_another_window)
	{
		ImGui::Begin("Another Window", &show_another_window);   // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
		ImGui::Text("Hello from another window!");
		if (ImGui::Button("Close Me"))
			show_another_window = false;
		ImGui::End();
	}
}

void GameOverlay::Update()
{
	ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 0.0f);

	// Main loop
	MSG msg;
	ZeroMemory(&msg, sizeof(msg));
	while (msg.message != WM_QUIT)
	{
		// Poll and handle messages (inputs, window resize, etc.)
		// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
		// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
		// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
		// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
		if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
			continue;
		}

		// Set Open State
		if (lastState != IsOpen)
		{
			lastState = IsOpen;
			UpdateOverlayState();
		}

		InternalRendering();

		// Rendering
		ImGui::EndFrame();
		g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, false);
		g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
		g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, false);
		D3DCOLOR clear_col_dx = D3DCOLOR_RGBA((int)(clear_color.x*255.0f), (int)(clear_color.y*255.0f), (int)(clear_color.z*255.0f), (int)(clear_color.w*255.0f));
		g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, clear_col_dx, 1.0f, 0);
		if (g_pd3dDevice->BeginScene() >= 0)
		{
			ImGui::Render();
			ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
			g_pd3dDevice->EndScene();
		}
		HRESULT result = g_pd3dDevice->Present(NULL, NULL, NULL, NULL);

		// Handle loss of D3D9 device
		if (result == D3DERR_DEVICELOST && g_pd3dDevice->TestCooperativeLevel() == D3DERR_DEVICENOTRESET)
		{
			ImGui_ImplDX9_InvalidateDeviceObjects();
			g_pd3dDevice->Reset(&g_d3dpp);
			ImGui_ImplDX9_CreateDeviceObjects();
		}
	}
}

void GameOverlay::Start()
{
	if (_inti)
		return;

	_inti = true;

	ShowWindow(OverWindow, SW_SHOWDEFAULT);
	UpdateWindow(OverWindow);

	// Start the updater
	auto UpdaterStart = [](LPVOID p) -> DWORD WINAPI { GameOverlay *t = (GameOverlay*)p; t->Update(); return 0; };
	CreateThread(NULL, NULL, UpdaterStart, this, NULL, NULL);

}

void GameOverlay::UpdateOverlayState()
{
	//We call this function only when we open or close the menu
	long style = GetWindowLong(OverWindow, GWL_EXSTYLE);
	if (IsOpen)
	{
		style &= ~WS_EX_LAYERED;
		SetWindowLong(OverWindow, GWL_EXSTYLE, style);
		SetForegroundWindow(OverWindow);
	}
	else
	{
		style |= WS_EX_LAYERED;
		SetWindowLong(OverWindow, GWL_EXSTYLE, style);
	}
	//Credits go to someone from UC
}