#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>

#include <fgc.h>

#define ZONE_DATA FGCColor backFog, backSky, foreFog, foreSky;
#include <zone.h>

FGCTexture tex_cyan, tex_paused, tex_wall;

mat4 viewMat, projMat;

double cameraAngleX = 0.0, cameraAngleY = 0.0;
vec3 cameraPosition = {0.0, 1.5, 3.0};

double meshAngle = 0.0;

bool paused = false;

FGCFramebuffer gbuffer =
#ifdef __cplusplus
	{};
#else
	{0};
#endif

const char* skyLitVert =
"uniform mat4 u_matrices[6]; // 0:mvp 1:mv 2:m 3:nrm 4:tex 5:light   \n"
"uniform vec3 u_camera;                                              \n"
"layout(location = 0) in vec4 a_Position;                            \n"
"layout(location = 1) in vec4 a_Normal;                              \n"
"layout(location = 2) in vec4 a_UV;                                  \n"
"out vec2 v_UV;                                                      \n"
"out vec4 v_RelativePos;                                             \n"
"out vec3 v_Normal;                                                  \n"
"out vec3 v_Position;                                                \n"
"out vec3 v_ToCamera;                                                \n"
"void main(){                                                        \n"
"   v_UV = vec2(u_matrices[4] * a_UV);                               \n"
"   v_RelativePos = u_matrices[1] * a_Position;                      \n"
"   v_Normal = vec3(u_matrices[3] * a_Normal);                       \n"
"   mat4 m = u_matrices[2];                                          \n"
"   // Remove the positional offset from the model matrix.           \n"
"   m[3] = vec4(0.0, 0.0, 0.0, 1.0);                                 \n"
"   v_Position = vec3(m * a_Position);                               \n"
"   // (relative cam pos) - (vert pos without model pos offset)      \n"
"   v_ToCamera = u_camera - v_Position;                              \n"
"   gl_Position = u_matrices[0] * a_Position;                        \n"
"}";

const char* skyLitFrag =
"uniform sampler2D u_texture;                                        \n"
"uniform vec4 u_fog;                                                 \n"
"uniform vec4 u_sky;                                                 \n"
"uniform vec3 u_camera;                                              \n"
"in vec2 v_UV;                                                       \n"
"in vec4 v_RelativePos;                                              \n"
"in vec3 v_Normal;                                                   \n"
"in vec3 v_Position;                                                 \n"
"in vec3 v_ToCamera;                                                 \n"
"layout(location = 0) out vec4 fragColor;                            \n"
"vec4 SkyColor(vec3 A, float hard){                                  \n"
"	float v = max(A.y, 0.0);                                         \n"
"	float hardCurve = pow(hard, 8.0) * 100.0;                        \n"
"	vec3 glow = u_sky.rgb * (1.0 - v)                                \n"
"		* clamp(A.y * hardCurve + 1.0, 0.0, 1.0);                    \n"
"	return vec4(u_fog.rgb + glow, 1.0);                              \n"
"}                                                                   \n"
"vec3 FresnelSchlickRoughness(float cosTheta, vec3 F0, float rough){ \n"
"   return F0 + (max(vec3(1.0-rough),F0)-F0) * pow(1.0-cosTheta,5.0);\n"
"}                                                                   \n"
"void main(){                                                        \n"
"   vec4 baseColor = texture(u_texture, v_UV);                       \n"
"   if(baseColor.a < 0.001) discard;                                 \n"
"   float rough = 0.4;                                               \n"
"   vec3 N = normalize(v_Normal);                                    \n"
"   vec3 V = normalize(u_camera - v_Position);                       \n"
"   vec3 R = reflect(-V, N);                                         \n"
"   // Dot product of camera and normal vectors.                     \n"
"   float cosTheta = max(dot(normalize(v_ToCamera), N), -0.1);       \n"
"   // Schlick's approximation.                                      \n"
"   vec3 kS = FresnelSchlickRoughness(cosTheta, vec3(0.04), rough);  \n"
"   vec3 kD = 1.0 - kS;                                              \n"
"   // Specular.                                                     \n"
"   vec3 spec = kS * SkyColor(R, 1.0 - rough * 0.5).xyz;             \n"
"   // Diffuse. Multiply the irradiant light by the base color.      \n"
"   vec3 dif = baseColor.rgb * kD * SkyColor(N, 0.5).xyz;            \n"
"   // Interpolate between lit color and sky.                        \n"
"   float vis = 1.0 / exp(length(v_RelativePos) * u_fog.a);          \n"
"   fragColor =                                                      \n"
"   //vec4(mix(SkyColor(-V, 1.0-vis).xyz, dif+spec, vis), baseColor.a);\n"
"vec4(N, baseColor.a);"
"}";

