#include <GL/glut.h>
#include <math.h>
#include <stdio.h>
#include <time.h>
#include <Cg/cg.h>
#include <Cg/cgGL.h>

// Define a constant for the value of PI
#define GL_PI 3.1415f

GLfloat xRot = 300.0f;
GLfloat zRot = 30.0f;

static CGcontext   myCgContext;
static CGprofile   myCgVertexProfile;
static CGprogram   myCgVertexProgram;
static CGprofile   myCgFragmentProfile;
static CGprogram   myCgFragmentProgram;

static const char *myProgramName = "Water_Surafce_Progarm_Base",
                  *myVertexProgramFileName = "WaterVertex.cg",
                  *myVertexProgramName = "vert_shader",
                  *myFragmentProgramFileName = "WaterFregment.cg",
                  *myFragmentProgramName = "fregm_shader";

static CGparameter myCgVertexParam_timestamp;
static CGparameter myCgVertexParam_grid_size;

static CGparameter myCgFragmentParam_globalAmbient;
static CGparameter myCgFragmentParam_lightColor;
static CGparameter myCgFragmentParam_lightPosition;
static CGparameter myCgFragmentParam_eyePosition;
static CGparameter myCgFragmentParam_Ke;
static CGparameter myCgFragmentParam_Ka;
static CGparameter myCgFragmentParam_Kd;
static CGparameter myCgFragmentParam_Ks;
static CGparameter myCgFragmentParam_shininess;

static float timestamp = 0.0f;

static float globalAmbient[]	= {0.3f, 0.3f, 0.3f};
static float lightColor[]		= {0.2f, 0.2f, 0.8f};
static float lightPosition[]	= {0.0f, 200.0f, -100.0f};
static float eyePosition[]		= {0.0f, 0.0f, 50.0f};
static float Ke[]				= {0.0f, 0.0f, 0.0f};
static float Ka[]				= {1.0f, 1.0f, 1.0f};
static float Kd[]				= {0.6f, 0.6f, 0.6f};
static float Ks[]				= {1.0f, 1.0f, 1.0f};
static float shininess			= 100;


static void checkForCgError(const char *situation)
{
  CGerror error;
  const char *string = cgGetLastErrorString(&error);

  if (error != CG_NO_ERROR) {
    printf("%s: %s: %s\n",
      myProgramName, situation, string);
    if (error == CG_COMPILER_ERROR) {
      printf("%s\n", cgGetLastListing(myCgContext));
    }
    exit(1);
  }
}

void drawSurface(int stacks, float size) {
	int i, j;

	float height;
	float width;

	glNormal3f(0.0f, 0.0f, 1.0f);

	for(i=0, height=-size/2; i<stacks; i++, height+=size/stacks) {

		width = -height/2;

		glBegin(GL_QUAD_STRIP);
		for(j=0, width=-size/2; j<=stacks; j++, width+=size/stacks) {
			glTexCoord2f(j/(float)stacks, i/(float)stacks);
			glVertex3f(width, height, 0);
			glTexCoord2f(j/(float)stacks, (i+1)/(float)stacks);
			glVertex3f(width, height + size/stacks, 0);
		}

		glEnd();
	}

	return;
}


// Called to draw scene
void RenderScene(void)
{
	int i;
	double angle;

	// Clear the window with current clearing color
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	timestamp = clock()/1000.0;

	glPushMatrix();
	glRotatef(xRot, 1.0f, 0.0f, 0.0f);
	glRotatef(zRot, 0.0f, 0.0f, 1.0f);

	// >> Modellezo programresz

	cgSetParameter1f(myCgVertexParam_timestamp, timestamp);
	cgSetParameter1f(myCgVertexParam_grid_size, 200);

	cgSetParameter3fv(myCgFragmentParam_globalAmbient, globalAmbient);
	cgSetParameter3fv(myCgFragmentParam_lightColor, lightColor);
	cgSetParameter3fv(myCgFragmentParam_lightPosition, lightPosition);
	cgSetParameter3fv(myCgFragmentParam_eyePosition, eyePosition);
	cgSetParameter3fv(myCgFragmentParam_Ke, Ke);
	cgSetParameter3fv(myCgFragmentParam_Ka, Ka);
	cgSetParameter3fv(myCgFragmentParam_Kd, Kd);
	cgSetParameter3fv(myCgFragmentParam_Ks, Ks);
	cgSetParameter1f(myCgFragmentParam_shininess, shininess);

	cgGLBindProgram(myCgVertexProgram);
	checkForCgError("binding vertex program");
	cgGLEnableProfile(myCgVertexProfile);
	checkForCgError("enabling vertex profile");

	cgGLBindProgram(myCgFragmentProgram);
	checkForCgError("binding fragment program");
	cgGLEnableProfile(myCgFragmentProfile);
	checkForCgError("enabling fragment profile");

	drawSurface(200, 200);

	cgGLDisableProfile(myCgFragmentProfile);
	checkForCgError("disabling fragment profile");

	cgGLDisableProfile(myCgVertexProfile);
	checkForCgError("disabling vertex profile");

	// << Modellezo programresz

	glPopMatrix();

	// Flush drawing commands
	glutSwapBuffers();
}

