#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>

#include <GL/glfw.h>
#include <GL/glext.h>
#include <GL/wglext.h>

#include "types.h"

int width=800;
int height=600;
int pheight=512;
int pwidth=512;

//int nb_buffers=4;
#define nb_buffers 12
int running=TRUE;
int wireframe=FALSE;
int vsync=TRUE;
int blur=TRUE;

GLuint pbuffer_tex_id[nb_buffers];
HDC hpbufdc_;
HGLRC hpbufglrc_;

HPBUFFERARB  pbuffer_;


PFNWGLCREATEPBUFFERARBPROC  wglCreatePbufferARB;
PFNWGLGETPBUFFERDCARBPROC  wglGetPbufferDCARB;
PFNWGLCHOOSEPIXELFORMATARBPROC  wglChoosePixelFormatARB;
PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB;
PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB;
PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB;
PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB;


HDC hDC;
HGLRC hRC;

double FPS_time_elapsed = 0.0;
unsigned int FPS_number_of_frames = 0;


//========================================================================
// PrintGetLastError()
//========================================================================

void PrintGetLastError(void ) {
	DWORD j ;
	LPVOID lpMsgBuf;
	j = GetLastError() ;//& 0x0000FFFF;
	FormatMessage(
		FORMAT_MESSAGE_ALLOCATE_BUFFER |
		FORMAT_MESSAGE_FROM_SYSTEM |
		FORMAT_MESSAGE_IGNORE_INSERTS ,
		NULL,
		j,
		MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
		(LPTSTR) &lpMsgBuf,
		0,
		NULL);
	printf("yop : %s",lpMsgBuf);
}


//========================================================================
// Resize() - GLFW window resize callback function
//========================================================================

void Resize( int x, int y )
{
	width = x;
	height = y > 0 ? y : 1;   // Prevent division by zero in aspect calc.
		// Setup viewport
	glViewport( 0, 0, width,height );

}


//========================================================================
// Input cllback functions
//========================================================================

void KeyFun( int key, int action )
{
	if( action == GLFW_PRESS )
	{
		switch( key )
		{
		case GLFW_KEY_ESC:
			running = FALSE;
			break;
		case 'W':
			wireframe = !wireframe;
			glPolygonMode( GL_FRONT_AND_BACK, wireframe ? GL_LINE : GL_FILL );
			break;
		case 'V':
			vsync = !vsync;
			(vsync) ? glfwSwapInterval( 1 ) : glfwSwapInterval( 0 );
			glFinish();
			break;
		case 'B':
			blur = !blur;
			(blur) ? glEnable(GL_BLEND): glDisable(GL_BLEND);
			break;
		default:
			break;
		}
	}
}



void initGL(void) {
	int i;

	// Initialize GLFW
	glfwInit();

	// Open OpenGL fullscreen window
	//    if( !glfwOpenWindow( WIDTH, HEIGHT, 5,6,5,0, 16,0, GLFW_FULLSCREEN ) )
	if( !glfwOpenWindow( width, height, 8,8,8,8, 24,8, GLFW_WINDOW ) )  // XXX
//	if( !glfwOpenWindow( width, height, 5,6,5,0, 16,0, GLFW_FULLSCREEN ) )  // XXX
	{
		glfwTerminate();
		exit( 0 );
	}
	// Set window title
	glfwSetWindowTitle( "True Motion Blur" );

	// Disable VSync (we want to get as high FPS as possible!)
	// euh non ...
//	glfwSwapInterval( 1 );
// vsync=FALSE;

	glfwSwapInterval( 0 );
	vsync=FALSE;

	// Window resize callback function
	glfwSetWindowSizeCallback( Resize );
	// Set keyboard input callback function
	glfwSetKeyCallback( KeyFun );

	// if (glfwExtensionSupported("WGL_ARB_pbuffer")==GL_TRUE) {} else exit(-2);

	// init des pointeurs de fonction des extensions GL 1.4 ou 1.5

	wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) glfwGetProcAddress( "wglCreatePbufferARB" );
	if (wglCreatePbufferARB == NULL) exit(-3);

	wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) glfwGetProcAddress( "wglGetPbufferDCARB" );
	if (wglGetPbufferDCARB == NULL) exit(-3);

	wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) glfwGetProcAddress( "wglChoosePixelFormatARB" );
	if (wglChoosePixelFormatARB == NULL) exit(-3);

	wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC) glfwGetProcAddress( "wglBindTexImageARB" );
	if (wglBindTexImageARB == NULL) exit(-3);

	wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC) glfwGetProcAddress( "wglReleaseTexImageARB" );
	if (wglReleaseTexImageARB == NULL) exit(-3);

	wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC) glfwGetProcAddress( "wglReleasePbufferDCARB" );
	if (wglReleasePbufferDCARB == NULL) exit(-3);

	wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC) glfwGetProcAddress( "wglDestroyPbufferARB" );
	if (wglDestroyPbufferARB == NULL) exit(-3);

		hDC = wglGetCurrentDC();
	hRC = wglGetCurrentContext();

	UINT nbformats=0;
	const int hdcAttributes [30]={
		WGL_SUPPORT_OPENGL_ARB, TRUE, // pbuffer will be used with gl
//		WGL_BIND_TO_TEXTURE_RGB_ARB ,TRUE,
 		WGL_DRAW_TO_PBUFFER_ARB ,TRUE,
//		WGL_DRAW_TO_WINDOW_ARB ,TRUE,
		WGL_COLOR_BITS_ARB	,	24,
		WGL_ALPHA_BITS_ARB	,	8,
		WGL_DEPTH_BITS_ARB	,24,
		WGL_STENCIL_BITS_ARB	,8,
		WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
		0 			};
	int *pixelformats=(int*)calloc(256,4);

	wglChoosePixelFormatARB(hDC, hdcAttributes,
		NULL,
		256,
		pixelformats,
		&nbformats
		    );
	printf("nbformats:%d\n",nbformats);
