#ifdef _DEBUG

#define MULTISHADER
#define LOCALMUSIC

#include <time.h>
#include <io.h>
#include <stdio.h>
#include <process.h>
#include "Shaders.h"
#include "small.h"
#include "synth.h"

#define HALF_FAC 2
#pragma data_seg(".resolutionX")
static const int gi_ScreenWidth = 1280/HALF_FAC;

#pragma data_seg(".resolutionY")
static const int gi_ScreenHeight = 720/HALF_FAC;

#pragma bss_seg(".debugnothing")
HANDLE gh_ShaderCompileEvent;
static char** gs_LastShader_;
static __time64_t gi_ShaderChangedDate;
static unsigned int gi_ShaderProgram;
static unsigned int gi_LastShaderProgram;
#pragma data_seg(".debuginfo")
static const char* gs_VertexShader = "generic.vs";
static const char* gs_ShaderFile = "mark.fs";

#pragma data_seg(".pfd")
static const PIXELFORMATDESCRIPTOR pfd={
	0, 1, PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 8
};

#pragma data_seg(".dms")
static DEVMODE dmScreenSettings={
	"",0,0,sizeof(dmScreenSettings),0,DM_PELSWIDTH|DM_PELSHEIGHT,
	0,0,0,0,0,0,0,0,0,0,0,0,0,"",0,0,gi_ScreenWidth,gi_ScreenHeight
};

