#include "core_win32opengl.h"
#include <direct.h>

#pragma comment(lib,"kernel32")
#pragma comment(lib,"gdi32")
#pragma comment(lib,"user32")
#pragma comment(lib,"opengl32")
#pragma comment(lib,"glu32")

#define IDI_MAINICON 101

static WNDCLASS wincl;
static int wincount=0;

void CoreOpenGL::SetupPixelFormat()
{
	PIXELFORMATDESCRIPTOR pfd=
	{
        sizeof(PIXELFORMATDESCRIPTOR),1,
		PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,colorsize,
		0,0,0,0,0,0,0,0,0,0,0,0,0,
		depthsize,0,
		0,PFD_MAIN_PLANE,0,0,0,0
    };

	int pfmt=ChoosePixelFormat(device,&pfd);
	SetPixelFormat(device,pfmt,&pfd);
}

LRESULT APIENTRY WindowProcGL(HWND hwnd,UINT msg,WPARAM wp,LPARAM lp)
{
	CoreOpenGL *thiscore=(CoreOpenGL *)GetWindowLong(hwnd,GWL_USERDATA);
	if ((thiscore==NULL)&&(msg!=WM_CREATE))
		return DefWindowProc(hwnd,msg,wp,lp);

	RAVEN_KEY_CODE ratkey;
	RAVEN_SYS_KEY vkey;

	int btnnum=0;

	switch (msg)
	{
		case WM_CREATE:
		{
			HINSTANCE instance=(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
			thiscore=(CoreOpenGL *)(((LPCREATESTRUCT)lp)->lpCreateParams);

			SetWindowLong(hwnd,GWL_USERDATA,(LONG)thiscore);
			thiscore->hwnd=hwnd;
			thiscore->BindGLContext();

			ShowWindow(hwnd,SW_SHOW);
			return 0;
		}
		break;
	case WM_QUIT:
    case WM_CLOSE:
		thiscore->isappterm=true;
        return 0;
    case WM_SIZE:
        thiscore->height=HIWORD(lp);
        thiscore->width=LOWORD(lp);
		thiscore->isresized=true;

        ReleaseDC(thiscore->hwnd,thiscore->device);
        thiscore->device=GetDC(thiscore->hwnd);

        return 0;
    case WM_ERASEBKGND:
    case WM_ACTIVATEAPP:
        return 0;
    case WM_KEYDOWN:
        vkey=wp;
        ratkey=RAVEN_key_map_get_code(thiscore->keymap,vkey);

        if (ratkey)
            thiscore->keys[ratkey]=true;
        else
            thiscore->keys[vkey]=true;

        return 0;
    case WM_KEYUP:
        vkey=wp;
        ratkey=RAVEN_key_map_get_code(thiscore->keymap,vkey);

        if (ratkey)
            thiscore->keys[ratkey]=false;
        else
            thiscore->keys[vkey]=false;

        return 0;
    case WM_RBUTTONDOWN: btnnum++; /* Right mouse button pressed */
    case WM_MBUTTONDOWN: btnnum++; /* Middle mouse button pressed */
    case WM_LBUTTONDOWN: btnnum++; /* Left mouse button pressed */
        thiscore->buttons[btnnum]=true;
        return 0;
    case WM_RBUTTONUP: btnnum++; /* Right mouse button released */
    case WM_MBUTTONUP: btnnum++; /* Middle mouse button released */
    case WM_LBUTTONUP: btnnum++; /* Left mouse button released */
        thiscore->buttons[btnnum]=false;
        return 0;
    case WM_MOUSEMOVE:
        thiscore->mousex=(double)LOWORD(lp)/(double)thiscore->width;
        thiscore->mousey=(double)HIWORD(lp)/(double)thiscore->height;
        return 0;
    case WM_SYSCOMMAND:
        /* System call made. */
        if (wp==SC_SCREENSAVE||wp==SC_MONITORPOWER) return 0;
        break;
    default:
        break;
	}

	return DefWindowProc(hwnd,msg,wp,lp);
}

CoreOpenGL::CoreOpenGL(char *title,unsigned int width,unsigned int height,int colorsize,int depthsize,int flags):
	Core(title,width,height,colorsize,depthsize,flags)
{
	instance=GetModuleHandle(NULL);

	char path[5000];
	if (GetModuleFileName(NULL,path,sizeof(path)))
	{
		char *slash=strrchr(path,'\\');
		if (slash) *slash='\0';
        _chdir(path);
	}
}
CoreOpenGL::~CoreOpenGL() {}

bool CoreOpenGL::Start()
{
	if (!keymap)
	{
		cerr<<"Keymap failed to initialize!"<<endl;
		return false;
	}

	if (!wincount)
	{
		wincl.hInstance=instance;
		wincl.lpszClassName="RAVEN wc";
		wincl.lpfnWndProc=WindowProcGL;
		wincl.style=CS_CLASSDC|CS_VREDRAW|CS_HREDRAW;
		wincl.hIcon=LoadIcon(instance,MAKEINTRESOURCE(IDI_MAINICON));
		wincl.hCursor=LoadCursor(NULL,IDI_APPLICATION);
		wincl.lpszMenuName=NULL;
		wincl.cbClsExtra=0;
		wincl.cbWndExtra=0;
		wincl.hbrBackground=NULL;
		if (!RegisterClass(&wincl))
		{
			cerr<<"Failed to register window class!"<<endl;
			return false;
		}
	}

	if (flags&RAVEN_FULLSCREEN)
	{
		DEVMODE dm;
		memset(&dm,0,sizeof(dm));
		dm.dmSize=sizeof(DEVMODE);
		dm.dmFields=DM_PELSWIDTH|DM_PELSHEIGHT|DM_BITSPERPEL;
		dm.dmPelsWidth=width;
		dm.dmPelsHeight=height;
		dm.dmBitsPerPel=colorsize;
		if (ChangeDisplaySettings(&dm,CDS_FULLSCREEN)==DISP_CHANGE_FAILED)
		{
			flags&=~RAVEN_FULLSCREEN; // unflag fullscreen, it didn't work out
			ChangeDisplaySettings(NULL,0);
			cout<<"Failed to go to fullscreen!  Switching to windowed."<<endl;
		}
	}

	DWORD style=(flags&RAVEN_FULLSCREEN)?WS_POPUP:
		(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX| \
		((flags&RAVEN_RESIZABLE)?WS_SIZEBOX|WS_MAXIMIZEBOX:0));

	int screenwidth=GetSystemMetrics(SM_CXSCREEN);
	int screenheight=GetSystemMetrics(SM_CYSCREEN);

	if (flags&RAVEN_FULLSCREEN)
	{
		RECT winrect;
		winrect.left=0L;
		winrect.right=(long)width;
		winrect.top=0L;
		winrect.bottom=(long)height;

		AdjustWindowRect(&winrect,style,FALSE);

		hwnd=CreateWindow("RAVEN wc",title,style|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,
			winrect.left,winrect.top,winrect.right-winrect.left,winrect.bottom-winrect.top,
			NULL,NULL,instance,(void*)this);
	}
	else
	{
		RECT winrect;
		winrect.left=(long)(screenwidth/2-width/2);
		winrect.right=winrect.left+(long)width;
		winrect.top=(long)(screenheight/2-height/2);
		winrect.bottom=winrect.top+(long)height;

		AdjustWindowRect(&winrect,style,FALSE);

		hwnd=CreateWindow("RAVEN wc",title,style|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,
			winrect.left,winrect.top,winrect.right-winrect.left,winrect.bottom-winrect.top,
			NULL,NULL,instance,(void*)this);
	}

	if (!hwnd)
	{
		cerr<<"Failed to create window!"<<endl;
		return false;
	}

	wincount++;
	return true;
}

bool CoreOpenGL::Stop()
{
	bool success=true;

	wglMakeCurrent(device,NULL);
	wglDeleteContext(context);
	ReleaseDC(hwnd,device);

	SetWindowLong(hwnd,GWL_USERDATA,(LONG)NULL);
	if (!DestroyWindow(hwnd))
	{
		cerr<<"Failed to destroy window!"<<endl;
		success=false;
	}

	if (flags&RAVEN_FULLSCREEN)
		ChangeDisplaySettings(NULL,0);

	wincount--;
	if (!wincount)
	{
		if (!UnregisterClass("RAVEN wc",instance))
		{
			cerr<<"Failed to unregister window class!"<<endl;
			success=false;
		}
	}
	return success;
}

bool CoreOpenGL::BindGLContext()
{
	device=GetDC(hwnd);
	SetupPixelFormat();
	context=wglCreateContext(device);
	wglMakeCurrent(device,context);

	wglSwapIntervalEXT(0);

	return true;
}

bool CoreOpenGL::Update()
{
	// do window proc event handling
	MSG msg;

	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
	{
		TranslateMessage(&msg); /* Translate message in to usable form. */
		DispatchMessage(&msg);  /* Dispatch the message to our callback. */
	}

	// swap the buffers
	if (!SwapBuffers(device))
    {
        /* If we failed it may because we lost the device context. */
        device=GetDC(hwnd);
        return SwapBuffers(device)!=0; /* Tries to swap buffers and returns success. */
    }

	return true;
}