void initCg()
{
	myCgContext = cgCreateContext();
	checkForCgError("creating context");
	cgSetParameterSettingMode(myCgContext, CG_DEFERRED_PARAMETER_SETTING);

	myCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
	cgGLSetOptimalOptions(myCgVertexProfile);
	checkForCgError("selecting vertex profile");

	myCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
	cgGLSetOptimalOptions(myCgFragmentProfile);
	checkForCgError("selecting fragment profile");

	myCgVertexProgram =
		cgCreateProgramFromFile(
			myCgContext,                /* Cg runtime context */
			CG_SOURCE,                  /* Program in human-readable form */
			myVertexProgramFileName,    /* Name of file containing program */
			myCgVertexProfile,          /* Profile: OpenGL ARB vertex program */
			myVertexProgramName,        /* Entry function name */
			NULL);                      /* No extra compiler options */
	checkForCgError("creating vertex program from file");

	myCgFragmentProgram =
		cgCreateProgramFromFile(
			myCgContext,                /* Cg runtime context */
			CG_SOURCE,                  /* Program in human-readable form */
			myFragmentProgramFileName,  /* Name of file containing program */
			myCgFragmentProfile,        /* Profile: OpenGL ARB vertex program */
			myFragmentProgramName,      /* Entry function name */
			NULL);                      /* No extra compiler options */
	checkForCgError("creating fragment program from file");

	cgGLLoadProgram(myCgVertexProgram);
	checkForCgError("loading vertex program");

	cgGLLoadProgram(myCgFragmentProgram);
	checkForCgError("loading fragment program");

	myCgVertexParam_timestamp =
		cgGetNamedParameter(myCgVertexProgram, "timestamp");
	checkForCgError("could not get twisting parameter");

	myCgVertexParam_grid_size =
		cgGetNamedParameter(myCgVertexProgram, "grid_size");
	checkForCgError("could not get grid_size parameter");

	myCgFragmentParam_globalAmbient =
		cgGetNamedParameter(myCgFragmentProgram, "globalAmbient");
	checkForCgError("could not get globalAmbient parameter");

	myCgFragmentParam_lightColor =
		cgGetNamedParameter(myCgFragmentProgram, "lightColor");
	checkForCgError("could not get lightColor parameter");

	myCgFragmentParam_lightPosition =
		cgGetNamedParameter(myCgFragmentProgram, "lightPosition");
	checkForCgError("could not get lightPosition parameter");

	myCgFragmentParam_eyePosition =
		cgGetNamedParameter(myCgFragmentProgram, "eyePosition");
	checkForCgError("could not get eyePosition parameter");

	myCgFragmentParam_Ke =
		cgGetNamedParameter(myCgFragmentProgram, "Ke");
	checkForCgError("could not get Ke parameter");

	myCgFragmentParam_Ka =
		cgGetNamedParameter(myCgFragmentProgram, "Ka");
	checkForCgError("could not get Ka parameter");

	myCgFragmentParam_Kd =
		cgGetNamedParameter(myCgFragmentProgram, "Kd");
	checkForCgError("could not get Kd parameter");

	myCgFragmentParam_Ks =
		cgGetNamedParameter(myCgFragmentProgram, "Ks");
	checkForCgError("could not get Ks parameter");

	myCgFragmentParam_shininess =
		cgGetNamedParameter(myCgFragmentProgram, "shininess");
	checkForCgError("could not get shininess parameter");

	return;
}