//	PrintGetLastError(); // ?????????????????????????????

	//PrintGetLastError();
	const int pbufferAttributes [50] = {
//		WGL_TEXTURE_FORMAT_ARB,WGL_TEXTURE_RGBA_ARB, //**** slows down to a crawl any Geforce with glCopyTexSub
//		WGL_TEXTURE_FORMAT_ARB,WGL_TEXTURE_RGB_ARB,  //**** slows down to a crawl any Geforce with glCopyTexSub
//		WGL_TEXTURE_TARGET_ARB,WGL_TEXTURE_2D_ARB,   //**** slows down to a crawl any Geforce with glCopyTexSub
//		WGL_MIPMAP_TEXTURE_ARB,TRUE, // pour avoir des beaux mipmaps faits par la carte !
//		WGL_DEPTH_TEXTURE_FORMAT_NV, WGL_TEXTURE_DEPTH_COMPONENT_NV, //**** slows down to a crawl any Geforce with glCopyTexSub
		0 			};
	i=0;
	//for (i=0;i<nb_buffers;i++)
	{
		pbuffer_ = wglCreatePbufferARB(hDC,
			pixelformats[0],
			pwidth,
			pheight,
			pbufferAttributes);

		hpbufdc_ = wglGetPbufferDCARB( pbuffer_ );
		hpbufglrc_ = wglCreateContext( hpbufdc_);
///////////
		if (pbuffer_==NULL) exit(-3);
		if (glGetError()!=GL_NO_ERROR) exit(-3);

	printf("pbuffer:%d = %p\n",i,pbuffer_);
//		PrintGetLastError(); // ?????????????????????????????
		wglMakeCurrent(
			hpbufdc_,	// device context of device that OpenGL calls are to be drawn on
			hpbufglrc_ 	// OpenGL rendering context to be made the calling thread's current rendering context
		);
		glEnable(GL_DEPTH_TEST );
		glDisable(GL_POLYGON_STIPPLE );
		// Setup projection
		glMatrixMode( GL_PROJECTION );
		glLoadIdentity();
		//
		gluPerspective( 45.0, (double)pwidth/(double)pheight, 1.0, 100.0 );
		glTranslatef( 0.0f,0.0f,-10.0f);
		glMatrixMode( GL_MODELVIEW );

//		PrintGetLastError(); // pourquoi il dit (invalid window handle) => mmh, c'est pas grave.

/*
		wglMakeCurrent(
			hDC,	// device context of device that OpenGL calls are to be drawn on
			hRC 	// OpenGL rendering context to be made the calling thread's current rendering context
			);
*////////////////
	}

	wglMakeCurrent(
		hDC,	// device context of device that OpenGL calls are to be drawn on
		hRC 	// OpenGL rendering context to be made the calling thread's current rendering context
	);

if (!wglShareLists(hRC,  // OpenGL rendering context with which to share
                  // display lists
  hpbufglrc_   // OpenGL rendering context to share display lists
)) exit(-4);

	glGenTextures( nb_buffers, pbuffer_tex_id );
	for (i=0;i<nb_buffers;i++)
	{
		glBindTexture( GL_TEXTURE_2D, pbuffer_tex_id[i] );
		glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0 ); // pas d'anisotropic

		unsigned char *ptex =NULL;
		int x,y;