const char* skyLitSamplers[] = { "u_texture", 0 };

FGCPipeline skyLitPipeline;

const char* skyVert =
"uniform mat4 u_matrices[6]; // 0:mvp 1:mv 2:m 3:nrm 4:tex 5:light   \n"
"layout(location = 0) in vec4 a_Position;                            \n"
"layout(location = 1) in vec4 a_Normal;                              \n"
"layout(location = 2) in vec4 a_UV;                                  \n"
"out vec3 v_STR;                                                     \n"
"void main(){                                                        \n"
"   v_STR = a_Position.xyz;                                          \n"
"   vec4 pos = u_matrices[0] * a_Position;                           \n"
"   gl_Position = pos.xyww;                                          \n"
"}";

const char* gradientSkyFrag =
"uniform vec4 u_fog;                                                 \n"
"uniform vec4 u_sky;                                                 \n"
"uniform vec3 u_camera;                                              \n"
"in vec3 v_STR;                                                      \n"
"layout(location = 0) out vec4 fragColor;                            \n"
"//https://gist.github.com/patriciogonzalezvivo/670c22f3966e662d2f83 \n"
"vec4 mod289(vec4 x){return x - floor(x * (1.0 / 289.0)) * 289.0;}   \n"
"vec4 perm(vec4 x){return mod289(((x * 34.0) + 1.0) * x);}           \n"
"float Noise(vec3 p){                                                \n"
"	vec3 a = floor(p);                                               \n"
"	vec3 d = p - a;                                                  \n"
"	d = d * d * (3.0 - 2.0 * d);                                     \n"
"	vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);                      \n"
"	vec4 k1 = perm(b.xyxy);                                          \n"
"	vec4 k2 = perm(k1.xyxy + b.zzww);                                \n"
"	vec4 c = k2 + a.zzzz;                                            \n"
"	vec4 k3 = perm(c);                                               \n"
"	vec4 k4 = perm(c + 1.0);                                         \n"
"	vec4 o1 = fract(k3 * (1.0 / 41.0));                              \n"
"	vec4 o2 = fract(k4 * (1.0 / 41.0));                              \n"
"	vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);                           \n"
"	vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);                     \n"
"	return o4.y * d.y + o4.x * (1.0 - d.y);                          \n"
"}                                                                   \n"
"vec4 SkyColor(vec3 A, float hard){                                  \n"
"	float v = max(A.y, 0.0);                                         \n"
"	float hardCurve = pow(hard, 8.0) * 100.0;                        \n"
"	vec3 glow = u_sky.rgb * (1.0 - v)                                \n"
"		* clamp(A.y * hardCurve + 1.0, 0.0, 1.0);                    \n"
"   return vec4(u_fog.rgb + glow, 1.0)                               \n"
"     + clamp((Noise(normalize(A)*180.0)*0.194-0.189)*180.0,0.0,1.0) \n"
"     * u_sky.a * clamp(A.y * 100.0 + 1.0, 0.0, 1.0); // Horizon.    \n"
"}                                                                   \n"
"void main(){                                                        \n"
"   vec3 N = normalize(v_STR);                                       \n"
"   fragColor = SkyColor(N, 1.0);                                    \n"
"}";

const char* gradientSkySamplers[] = {0};

FGCPipeline gradientSkyPipeline;

FGCColor LerpColor(FGCColor ca, FGCColor cb, float f){
	return (FGCColor){
		f * (cb.r - ca.r) + ca.r,
		f * (cb.g - ca.g) + ca.g,
		f * (cb.b - ca.b) + ca.b,
		f * (cb.a - ca.a) + ca.a
	};
}

void DrawSky(
		mat4 viewMat,
		mat4 projMat,
		FGCPipeline pipe,
		FGCColor fog,
		FGCColor sky){
	if(!pipe.success) return;
	FGCPipeline old_pipeline = fgcDrawPipeline;
	fgcSetPipeline(pipe);
	glUniform4f(fgcDrawPipeline.u_fog, fog.r, fog.g, fog.b, fog.a);
	glUniform4f( // TODO: Maybe store this uniform location somewhere.
		glGetUniformLocation(fgcDrawPipeline.programObject, "u_sky"),
		sky.r, sky.g, sky.b, sky.a
	);
	glDisable(GL_CULL_FACE);
	// Extract the 3x3 rotation matrix from the view matrix.
	// The camera is effectively at <0,0,0> with the skybox.
	fgcDrawMesh(
		&fgcCubeMesh,
		MAT4_IDEN,
		MAT4(
			viewMat.m[0][0], viewMat.m[0][1], viewMat.m[0][2], 0.0,
			viewMat.m[1][0], viewMat.m[1][1], viewMat.m[1][2], 0.0,
			viewMat.m[2][0], viewMat.m[2][1], viewMat.m[2][2], 0.0,
			0.0,             0.0,             0.0,             1.0
		),
		projMat
	);
	glUniform4f(fgcDrawPipeline.u_fog, fgcFogColor.r, fgcFogColor.g, fgcFogColor.b, fgcFogColor.a);
	fgcSetPipeline(old_pipeline);
	glEnable(GL_CULL_FACE);
}

