#define STRICT
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <mmsystem.h>
#include <cstdio>
#include <assert.h>
#include <psapi.h>
#pragma comment(lib, "psapi.lib")
#include <ctime>


#include <win.h>
#define INITGUID
#include <ddraw.h>
#include <d3d.h>

#include <basicdib.h>
#include <ddsurf.h>
#include <ddwrap.h>

#include <ddoverlaysurf.h>
#include <ddoverlay.h>
#include "engine.h"
#include "HookDLL.h"

#include <winexcep.h>


KEngine:: KEngine()
{
}

KEngine:: KEngine(HINSTANCE hInst, HWND target_window, DWORD pid)
{
	m_hInst			= hInst;
	m_target_window = target_window;
	m_focus_past    = false;
	m_focus_present = false;
	m_target_pid	= pid;
	//m_safe_to_render = true;

	//sq = new Squares[NUM_OF_SQUARES];
}

KEngine:: ~KEngine()
{
	//delete sq;
}

void KEngine:: OnKeyDown(WPARAM wParam, LPARAM lParam)
{
    if ( wParam == VK_ESCAPE )
		PostMessage(KWindow::m_hWnd, WM_CLOSE, 0, 0);
}

LRESULT KEngine:: WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{

	if( uMsg >= WM_APP )
	{
		// Handle the messages reported by the hook.

		// MSGID_NEW + 0 reports a change of keyboard focus on
		// the target window. This report is received from the
		// controller itself, and not from the hook.
		if( uMsg == (WM_APP + MSGID_NEW + 0) )
		{
			if( (bool)wParam == true )
			{
				m_overlay.Show();
				//m_safe_to_render = true;
			}
			else if( (bool)wParam == false )
			{
				m_overlay.Hide();
				//m_safe_to_render = false;
			}
		}
		else
		{
			HookReportHandler(uMsg, wParam, lParam);
		}

		return 0;
	}
	else
	{
		switch( uMsg )
		{
			case WM_CREATE:
				KWindow::m_hWnd = hWnd;
				SetupDirectDraw(GetParent(hWnd), hWnd, L"m.bmp", 1, false, 1280, 800, 32);
				return 0;

			case WM_PAINT:
				ValidateRect(hWnd, NULL);
				return 0;

			case WM_KEYDOWN:
				OnKeyDown(wParam, lParam);
				return 0;

			case WM_CLOSE:
				PostQuitMessage(0);
				return 0;

			default:
				return DefWindowProc(hWnd, uMsg, wParam, lParam);
		}
	}
}

void KEngine:: HookReportHandler(UINT msg_id, WPARAM wParam, LPARAM lParam)
{
	switch(msg_id)
	{
	case WM_APP + MSGID_CBT + HCBT_ACTIVATE:
		//m_overlay.Show();
		//InitScene();
		//m_safe_to_render = true;
		break;

	case WM_APP + MSGID_CBT + HCBT_CREATEWND:
		break;

	case WM_APP + MSGID_CBT + HCBT_DESTROYWND:
		break;

	case WM_APP + MSGID_CBT + HCBT_MINMAX:
			if( LOWORD(lParam) == SW_MINIMIZE )
			{
				SetWinRect();
				m_overlay.Hide();
				//InitScene();
				//m_safe_to_render = false;
			}
			else if( LOWORD(lParam) == SW_MAXIMIZE )
			{
				SetWinRect();
				m_overlay.Show();
				//InitScene();
				//m_safe_to_render = true;
			}
			else if( LOWORD(lParam) == SW_RESTORE )
			{
				SetWinRect();
				m_overlay.Show();
				//InitScene();
				//m_safe_to_render = true;
			}
		break;

	case WM_APP + MSGID_CBT + HCBT_MOVESIZE:
		SetWinRect();
		//InitScene();
		//m_safe_to_render = true;
		break;

	case WM_APP + MSGID_CBT + HCBT_SETFOCUS:
		// Window gaining the keyboard focus.
		if( (HWND)wParam == m_target_window)
		{
			//m_overlay.Show();
			//m_safe_to_render = true;
		}
		// Window losing the keyboard focus.
		if( (HWND)lParam == m_target_window )
		{
			//m_overlay.Hide();
			//m_safe_to_render = false;
		}
		break;
	case WM_APP + MSGID_MOUSE + 0:
		SetWinRect();
		//if( /*[mouse click is in desired area]*/ ) 
		//{
		//	//[do something nice]
		//}
		//else
		//{
		//	//[do something else that is nice.]
		//}
		break;
	}
}


