//#define NOMUSICTIMING
#define MULTISHADER

#ifdef _DEBUG
#include <time.h>
#include <io.h>
#include <process.h>
#include "Shaders.h"
#include "synth.h"
#include "4klang.h"
#else
#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN
#include <windows.h>
#include <stdio.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "glext.h"
#include "synth.h"

#include "4klang.h"
#ifdef NOMUSICTIMING
#include "Mmsystem.h"
#endif

#define V_Y "Y"
#define V_Z "Z"

#ifndef ASPECT
#define ASPECT 1.78
#endif

#ifndef SCREENWIDTH
#define SCREENWIDTH 1280
#endif

#ifndef SCREENHEIGTH
#define SCREENHEIGTH 720
#endif

#define WINDOWED

#include "mark_small.h"

#define STR2(x) #x 
#define STR(x) STR2(x) 

//static char* vsh = "varying vec4 Y;varying vec2 Z;void main(){Y=gl_Color;Z=(gl_Vertex.xy*vec2(Y.w,1))*.5+.5;gl_Position=gl_Vertex;}";
static char* vsh = "varying vec4 "V_Y";varying vec2 "V_Z";void main(){"V_Y"=gl_Color;"V_Z"=(gl_Vertex.xy*vec2("STR( ASPECT )",1))*.5+.5;gl_Position=gl_Vertex;}";
#endif

#ifdef _DEBUG
#define HALF_FAC 1
static const int gi_ScreenWidth = 1280/HALF_FAC;

static const int gi_ScreenHeight = 720/HALF_FAC;
#else
static const int gi_ScreenWidth = SCREENWIDTH;

static const int gi_ScreenHeight = SCREENHEIGTH ;
#endif

#pragma data_seg(".glUniform4f")
static const char* glUniform4f = "glUniform4f";

#ifdef _DEBUG
HANDLE gh_ShaderCompileEvent;
static char** gs_LastShader_;
static __time64_t gi_ShaderChangedDate;
static unsigned int gi_ShaderProgram;
static unsigned int gi_LastShaderProgram;
static const char* gs_VertexShader = "generic.vs";
static const char* gs_ShaderFile = "mark.fs";
#endif

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
};

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
};

__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;
}

#ifdef _DEBUG
#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);\
	}\
}
#else
#define CHECK_DEBUG_OUTPUT(shader)
#endif

#ifdef _DEBUG
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);
				std::cout << "Shader loaded." << std::endl;
			}
			_findclose(hfile);
		}
		::Sleep(100);
	}
	return 0;
}
#endif

#ifdef _DEBUG

#include <cmath>

float g_DebugCamPos[ 3 ]= {0,2.0f,-5.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= 8.0f;

bool g_bForceCompile= true;

void MoveCam( float& fCurTime )
{
	float fSpeed= 0.25f;

	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(bStrg)
		{
			fSpeed *= 4.0f;
		}

		if( GetAsyncKeyState( VK_HOME ) && bStrg)
		{
			g_DebugCamPos[ 0 ]= 0.0f;
			g_DebugCamPos[ 1 ]= 2.0f;
			g_DebugCamPos[ 2 ]= -5.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;

}
#endif

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

int gCurScene= 0;
int gCurSceneStart= 0;
int g_SceneLength[]=
{
	16, 16, 16,
	16, 16, 16, 
	16, 32, 16,
	16, 16, 16, 
	0x80000000 
};
int g_SceneShader[]=
{
	0,0,0,
	1,1,1,
	2,2,2,
	3,3,3,
};
float g_SceneFactor[]=
{
	0,	0,	0,
	0,	0,	1.0f,
	0,	0,	1.0f,
	0,	1.0f,	1.0f,
	0,
};

void _cdecl main()
{
#ifdef _DEBUG
	//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);
#else
#ifndef	WINDOWED
	ChangeDisplaySettings (&dmScreenSettings,CDS_FULLSCREEN); 
	HDC hDC = GetDC(CreateWindow("edit", 0, WS_POPUP | WS_VISIBLE | WS_MAXIMIZE, 0, 0, 0, 0, 0, 0, 0, 0));
#else
	HDC hDC = GetDC(CreateWindow("static", "RED", WS_EX_APPWINDOW | WS_VISIBLE | WS_SYSMENU, 0, 0, gi_ScreenWidth, gi_ScreenHeight, 0, 0, 0, 0));
#endif
	
	SetPixelFormat(hDC, ChoosePixelFormat(hDC, &pfd), &pfd);
	wglMakeCurrent(hDC, wglCreateContext(hDC));
#ifdef MULTISHADER
	unsigned int shaders[4];

	mark_fs_0[6]= '0';
	shaders[0]=compileShader(vsh, mark_fs_0 ),

	mark_fs_0[6]= '1';
	shaders[1]=compileShader(vsh, mark_fs_0 ),

	mark_fs_0[6]= '2';
	shaders[2]=compileShader(vsh, mark_fs_0 ),

	mark_fs_0[6]= '3';
	shaders[3]=compileShader(vsh, mark_fs_0 ),

#else
	compileShader(vsh, mark_fs_0 );
#endif 
	ShowCursor(FALSE);
#endif

#ifdef _DEBUG
	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, (GLfloat)gi_ScreenWidth, (GLfloat)gi_ScreenHeight);
	glRectf(-1, -1, 1, 1);
	SwapBuffers(hDC);
#endif

#ifndef _DEBUG
	InitSound();
#else
	LARGE_INTEGER li_OldTime = { 0 };
#endif
#ifdef NOMUSICTIMING
	int iStartTick= timeGetTime();
#endif

	float lf_Time= 0.0f;
	do 
	{
#ifdef _DEBUG
		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;
		}
#endif

		get_Sample();
		int Sample=  MMTime.u.sample - gCurSceneStart;
		int SceneEnd = g_SceneLength[gCurScene] * SAMPLES_PER_TICK * 8;//samples per tick
		
#ifdef NOMUSICTIMING
		lf_Time = ( timeGetTime() - iStartTick ) * 0.001f / 16.0f;
#endif

		glLoadIdentity();

#ifdef _DEBUG
		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 * 145.0f / 60.0f  / g_fSpeedFac;
		if( lf_Time > 1.0f )
		{
			lf_Time= 0.0f;
			if (g_fSqrAnimFac < 0.0)
			{
				g_SceneID = (g_SceneID + 1) % 16;
			}
		}
		((PFNGLUNIFORM4FPROC)wglGetProcAddress(glUniform4f))(0, (float)g_SceneID, lf_Time * abs(g_fSqrAnimFac), (GLfloat)gi_ScreenHeight, (GLfloat)0.375f);
#else
#ifdef MULTISHADER
		((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(shaders[ g_SceneShader[ gCurScene ] ]);
#endif
		lf_Time= (float)Sample / (float)SceneEnd;
		glColor4f((float)gCurScene, lf_Time, gi_ScreenWidth, gi_ScreenHeight);
#endif
#ifdef _DEBUG
		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);
#endif

		glRects(-1, -1, 1, 1);
		SwapBuffers(hDC);

#ifndef _DEBUG
		if( Sample > SceneEnd )
		{
			gCurSceneStart+= SceneEnd;
			gCurScene++;
		}
#endif
	} 
#ifdef _DEBUG
	while ( !GetAsyncKeyState(VK_ESCAPE) );
#else
	while ( g_SceneLength[ gCurScene ]  > 0 && !GetAsyncKeyState(VK_ESCAPE) );	
#endif
	ExitProcess(0);
}