/*		ptex=	malloc(pwidth*pheight*3);
		for(x=0;x<pwidth;x++) {
			for(y=0;y<pheight;y++) {
				ptex[3*(y+x*pheight)]=(char)(x+y);
				ptex[3*(y+x*pheight)+1]=(char)(x+y);
				ptex[3*(y+x*pheight)+2]=(char)(x+y);
				ptex[3*(y+x*pheight)+3]=(char)(x+y);
			}
		}
*/		for(x=0;x<pwidth;x++) {
			for(y=0;y<pheight;y++) {
//				printf("r:%3uc ",ptex[4*(y+x*pheight)]);
//				printf("g:%3uc ",ptex[4*(y+x*pheight)+1]);
//				printf("b:%3uc ",ptex[4*(y+x*pheight)+2]);
//				printf("a:%3uc ",ptex[4*(y+x*pheight)+3]);
			}
		}
		glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, pwidth,	pheight,
			0, GL_BGRA_EXT, GL_UNSIGNED_BYTE,ptex
		);
	}
/** high quality parameters ::
////////// ne pas oublier d'activer dans les params du pbuffer :
//////////		WGL_MIPMAP_TEXTURE_ARB,TRUE, // pour avoir des beaux mipmaps faits par la carte !
		float aniso_level;
		glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,&aniso_level);
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso_level );
*/

		// Setup viewport
	glViewport( 0, 0, width, height);

	// Clear color and Z-buffer
	glDisable( GL_BLEND );
	glEnable( GL_DEPTH_TEST );
	glEnable( GL_TEXTURE_2D );
	glDisable( GL_LIGHTING );
	glDisable( GL_CULL_FACE );

	glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	// Setup projection
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
//	gluPerspective( 45.0, (double)width/(double)height, 1.0, 100.0 );
//	glTranslatef( 1.0f,1.0f,0.0f);
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();


	glfwEnable( GLFW_STICKY_KEYS );
	glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

	glFrontFace( GL_CW );
	glCullFace( GL_BACK );
	glEnable( GL_CULL_FACE );
	glClearColor(0.0f,0.0f,0.0f,1.0f);
	glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);

	//glDisable(GL_BLEND);
	glDisable(GL_DEPTH_TEST );

	glEnable(GL_BLEND);
	glBlendFunc( GL_SRC_ALPHA,GL_ONE);
//	glBlendFunc( GL_ONE,GL_ONE );
	glColor4f(1.0f,1.0f,1.0f,1.0/nb_buffers);
//	gluPerspective( 45.0, (double)width/(double)height, 1.0, 100.0 );
//	glTranslatef( 0.0f,0.0f,-100.0f);
///////////////////////
//  essai pour du texte : problème de choix de couleur ????

//  make the system font the device context's selected font
//SelectObject (hDC, GetStockObject (SYSTEM_FONT));

//  create the bitmap display lists
//  we're making images of glyphs 0 thru 255
//  the display list numbering starts at 1000, an arbitrary choice

//wglUseFontBitmaps (hDC, 0, 255, 1000);

}


void DrawSquare(void) {
	glBegin(GL_QUADS);

		glTexCoord2f( 0.0f,0.0f );
		glVertex2f( -1.0f,-1.0f );

		glTexCoord2f( 0.0f, 1.0f  );
		glVertex2f( -1.0f, 1.0f  );

		glTexCoord2f(  1.0f, 1.0f );
		glVertex2f(  1.0f, 1.0f );

		glTexCoord2f(  1.0f,0.0f );
		glVertex2f(  1.0f,-1.0f );

	glEnd();
}

//========================================================================
// Draw() - Main rendering function
//========================================================================

void Draw( double time, double dt ) // time = old_time + dt !!
{
	double  angle_z;

//	glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
//	glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);

	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	angle_z = -500.0 * time;
	// Setup camera
//	glLoadIdentity();
	glPushMatrix();
		// Rotate camera
	//	glRotated( -angle_x, 1.0, 0.0, 0.0 );
	//	glRotated( -angle_y, 0.0, 1.0, 0.0 );
		glRotated( -angle_z, 0.0, 0.0, 1.0 );
		glColor4f(0.5f,0.0f,1.0f,1.0f);
		glTranslatef(100.0f,0.0f,0.0f);
		glScalef(100.0f,100.0f,1.0f);
		glTranslatef(0.0f,0.0f,-10.0f);
		DrawSquare();/////////// le VIOLET
	glPopMatrix();
	glPushMatrix();
		glColor4f(1.0f,1.0f,1.0f,1.0f);
//
		glRotated( -angle_z+90.0, 0.0, 0.0, 1.0 );
		glTranslatef(0.0f,3.5f,0.0f);
//		glRotated( angle_z, 0.0, 0.0, 1.0 );
		glScalef(0.1f,3.0f,0.01f);
		DrawSquare(); /////////// le BLANC
	glPopMatrix();
	glPushMatrix();
		// Rotate camera
		angle_z = 180.0 * time;
	//	glRotated( -angle_x, 1.0, 0.0, 0.0 );
	//	glRotated( -angle_y, 0.0, 1.0, 0.0 );
		glRotated( -angle_z, 0.0, 0.0, 1.0 );
		glColor4f(1.0f,0.0f,0.0f,1.0f);
		DrawSquare(); /////////// le ROUGE
	glPopMatrix();
}