void KEngine:: GetWndClassEx(WNDCLASSEX & wc)
{
	KWindow::GetWndClassEx(wc);

	wc.style |= (CS_HREDRAW | CS_VREDRAW);
	// [My icon?]
	//wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_GRAPH));
}

WPARAM KEngine:: MessageLoop(void)
{
	MSG msg;
	HWND window_in_focus;

	m_bMainWindow = true;

	while(true)
	{
		window_in_focus = GetFocus();

		if( window_in_focus == m_target_window )
		{	 
			m_focus_present = true;
		}
		else if( GetParent(window_in_focus) == m_target_window)
		{
			m_focus_present = true;
		}
		else
		{
			m_focus_present = false;
		}

		if( m_focus_present != m_focus_past )
		{
			// There's been a change in focus.

			PostMessage( KWindow::m_hWnd, WM_APP + MSGID_NEW + 0, (WPARAM)m_focus_present, 0);
			m_focus_past = m_focus_present;
		}

		if(TimeToDie())
		{
			PostMessage(KWindow::m_hWnd, WM_QUIT, 0, 0);
		}

		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))	
		{
			if (msg.message == WM_QUIT) 
				break;

			TranslateMessage(&msg);						
			DispatchMessage(&msg);						
		}

		TestStateAndRecover();

		Render();
	}

	return msg.wParam;
}

void KEngine:: SetWinRect( void )
{
	WINDOWINFO wi;
	wi.cbSize = sizeof(WINDOWINFO);
	GetWindowInfo(m_target_window, & wi);

	m_win_rect.left   = wi.rcClient.left;
	m_win_rect.top    = wi.rcClient.top;
	m_win_rect.right  = wi.rcClient.right;
	m_win_rect.bottom = wi.rcClient.bottom;

	// Guard against weired client rect dimensions.
	// A minimized window is one such instance.
	// Hence, use a 'nothing' (0 pixel X 0 pixel) rect when in trouble.

	if( (m_win_rect.left   < 0) ||
		(m_win_rect.top	   < 0) ||
		(m_win_rect.right  < 0) ||
		(m_win_rect.bottom < 0)
	  )
	{
		m_win_rect.left	  = 0;
		m_win_rect.top	  = 0;
		m_win_rect.right  = 0;
		m_win_rect.bottom = 0;
	}
}

HWND KEngine:: GetEngineWindowHandle(void)
{
	return KWindow::m_hWnd;
}

/**************************************************
Looks for the target process in the system's 
process list. If it doesn't find it, it's time
to pull the plug.
**************************************************/

bool KEngine:: TimeToDie(void)
{
	BOOL b_ret;
	DWORD list_size, pid_list_size;
	DWORD pid_list[60];
	pid_list_size = 60 * sizeof(DWORD);

	b_ret = EnumProcesses(pid_list, pid_list_size, & list_size);

#ifdef KDEBUG
	e_win.Test<BOOL>(b_ret, __FILE__, __LINE__, "EnumProcesses");
#endif

	if(pid_list_size <= list_size)
	{
		pid_list_size = list_size;
		b_ret = EnumProcesses(pid_list, pid_list_size, & list_size);

#ifdef KDEBUG
		e_win.Test<BOOL>(b_ret, __FILE__, __LINE__, "EnumProcesses");
#endif
	
	}

	for(unsigned int i=0; i<(pid_list_size/sizeof(DWORD)); i++)
	{
		if(pid_list[i] == m_target_pid)
		{
			return false;
		}
	}

	return true;
}