// Draw an image with position, rotation, and scaling.
void DrawImage(FGCTexture tex, float posX, float posY, float angle, float scaleX, float scaleY){
	double screenWidth = fgcGetDisplayWidth(), screenHeight = fgcGetDisplayHeight();
	double textureWidth = tex.width, textureHeight = tex.height;
	fgcSetTexture(tex, 0);
	fgcDrawMesh(
		&fgcPlaneMesh,
		mat4MultiplyMatrix(
			mat4SetTranslation(VEC3(
				(textureWidth * 0.5 * scaleX + posX) / screenHeight * 2.0 - screenWidth / screenHeight,
				(textureHeight * 0.5 * scaleY + posY) / screenHeight * -2.0 + 1.0,
				0.0
			)),
			mat4MultiplyMatrix(
				mat4SetRotationQuaternion(fgcEulerToQuat(0.0, 0.0, angle)),
				mat4SetScaleXYZ(VEC3(
					textureWidth / screenHeight * scaleX * 2.0,
					textureHeight / screenHeight * scaleY * 2.0,
					1.0
				))
			)
		),
		MAT4_IDEN,
		mat4SetScaleXYZ(VEC3(screenHeight / screenWidth, 1.0, 1.0))
	);
}

// Pause or unpause the game.
void PauseGame(bool pause){
	paused = pause;
	if(fgcMouseTrapped == pause) fgcTrapMouse(!pause);
}

void SubjectiveCamera(double sensitivity, double speed, bool fly){
	// Rotate the camera with the mouse.
	cameraAngleX = fmin(fmax(cameraAngleX - fgcMouseMoveY * sensitivity, -1.570796), 1.570796);
	cameraAngleY -= fgcMouseMoveX * sensitivity;
	// Move the player with directional input.
	vec2 move = VEC2(
		(fgcRightKey() || fgcCharKey('d')) -
		(fgcLeftKey()  || fgcCharKey('a')),
		(fgcDownKey()  || fgcCharKey('s')) -
		(fgcUpKey()    || fgcCharKey('w')));
	// Get the length of the Y plane of the translation vector.
	double moveLength = vec2Length(move);
	// Apply the lateral translation.
	if(moveLength > 0.1){
		// Get the Y angle of the move vector plus the Y angle of the camera.
		move = vec2Normalize(move);
		double moveAngle = atan2(move.x, move.y) + cameraAngleY;
		cameraPosition.x += sin(moveAngle) * speed;
		cameraPosition.z += cos(moveAngle) * speed;
	}
	// Apply the vertical translation.
	if(fly)
		cameraPosition.y += (fgcSpaceKey() - fgcControlKey()) * speed;
}