void DrawEmpty(int last) {
		//glBindTexture( GL_TEXTURE_2D, pbuffer_tex_id[last]);//[last] );
	//wglBindTexImageARB ( pbuffer[last],WGL_FRONT_LEFT_ARB );
	glBindTexture( GL_TEXTURE_2D, pbuffer_tex_id[last]);//[last] );
	DrawSquare();
	//wglReleaseTexImageARB ( pbuffer[last], WGL_FRONT_LEFT_ARB );
}



//========================================================================
// main()
//========================================================================

int main( int argc, char **argv )
{
	int i;
	int width_,height_; // pour alterner entre pbuffer et normal
	double t=0.0;

	// Check command line arguments
	for( i = 1; i < argc; i ++ ) {
		// Use benchmarking?
		if( strcmp( argv[i], "-b" ) == 0 ) {
		}

		// Force multithreading off?
		if( strcmp( argv[i], "-s" ) == 0 ) {
		}
	}
	initGL();

	t = glfwGetTime();
	glfwSwapBuffers();


	i = 0;
	// Main loop

	double old_time=0.0;
	double time=0.0;
	double  dt=0.0;
	double sub_dt=0.0;

	while( running )	{
		width_=width;
		height_=height;

		height=pheight;
		width=pwidth;

		// Get frame time
		time = glfwGetTime();
		dt = time-old_time;
		sub_dt = dt/(nb_buffers-0.0);//
		old_time = time;

		FPS_time_elapsed+=dt;
		FPS_number_of_frames++;


			wglMakeCurrent(
				hpbufdc_,	// device context of device that OpenGL calls are to be drawn on
				hpbufglrc_ //hpbufglrc[cpb] 	// OpenGL rendering context to be made the calling thread's current rendering context
				);
		////////////////////////
		// pour amliorer : un seul pbuffer, et des glCopyTexSub
		for (i=0;i<nb_buffers;i++) {
			time+= sub_dt;
//			wglReleaseTexImageARB ( pbuffer[i], WGL_FRONT_LEFT_ARB );
			Draw(time,sub_dt);
		glBindTexture( GL_TEXTURE_2D, pbuffer_tex_id[i]);// texture en cours
		glCopyTexSubImage2D(  GL_TEXTURE_2D,
				0,    //MIMAP level
				0,// xoffset,
				0,// yoffset,
				0,// x,
				0,// y,
				pwidth,// width,
				pheight// height
			);
		}

		width=width_;
		height=height_;
		// dessin a l'ecran
		wglMakeCurrent(
			hDC,	// device context of device that OpenGL calls are to be drawn on
			hRC 	// OpenGL rendering context to be made the calling thread's current rendering context
		);
		glClear( GL_COLOR_BUFFER_BIT);

		DrawEmpty(0);
		if (blur) {
			for (i=1;i<nb_buffers;i++) {
				DrawEmpty(i);
			}
		}
/*		///////////////////////
		// display a string:
		// indicate start of glyph display lists
		glMatrixMode( GL_PROJECTION );
		glLoadIdentity();

		// Setup camera
		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity();
		glDisable(GL_TEXTURE);
		glRasterPos2i(0,0);
		glColor4f(0.5f,1.0f,1.0f,1.0f);

		glListBase (1000);
		// now draw the characters in a string
		//glColor4f(0.0f,1.0f,1.0f,1.0f);
		glCallLists (24, GL_UNSIGNED_BYTE, "Hello Win32 OpenGL World");
		glEnable(GL_TEXTURE);
		//////////////////
*/
		glfwSwapBuffers();

		if (FPS_time_elapsed >=1.0) {

			printf("FPS:%6.2f\n",FPS_number_of_frames/FPS_time_elapsed);
			FPS_time_elapsed=0.0;
			FPS_number_of_frames=0;

		}

		// Check if window was closed
		running = running && glfwGetWindowParam( GLFW_OPENED );
	}

		wglDeleteContext( hpbufglrc_ );
		wglReleasePbufferDCARB( pbuffer_, hpbufdc_ );
		wglDestroyPbufferARB( pbuffer_ );
	// Terminate OpenGL
	glfwTerminate();
	return 0;
}