void KEngine:: InitScene(void)
{
	//time_t t;
	//srand((unsigned)time(&t));

	SetWinRect();

	RECT src;
	src.left = src.top = 0;
	src.right = m_win_rect.right - m_win_rect.left;
	src.bottom =  m_win_rect.bottom - m_win_rect.top;
	
	m_overlay.SetSrcRect(src);

	m_overlay.SetDestRect(m_win_rect);

	//for(int i=0; i<NUM_OF_SQUARES; i++)
	//{
	//	sq[i].size = 16;
	//	sq[i].x = (float)(rand()%(m_win_rect.right - m_win_rect.left - sq[i].size));
	//	sq[i].y = (float)(rand()%(m_win_rect.bottom - m_win_rect.top - sq[i].size));
	//	sq[i].plane = rand()%3;
	//	if(sq[i].plane == 0)
	//		sq[i].c = m_backbuffer.ColorMatch(0xDF,0xDF,0xDF);
	//	else if(sq[i].plane == 1)
	//		sq[i].c = m_backbuffer.ColorMatch(0xBF,0xBF,0xBF);
	//	else if(sq[i].plane == 2)
	//		sq[i].c = m_backbuffer.ColorMatch(0xAF,0xAF,0xAF);
	//}
}

//void KEngine:: Render()
//{
//	RECT src;
//
//	//if(m_safe_to_render)
//	//{
//	//	SetWinRect();
//	//	m_overlay.SetDestRect(m_win_rect);
//
//	//	SetRect(&src, 0,0,
//	//			m_win_rect.right-m_win_rect.left, 
//	//			m_win_rect.bottom-m_win_rect.top);
//	//	m_overlay.SetSrcRect(src);
//		
//		SetWinRect();
//		m_overlay.SetDestRect(m_win_rect);
//
//		SetRect(&src, 0,0,
//				m_win_rect.right-m_win_rect.left-1, 
//				m_win_rect.bottom-m_win_rect.top-1);
//		m_overlay.SetSrcRect(src);
//
//		
//		m_backbuffer.FillColor(0,0,
//							m_win_rect.right - m_win_rect.left-1,
//							m_win_rect.bottom - m_win_rect.top-1,
//							m_backbuffer.ColorMatch(0x00,0x00,0x00));
//
//
//		for(int i=0; i<NUM_OF_SQUARES; i++)
//		{
//			if(sq[i].plane==0)
//				sq[i].y+=0.4f;
//			else if(sq[i].plane==1)
//				sq[i].y+=0.7f;
//			else if(sq[i].plane==2)
//				sq[i].y+=1.0f;
//
//			if((sq[i].y + sq[i].size) > ((float)m_win_rect.bottom-1))
//				sq[i].y=0.0f;
//
//
//			m_backbuffer.FillColor((int)sq[i].x, (int)sq[i].y, (int)sq[i].x+sq[i].size, 
//								(int)sq[i].y+sq[i].size, sq[i].c);
//		}
//	//}
//	//else
//	//{
//	//	SetRect(&src, 0,0,1,1);
//	//	m_overlay.SetSrcRect(src);
//
//	//	SetRect(&dest, 0,0,1,1);
//	//	m_overlay.SetDestRect(dest);
//	//}
//
//	m_overlay.Flip();
//	m_overlay.UpdateOverlay((IDirectDrawSurface7 * &)m_primary); 
//
//	Sleep(25);
//}



// Static bitmap at top right.


void KEngine:: Render()
{
	SetWinRect();
	m_overlay.DrawBitmap( m_dib, 0, 0, m_dib->bmiHeader.biWidth, m_dib->bmiHeader.biHeight);

	static int x = m_win_rect.right - m_dib->bmiHeader.biWidth - 10;
	static int y = m_win_rect.top + 10;
	
	m_dest_rect.left = x;
	m_dest_rect.top = y;
	m_dest_rect.right = m_dest_rect.left + m_src_rect.right - m_src_rect.left;
	m_dest_rect.bottom = m_dest_rect.top + m_src_rect.bottom - m_src_rect.top;

	m_overlay.UpdateOverlay((IDirectDrawSurface7 * &)m_primary); 
	//m_overlay.UpdateOverlay(& m_src_rect, (IDirectDrawSurface7 * &)m_primary, & m_dest_rect);
	//m_overlay.UpdateOverlay(& m_src_rect, (IDirectDrawSurface7 * &)m_overlay, & m_dest_rect);

	Sleep(25);
}