#pragma code_seg(".compile")
__forceinline unsigned int compileShader(const char* vsh, const char* fsh)
{
	GLuint s,p;
	p = ((PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram"))();
	s = ((PFNGLCREATESHADERPROC)(wglGetProcAddress("glCreateShader")))(GL_VERTEX_SHADER);
	((PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource")) (s, 1, &vsh, NULL);
	((PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"))(s);
	((PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader")) (p,s);
	s = ((PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader"))(GL_FRAGMENT_SHADER);	
	((PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource")) (s, 1, &fsh, NULL);
	((PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"))(s);
	((PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader")) (p,s);
	((PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram"))(p);
#ifndef MULTISHADER
	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(p);
#endif
	return p;
}

__forceinline unsigned int compileShaderMultiple(const char* vsh, const char** fsh)
{
	GLuint s,p;
	p = ((PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram"))();
	s = ((PFNGLCREATESHADERPROC)(wglGetProcAddress("glCreateShader")))(GL_VERTEX_SHADER);
	((PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource")) (s, 1, &vsh, NULL);
	((PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"))(s);
	((PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader")) (p,s);
	s = ((PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader"))(GL_FRAGMENT_SHADER);	
	((PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource")) (s, 7, fsh, NULL);
	((PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"))(s);
	((PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader")) (p,s);
	((PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram"))(p);
	return p;
}

#define CHECK_DEBUG_OUTPUT(shader) \
{\
	GLint success = 0;\
	glGetShaderiv(shader, GL_COMPILE_STATUS, &success);\
	if (!success)\
	{\
		GLchar infoLog[16384];\
		glGetShaderInfoLog(shader, 16384, NULL, infoLog);\
		OutputDebugString(infoLog);\
	}\
}

DWORD WINAPI filemon(void* args)
{
	while (true)
	{
		_finddata_t fdata;
		long hfile = _findfirst(gs_ShaderFile, &fdata);
		if (hfile != -1)
		{
			if (fdata.time_write != gi_ShaderChangedDate)
			{
				gi_ShaderChangedDate = fdata.time_write;
				::SetEvent(gh_ShaderCompileEvent);
				OutputDebugString("Shader loaded.\n");
			}
			_findclose(hfile);
		}
		::Sleep(100);
	}
	return 0;
}

#include <cmath>

float g_DebugCamPos[ 3 ]= {0,2.0f,-48.0f};
float g_DebugCamRot[ 2 ]= {0,0};

bool g_ShaderDebug= true;
int g_ShaderID= 0;
int g_SceneID= 0;
int g_MaxSceneID= 16;
float g_fSqrAnimFac= 0.0f;

float g_fSpeedFac= 12.0f;

bool g_bForceCompile= true;

void MoveCam( float& fCurTime )
{
	float fSpeed= 0.125f*3.0f;

	bool bShift= GetAsyncKeyState( VK_SHIFT ) || GetAsyncKeyState( VK_MBUTTON ) || GetAsyncKeyState( VK_RBUTTON );
	bool bStrg= GetAsyncKeyState( VK_CONTROL ) != 0;
	float a= g_DebugCamRot[ 0 ];
	float b= g_DebugCamRot[ 1 ];
	float g_Forward[ 3 ]= {sinf( a )*cosf(b),-sinf(b), cosf( a )*cosf(b)};
	float g_Right[ 3 ]= {cosf( a ),0, -sinf( a )};
	if( bShift )
	{
		if( GetAsyncKeyState( VK_HOME ) )
		{
			g_DebugCamPos[ 0 ]= 0.0f;
			g_DebugCamPos[ 1 ]= 2.0f;
			g_DebugCamPos[ 2 ]= -48.0f;

			g_DebugCamRot[ 0 ]= 0.0f;
			g_DebugCamRot[ 1 ]= 0.0f;
		}

		if( GetAsyncKeyState( 'W' ) )
		{
			g_DebugCamPos[ 0 ]+= fSpeed * g_Forward[ 0 ];
			g_DebugCamPos[ 1 ]+= fSpeed * g_Forward[ 1 ];
			g_DebugCamPos[ 2 ]+= fSpeed * g_Forward[ 2 ];
		}
		if( GetAsyncKeyState( 'S' ) )
		{
			g_DebugCamPos[ 0 ]-= fSpeed * g_Forward[ 0 ];
			g_DebugCamPos[ 1 ]-= fSpeed * g_Forward[ 1 ];
			g_DebugCamPos[ 2 ]-= fSpeed * g_Forward[ 2 ];
		}
		if( GetAsyncKeyState( 'A' ) )
		{
			g_DebugCamPos[ 0 ]-= fSpeed * g_Right[ 0 ];
			g_DebugCamPos[ 1 ]-= fSpeed * g_Right[ 1 ];
			g_DebugCamPos[ 2 ]-= fSpeed * g_Right[ 2 ];
		}
		if( GetAsyncKeyState( 'D' ) )
		{
			g_DebugCamPos[ 0 ]+= fSpeed * g_Right[ 0 ];
			g_DebugCamPos[ 1 ]+= fSpeed * g_Right[ 1 ];
			g_DebugCamPos[ 2 ]+= fSpeed * g_Right[ 2 ];
		}
		if( GetAsyncKeyState( 'F' ) )
		{
			g_DebugCamPos[ 1 ]+= fSpeed;
		}
		if( GetAsyncKeyState( 'V' ) )
		{
			g_DebugCamPos[ 1 ]-= fSpeed;
		}

		if( bStrg )
		{
			if( ( GetAsyncKeyState( VK_F2 ) & 1 ) != 0)
			{
				g_ShaderDebug= !g_ShaderDebug;
				g_bForceCompile= true;
			}
			if( ( GetAsyncKeyState( VK_F3 ) & 1 ) != 0)
			{
				g_ShaderID= (g_ShaderID + MAX_SHADER_ID - 1 ) % MAX_SHADER_ID;
				g_bForceCompile= true;
			}
			if( ( GetAsyncKeyState( VK_F4 ) & 1 )!= 0)
			{
				g_ShaderID= (g_ShaderID + MAX_SHADER_ID + 1 ) % MAX_SHADER_ID;
				g_bForceCompile= true;
			}
			if( ( GetAsyncKeyState( VK_F7 ) & 1 ) != 0)
			{
				g_SceneID= (g_SceneID + g_MaxSceneID - 1 ) % g_MaxSceneID;
			}
			if( ( GetAsyncKeyState( VK_F8 ) & 1 )!= 0)
			{
				g_SceneID= (g_SceneID + g_MaxSceneID + 1 ) % g_MaxSceneID;
			}
			if( ( GetAsyncKeyState( VK_F9 ) & 1 ) != 0)
			{
				g_fSqrAnimFac-= 1.0f;
			}
			if( ( GetAsyncKeyState( VK_F10 ) & 1 )!= 0)
			{
				g_fSqrAnimFac+= 1.0f;
			}
		}
		else
		{
			if( ( GetAsyncKeyState( VK_F6 ) & 1 )!= 0)
			{
				fCurTime= 0.0f;
			}
			if( ( GetAsyncKeyState( VK_F7 ) & 1 )!= 0)
			{
				g_fSpeedFac*= 2.0f;
				if( g_fSpeedFac > 32.0f )
				{
					g_fSpeedFac= 32.0f;
				}
			}
			if( ( GetAsyncKeyState( VK_F8 ) & 1 ) != 0)
			{
				g_fSpeedFac/= 2.0f;
				if( g_fSpeedFac < 2.0f )
				{
					g_fSpeedFac= 2.0f;
				}
			}
		}
	}

	static POINT OldCurPos;
	POINT CurPos;
	GetCursorPos( &CurPos );

	if( bShift )
	{
		g_DebugCamRot[ 0 ]-= 0.003f * ( OldCurPos.x - CurPos.x );
		g_DebugCamRot[ 1 ]-= 0.003f * ( OldCurPos.y - CurPos.y );
		g_DebugCamRot[ 1 ]= max( g_DebugCamRot[ 1 ], -1.56f );
		g_DebugCamRot[ 1 ]= min( g_DebugCamRot[ 1 ], 1.56f );
	}
	OldCurPos= CurPos;

}

LRESULT MessageCallback(HWND ar_Handle, UINT aw_Message, WPARAM aw_Param, LPARAM al_Param)
{
	return DefWindowProc(ar_Handle, aw_Message, aw_Param, al_Param);
}

#pragma bss_seg(".main_bss")
int gCurScene= 0;

#pragma data_seg(".main_glob")
const int g_SceneLength= 16;
const int g_MagicConstant=313600;

#pragma code_seg(".main")
void _cdecl main()
{
	//ChangeDisplaySettings (&dmScreenSettings,CDS_FULLSCREEN); 
	//HDC hDC = GetDC(CreateWindow("edit", 0, WS_POPUP | WS_VISIBLE | WS_MAXIMIZE, 0, 0, 0, 0, 0, 0, 0, 0));
	//HWND hWnd = CreateWindow("MDICLIENT", "Test", WS_OVERLAPPED | WS_VISIBLE | WS_SYSMENU, 0, 0, gi_ScreenWidth, gi_ScreenHeight, 0, 0, 0, 0);

	WNDCLASSEX wndclass; 
	wndclass.cbSize        = sizeof (wndclass) ;
	wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wndclass.lpfnWndProc   = (WNDPROC)MessageCallback ;
	wndclass.cbClsExtra    = 0 ;
	wndclass.cbWndExtra    = 0 ;
	wndclass.hInstance     = NULL ;
	wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
	wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
	wndclass.hbrBackground = (HBRUSH) GetStockObject (DKGRAY_BRUSH) ;
	wndclass.lpszMenuName  = NULL;
	wndclass.lpszClassName = "Window" ;
	wndclass.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ; 

	RegisterClassEx(&wndclass); 

	HWND hWnd = 	CreateWindow(
		"Window",         /* Classname */
		"Title",       /* Title Text */
		WS_EX_APPWINDOW, /* default window */
		10,       /* Windows decides the position */
		30,       /* where the window ends up on the screen */
		gi_ScreenWidth,                 /* The programs width */
		gi_ScreenHeight,                 /* and height in pixels */
		NULL,        /* The window is a child-window to desktop */
		NULL,                /* No menu */
		GetModuleHandle(NULL), //GetModuleHandle(NULL),       /* Program Instance handler */
		NULL                 /* No Window Creation data */
		);


	HDC hDC = GetDC(hWnd);
	SetPixelFormat(hDC, ChoosePixelFormat(hDC, &pfd), &pfd);
	wglMakeCurrent(hDC, wglCreateContext(hDC));
	initShaders();
	gh_ShaderCompileEvent = ::CreateEvent(NULL, FALSE, FALSE, TEXT("WriteEvent")); 
	SetThreadPriority((HANDLE)CreateThread(0, 0, &filemon, 0, 0, 0), THREAD_PRIORITY_BELOW_NORMAL);
	
	ShowWindow (hWnd , SW_NORMAL );  
	::Sleep(100);

	if (::WaitForSingleObject(gh_ShaderCompileEvent, 0) == WAIT_OBJECT_0)
	{
		::Sleep(250);
		gi_ShaderProgram = createProgram(
			createVertexShader(gs_VertexShader), 
			createFragmentShader(gs_ShaderFile, g_ShaderID, g_ShaderDebug ));

		((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(gi_ShaderProgram);
		PrintErrors();
	}
	glColor4f(0,0,0, float(gi_ScreenWidth)/gi_ScreenHeight);
	glRectf(-1, -1, 1, 1);
	SwapBuffers(hDC);

	LARGE_INTEGER li_OldTime = { 0 };

	float lf_Time= 0.0f;
	do 
	{
		MSG msg;
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) 
		{
			if (msg.message == WM_QUIT)    
				return;      
			else         
			{
				TranslateMessage(&msg);    
				DispatchMessage(&msg);    
			}
		}

		if (::WaitForSingleObject(gh_ShaderCompileEvent, 0) == WAIT_OBJECT_0 || g_bForceCompile)
		{
			::Sleep(50);
			gi_ShaderProgram = createProgram(
				createVertexShader(gs_VertexShader), 
				createFragmentShader(gs_ShaderFile, g_ShaderID, g_ShaderDebug));

			((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(gi_ShaderProgram);
			PrintErrors();

			g_bForceCompile= false;
		}
		
		LARGE_INTEGER li_CurrentTime, li_CurrentFrequency;
		QueryPerformanceCounter(&li_CurrentTime);
		QueryPerformanceFrequency(&li_CurrentFrequency);
		//lf_Time = (float)li_CurrentTime.QuadPart / (float)li_CurrentFrequency.QuadPart;
		float lf_DiffTime = (float)(li_CurrentTime.QuadPart - li_OldTime.QuadPart) / (float)li_CurrentFrequency.QuadPart;
		char windowText[255];
		sprintf_s(
			windowText, 
			"Shader: %d Scene: %d AnimFac: %2.2f FPS: %.2f, Render time: %.4fms",
			g_ShaderID,
			g_SceneID, 
			g_fSqrAnimFac, 
			1.0f / lf_DiffTime, 
			lf_DiffTime );
		::SetWindowTextA(hWnd, windowText);

		li_OldTime = li_CurrentTime;

		lf_Time+= lf_DiffTime * 135.0f / 60.0f  / g_fSpeedFac;
		if( lf_Time > 1.0f )
		{
			lf_Time= 0.0f;
		}
		glColor4f((float)g_SceneID, lf_Time, lf_Time * lf_Time * g_fSqrAnimFac, 0.0f);
		MoveCam( lf_Time );

		float fDebugData[ 16 ];
		fDebugData[ 0 ]= g_DebugCamPos[ 0 ];
		fDebugData[ 1 ]= g_DebugCamPos[ 1 ];
		fDebugData[ 2 ]= g_DebugCamPos[ 2 ];
		fDebugData[ 4 ]= g_DebugCamRot[ 0 ];
		fDebugData[ 5 ]= g_DebugCamRot[ 1 ];
		glMatrixMode(GL_MODELVIEW);
		glLoadMatrixf((GLfloat*)&fDebugData);

		glRects(-1, -1, 1, 1);
		SwapBuffers(hDC);
	} 
	while ( !GetAsyncKeyState(VK_ESCAPE) );
	ExitProcess(0);
}
#endif