void Render(double d){
	if(fgcEscapeKey() || fgcAltKey() || !fgcHasFocus) PauseGame(true);
	if(paused) d = 0.0;
	double width = fgcGetDisplayWidth();
	double height = fgcGetDisplayHeight();
	double aspect = width / height;

	// Resize the gbuffer to the screen.
	fgcResizeFramebuffer(&gbuffer, width, height, 0);
	// Draw to the gbuffer.
	fgcSetFramebuffer(&gbuffer, 1.0f);
	// Clear the depth buffer.
	glClear(GL_DEPTH_BUFFER_BIT);

	if(!paused) SubjectiveCamera(0.003, 3.0 * d, false);

	mat4 viewRot = mat4SetRotationQuaternion(fgcEulerToQuat(cameraAngleX, cameraAngleY, 0.0));
	viewMat = mat4Translate(viewRot, cameraPosition);
	projMat = mat4Perspective(acos(-1) * 0.4, aspect, 0.1, 100.0);

	meshAngle = fgcWrapAngle(meshAngle - d);

	// Update visualZone.
	ZoneUpdate(viewMat.col[3].x, viewMat.col[3].y, viewMat.col[3].z, d * 2.0);
	if(zoneA && zoneB){
		visualZone.backFog = LerpColor(zoneA->backFog, zoneB->backFog, (float)zoneF);
		visualZone.backSky = LerpColor(zoneA->backSky, zoneB->backSky, (float)zoneF);
		visualZone.foreFog = LerpColor(zoneA->foreFog, zoneB->foreFog, (float)zoneF);
		visualZone.foreSky = LerpColor(zoneA->foreSky, zoneB->foreSky, (float)zoneF);
	}

	fgcSetPipeline(skyLitPipeline);

	// Set foreground parameters.
	fgcSetFog(visualZone.foreFog);
	glUniform4f(
		glGetUniformLocation(skyLitPipeline.programObject, "u_sky"),
		visualZone.foreSky.r, visualZone.foreSky.g, visualZone.foreSky.b, visualZone.foreSky.a
	);

	// Draw opaque.
	glDisable(GL_BLEND);

	fgcSetTexture(tex_wall, 0);
	mat4 cubemat = mat4Translate(
		mat4SetRotationQuaternion(fgcEulerToQuat(0.67, meshAngle, 0.67)),
		VEC3(0.0, 0.9, 0.0));
	fgcDrawMesh(&fgcCubeMesh, cubemat, viewMat, projMat);
	fgcTexMatrix = mat4SetScaleXYZ(VEC3(16.0, 16.0, 16.0));
	fgcDrawMesh(&fgcPlaneMesh, mat4Scale(mat4SetRotationX(-1.570796), 32.0), viewMat, projMat);
	fgcTexMatrix = MAT4_IDEN;

	// Draw the sky/background.
	// Exterior sky colors should generally be used regardless of interior ambient lighting conditions.
	DrawSky(viewRot, projMat, gradientSkyPipeline, visualZone.backFog, visualZone.backSky);

	// End of lighting pass.
	fgcSetPipeline(fgcUnlitPipeline);

	// Draw the gbuffer to the screen.
	fgcSetFramebuffer(NULL, 1.0f);
	fgcDrawFramebuffer(&gbuffer, false, 1.0f);

	// Draw transparent.
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	if(paused){
		fgcSetTexture(tex_paused, 0);
		fgcDrawMesh(&fgcPlaneMesh, mat4SetScaleXYZ(VEC3(height / width, 1.0, 1.0)), MAT4_IDEN, MAT4_IDEN);
		if(fgcMouseButton(1)) PauseGame(false);
		// Reduce power consumption by imposing a small delay.
		SDL_Delay(50);
	}
}

int main(){
	#if defined(__GLIBC__) && defined(__GLIBC_MINOR__)
		printf("Built with glibc %d.%d\n", __GLIBC__, __GLIBC_MINOR__);
	#endif

	FGCDisplayInfo disp = fgcCreateDisplay(1024, 576, "cfps", 0, false, true);
	if(!disp.success) return 0;

	skyLitPipeline =
		fgcLoadPipeline(skyLitVert, skyLitFrag, skyLitSamplers);
	if(skyLitPipeline.success){
		if(fgcVerbose)
			printf("Sky-lit pipeline loaded successfully.\n");
	}else{
		fprintf(stderr, "Failed to load sky-lit pipeline.\n");
	}

	gradientSkyPipeline =
		fgcLoadPipeline(skyVert, gradientSkyFrag, gradientSkySamplers);
	if(gradientSkyPipeline.success){
		if(fgcVerbose)
			printf("Gradient sky pipeline loaded successfully.\n");
	}else{
		fprintf(stderr, "Failed to load gradient sky pipeline.\n");
	}

	// Create the gbuffer.
	gbuffer = fgcCreateFramebuffer(fgcGetDisplayWidth(), fgcGetDisplayHeight(), false, GL_RGB, 0);

	tex_cyan = fgcLoadSolidColorTexture((FGCColor){0.0, 1.0, 1.0, 1.0});
	tex_paused = fgcLoadTexture("base/paused.png", true, true);
	tex_wall = fgcLoadTexture("base/wall.png", true, true);

	// Create the lowest-priority zone with +/- 100km extents.
	ZoneAdd((Zone){(FGCColor){0.0, 0.2, 0.35, 0.05},
		(FGCColor){0.1, 0.1, 0.0, 1.0},
		(FGCColor){0.0, 0.2, 0.35, 0.05},
		(FGCColor){0.1, 0.1, 0.0, 1.0}, -1e5, 1e5, -1e5, 1e5, -1e5, 1e5,
		0, NULL, NULL});

	// Create an interior zone.
	ZoneAdd((Zone){(FGCColor){0.0, 0.2, 0.35, 0.05},
		(FGCColor){0.1, 0.1, 0.0, 1.0},
		(FGCColor){0.0, 0.2, 0.35, 0.05},
		(FGCColor){0.0, 0.0, 0.0, 1.0}, -2.0, 2.0, 0.0, 3.0, -2.0, 2.0,
		1, NULL, NULL});

	PauseGame(false);

	fgcSetMainLoop(Render);

	return 0;
}