// This function does any needed initialization on the rendering
// context. 
void SetupRC()
{
	initCg();

	// Black background
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
	glEnable(GL_DEPTH_TEST);

}

void SpecialKeys(int key, int x, int y)
{
	// ...
	int state;

	if(key == GLUT_KEY_UP)
		xRot-= 5.0f;
  
	if(key == GLUT_KEY_DOWN)
		xRot += 5.0f;
  
	if(key == GLUT_KEY_LEFT)
		zRot -= 5.0f;
  
	if(key == GLUT_KEY_RIGHT)
		zRot += 5.0f;
  
	if(xRot > 356.0f)
		xRot = 0.0f;
  
	if(xRot < 0.0f)
		xRot = 355.0f;
  
	if(zRot > 356.0f)
		zRot = 0.0f;
  
	if(zRot < -1.0f)
		zRot = 355.0f;

	printf("Funkciobillentyu lenyomva, kodja %d, pozicio (%d,%d). ", key, x, y);
	state = glutGetModifiers();
	if(state & GLUT_ACTIVE_SHIFT)
		printf("SHIFT lenyomva. ");
	if(state & GLUT_ACTIVE_CTRL)
		printf("CTRL lenyomva. ");
	if(state & GLUT_ACTIVE_ALT)
		printf("ALT lenyomva. ");
	printf("\n");
	fflush(stdout);

	// Refresh the Window
	glutPostRedisplay();
}

void Keyboard(unsigned char key, int x, int y)
{
	// ...
	int state;

	printf("Billentyu lenyomva, kodja %c, pozicio (%d,%d). ", key, x, y);
	state = glutGetModifiers();
	if(state & GLUT_ACTIVE_SHIFT)
		printf("SHIFT lenyomva. ");
	if(state & GLUT_ACTIVE_CTRL)
		printf("CTRL lenyomva. ");
	if(state & GLUT_ACTIVE_ALT)
		printf("ALT lenyomva. ");
	printf("\n");
	fflush(stdout);

	glutPostRedisplay();
}

void Timer(int value)
{
	printf("Timer esemeny (%d)\n", value);

	glutPostRedisplay();
	glutTimerFunc(1000, Timer, value + 1);
}

void Idle()
{

	glutPostRedisplay();
}

void ChangeSizeOrtho(int w, int h)
{
	GLfloat nRange = 25.0f;
  
	// Prevent a divide by zero
	if(h == 0)
		h = 1;
  
	// Set Viewport to window dimensions
	glViewport(0, 0, w, h);
  
	// Reset projection matrix stack
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
  
	// Establish clipping volume (left, right, bottom, top, near, far)
	if (w <= h) 
		glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
	else 
		glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);
  
	// Reset Model view matrix stack
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

void ChangeSizePerspective(GLsizei w, GLsizei h)
{
	GLfloat fAspect;
  
	// Prevent a divide by zero
	if(h == 0)
		h = 1;
  
	// Set Viewport to window dimensions
	glViewport(0, 0, w, h);
  
	fAspect = (GLfloat)w/(GLfloat)h;
  
	// Reset coordinate system
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
  
	// Produce the perspective projection
	gluPerspective(	60.0f,    // fovy
					fAspect,  // aspect
					10.0,     // zNear
					200.0     // zFar
					);
	gluLookAt(	0.0, 0.0, 50.0, // eye
				0.0, 0.0, 0.0,  // center
				0.0, 1.0, 0.0   // up
				);
  
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

int main(int argc, char* argv[])
{
	// >> Inicializalas

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	//glutInitWindowSize(300, 300);
	glutCreateWindow("GLUT Alap");

	// << Inicializalas

	// >> Callback fuggvenyek

	//glutReshapeFunc(ChangeSizeOrtho); // Parhuzamos vetites
	glutReshapeFunc(ChangeSizePerspective); // Perspektiv vetites

	glutSpecialFunc(SpecialKeys);
	glutKeyboardFunc(Keyboard);
	glutDisplayFunc(RenderScene);
	//glutTimerFunc(1000, Timer, 1); // 1 mp mulva meghivodik a Timer() fuggveny
	glutIdleFunc(Idle); // Idle(), ha nem tortenik semmi
  
	// << Callback fuggvenyek

	SetupRC();
	glutMainLoop();
  
	return 0;
}