#include "../../../shared_cpp/OrthographicRenderer.h"
#include "../../../shared_cpp/types.h"
#include "../../../shared_cpp/WebglContext.h"
#include "../../../shared_cpp/mathlib.h"
#include "../../../shared_cpp/MainLoop.h"
#include <cstdio>
#include <cmath>
#include <emscripten/html5.h>
#include <unistd.h>
#include <pthread.h>
#include <cmath>
#include <cfloat>

struct Rigidbody {
    Vector2 force = { 0, 0 };
    Vector2 velocity = { 0, 0 };
    Vector2 position = { 0, 0 };
    float32 rotationalVelocity  = 0.f;
    float32 rotation = 0.f;
    float32 mass = 1.f;
    float32 cofOfRestition = 1.f;
    float32 momentOfInertia = 1.f;

    void reset() {
        force = { 0, 0 };
        velocity = { 0, 0 };
        rotationalVelocity = 0.f;
        rotation = 0.f;
    }

    void applyForce(Vector2 f) {
        force += f;
    }

    void applyGravity(float32 deltaTimeSeconds) {
        velocity += (Vector2 { 0.f, -50.f } * deltaTimeSeconds);
    }

    void update(float32 deltaTimeSeconds) {
        applyGravity(deltaTimeSeconds);
        
        Vector2 acceleration = force / mass;
        velocity += (acceleration * deltaTimeSeconds);
        position += (velocity * deltaTimeSeconds);
        force = Vector2 { 0.f, 0.f };

        rotation += (rotationalVelocity * deltaTimeSeconds);
    }

    void setMomentOfInertia(float32 moi) {
        momentOfInertia = moi;
    }
};

struct IntersectionResult {
    bool intersect = false;
    Vector2 collisionNormal;
    Vector2 relativeVelocity;
    Vector2 firstPointOfApplication;
    Vector2 secondPointOfApplication;
};

struct Edge {
	Vector2 normal;
	Vector2 start;
	Vector2 end;
};

struct ConvexPolygon {
	OrthographicShape shape;
	Rigidbody body;
	Rigidbody previousBody;
	Vector4 color;
	int32 numVertices = 3;
	float32 width = 0.f;
	float32 height = 0.f;

    Vector2* originalVertices;
    Vector2* transformedVertices;
    Edge* edges;

	void load(OrthographicRenderer* renderer) {
        transformedVertices = new Vector2[numVertices]; // This will be used for SAT calculations later
        originalVertices = new Vector2[numVertices];

		// Generate the shape with numVertices many sides in a "fan" shape (i.e. 3  vertices per vertex)
		// The shape will have all equal sides, just to make it easier on me. Therefore, it will fit inside
		// the conditions of a circle, which is fun. Before anyone gets mad: I know I can avoid recalculating
		// a lot of these cosines and sines. I will be okay; I will live. The bigger problem with this demo
		// is the 2k lines of JavaScript that are required to display it.
		int32 verticesNeeded = numVertices * 3;
		float32 angleIncrements = (2.f * PI) / static_cast<float32>(numVertices);
		OrthographicVertex* shaderVertices = new OrthographicVertex[verticesNeeded];
		for (int32 vidx = 0; vidx < numVertices; vidx++) {
			int32 indexPosition = vidx * 3;
			
			float32 firstAngle = angleIncrements * vidx;
		    shaderVertices[indexPosition].position = {  cosf(firstAngle) * width, sinf(firstAngle) * height };

            originalVertices[vidx] = shaderVertices[indexPosition].position;

		    shaderVertices[indexPosition + 1].position = {  0.f, 0.f };

			float32 secondAngle = angleIncrements * (vidx + 1);
			shaderVertices[indexPosition + 2].position = {  cosf(secondAngle) * width, sinf(secondAngle) * height };

			// Apply some global stylings
			for (int subIdx = 0; subIdx < 3; subIdx++) {
			    shaderVertices[indexPosition + subIdx].color = color.toNormalizedColor();
			}
		}

		shape.load(shaderVertices, verticesNeeded, renderer);
		delete[] shaderVertices;

        edges = new Edge[numVertices]; // This will be filled in later when we are doing our SAT calculation.

        // Calculate moment of inertia
        body.setMomentOfInertia((PI * body.mass) / 2.f);
	}

	void update(float32 dtSeconds) {
		previousBody = body;
		
		body.update(dtSeconds);
		shape.model = Mat4x4().translateByVec2(body.position).rotate2D(body.rotation);

        // Populate the current position of our edges
        for (int vidx = 0; vidx < numVertices; vidx++) {
            Vector2 start = shape.model * originalVertices[vidx];
            transformedVertices[vidx] = start;

            Vector2 end = shape.model * originalVertices[vidx == numVertices - 1 ? 0 : vidx + 1];
            edges[vidx] = { (end - start).getPerp().normalize(), start, end };
        }
	}

    void restorePreviousBody() {
        body = previousBody;
    }

	void render(OrthographicRenderer* renderer) {
		shape.render(renderer);
	}

	void unload() {
		shape.unload();

        delete[] originalVertices;
        originalVertices = NULL;

        delete[] transformedVertices;
        transformedVertices = NULL;

        delete[] edges;
        edges = NULL;
	}
};

EM_BOOL onPlayClicked(int eventType, const EmscriptenMouseEvent* mouseEvent, void* userData);
EM_BOOL onStopClicked(int eventType, const EmscriptenMouseEvent* mouseEvent, void* userData);

void load();
void update(float32 time, void* userData);
void unload();

WebglContext context;
OrthographicRenderer renderer;
MainLoop mainLoop;
ConvexPolygon polygons[4];

int main() {
	context.init("#gl_canvas");
    emscripten_set_click_callback("#gl_canvas_play", NULL, false, onPlayClicked);
    emscripten_set_click_callback("#gl_canvas_stop", NULL, false, onStopClicked);
    return 0;
}

void load() {
    renderer.load(&context);

	for (int index = 0; index < 4; index++) {
		polygons[index].width = 50.f;
		polygons[index].height = 50.f;

		if (index == 0) {
			polygons[index].body.position = { context.width / 4.f, context.height / 4.f };
            polygons[index].body.velocity = { 100.f, 200.f };
            polygons[index].body.mass = 2.f;
            polygons[index].body.rotationalVelocity = 0.2f;
		} else if (index == 1) {
			polygons[index].body.position = { context.width / 4.f, context.height * (3.f /4.f) };
            polygons[index].body.velocity = { 50.f, -50.f };
            polygons[index].body.mass = 4.f;
            polygons[index].body.rotationalVelocity = -0.5f;
		} else if (index == 2) {
			polygons[index].body.position = { context.width * (3.f / 4.f), context.height * (3.f / 4.f) };
            polygons[index].body.velocity = { -100.f, -50.f };
            polygons[index].body.mass = 6.f;
            polygons[index].body.rotationalVelocity = 0.9f;
		} else if (index == 3) {
			polygons[index].body.position = { context.width * (3.f / 4.f), context.height / 4.f };
            polygons[index].body.velocity = { -150.f, 50.f };
            polygons[index].body.mass = 8.f;
            polygons[index].body.rotationalVelocity = 1.4f;
		}

		polygons[index].numVertices = (index + 1) * 3;
		polygons[index].color = Vector4 {
			index == 0 || index == 3 ? 255.f : 0.f,
			index == 1 || index == 3 ? 255.f : 0.f,
			index == 2 ? 255.f : 0.f,
			255.f
		};
		polygons[index].load(&renderer);
	}

    printf("Main loop beginning\n");
    mainLoop.run(update);
}

Vector2 getProjection(Vector2* vertices, int numVertices, Vector2 axis) {
	float32 min = axis.dot(vertices[0]);
	float32 max = min;

	for (int v = 1; v < numVertices; v++) {
		float32 d = axis.dot(vertices[v]);

		if (d < min) {
			min = d;
		} else if (d > max) {
			max = d;
		}
	}

	return Vector2 { min, max };
}

bool projectionsOverlap(Vector2 first, Vector2 second) {
	return first.x <= second.y && second.x <= first.y;
}

float32 getProjectionOverlap(Vector2 first, Vector2 second) {
	float32 firstOverlap = fabs(first.x - second.y);
	float32 secondOverlap = fabs(second.x - first.y);
	return firstOverlap > secondOverlap ? secondOverlap : firstOverlap;
}

const float32 EPSILON = 1.f;
IntersectionResult getIntersection(ConvexPolygon* first, ConvexPolygon* second) {
	IntersectionResult ir;

	// For two rectangles to overlap, it means that at least one of the corners of one is inside of the other
	float32 minOverlap = FLT_MAX;
	Edge* minOverlapEdge = NULL;
	bool minOverlapWasFirst = false;
    
	for (int i = 0; i < first->numVertices; i++) {
		Vector2 normal = first->edges[i].normal;

	    Vector2 firstProj = getProjection(first->transformedVertices, first->numVertices, normal);
		Vector2 secondProj = getProjection(second->transformedVertices, second->numVertices, normal);

		if (!projectionsOverlap(firstProj, secondProj)) {
			return ir;
		}

		float32 overlap = getProjectionOverlap(firstProj, secondProj);
		if (overlap < minOverlap) {
			minOverlap = overlap;
			minOverlapEdge = &first->edges[i];
			minOverlapWasFirst = true;
		}
	}

	for (int i = 0; i < second->numVertices; i++) {
		Vector2 normal = second->edges[i].normal;

	    Vector2 firstProj = getProjection(first->transformedVertices, first->numVertices, normal);
		Vector2 secondProj = getProjection(second->transformedVertices, second->numVertices, normal);

		if (!projectionsOverlap(firstProj, secondProj)) {
			return ir;
		}

		float32 overlap = getProjectionOverlap(firstProj, secondProj);
		if (overlap < minOverlap) {
			minOverlap = overlap;
			minOverlapEdge = &second->edges[i];
		}
	}

	ir.intersect = true;
	ir.relativeVelocity = first->body.velocity - second->body.velocity;
	ir.collisionNormal = minOverlapEdge->normal;

    // Time to find just where we intersected
	Vector2 closestPoint;
	float32 minDistance = FLT_MAX;

    
    for (int p = 0; p < (minOverlapWasFirst ? second->numVertices : first->numVertices); p++) {
		Vector2 point = minOverlapWasFirst ? second->transformedVertices[p] : first->transformedVertices[p];

		float32 distFromPointToStart = (minOverlapEdge->start - point).length();
		float32 distFromPointToEnd = (minOverlapEdge->end - point).length();
		float32 potentialMin = MIN(distFromPointToStart, distFromPointToEnd);

		if (potentialMin < minDistance) {
			closestPoint = point;
			minDistance = potentialMin; 
		}
    }
    
    ir.firstPointOfApplication = closestPoint - first->body.position;
    ir.secondPointOfApplication = closestPoint - second->body.position;;

	return ir;
}

void resolveCollision(Rigidbody* first, Rigidbody* second, IntersectionResult* ir) {
    Vector2 relativeVelocity = ir->relativeVelocity;
    Vector2 collisionNormal  = ir->collisionNormal;
    Vector2 firstPerp        = ir->firstPointOfApplication.getPerp();
    Vector2 secondPerp       = ir->secondPointOfApplication.getPerp();
	float32 firstPerpNorm    = firstPerp.dot(collisionNormal);
	float32 sndPerpNorm      = secondPerp.dot(collisionNormal);

    float32 cofOfRestition = (first->cofOfRestition + second->cofOfRestition) / 2.f;
    float32 numerator = (relativeVelocity * (-1 * (1.f + cofOfRestition))).dot(collisionNormal);
    float32 linearDenomPart = collisionNormal.dot(collisionNormal * (1.f / first->mass + 1.f / second->mass));
	float32 rotationalDenomPart = (firstPerpNorm * firstPerpNorm) / first->momentOfInertia + (sndPerpNorm * sndPerpNorm) / second->momentOfInertia;

    // @TODO: Most of my 2D rotational work is pretty broken. Let's ignore it for the time being;
    float32 impulseMagnitude = numerator / (linearDenomPart);// + rotationalDenomPart);
    first->velocity = first->velocity + (collisionNormal * (impulseMagnitude / first->mass));
	second->velocity = second->velocity - (collisionNormal * (impulseMagnitude / second->mass));

    // first->rotationalVelocity = first->rotationalVelocity + firstPerp.dot(collisionNormal * impulseMagnitude) / first->momentOfInertia;
    // second->rotationalVelocity = second->rotationalVelocity - secondPerp.dot(collisionNormal * impulseMagnitude) / second->momentOfInertia;
}

void update(float32 deltaTimeSeconds, void* userData) {
	// Update
	for (int p = 0; p < 4; p++) {
	    polygons[p].update(deltaTimeSeconds);
	}

	// Check collisions with other rectangles
	for (int i = 0; i < 4; i++) {
	    ConvexPolygon* first = &polygons[i];
		for (int j = i + 1; j < 4; j++) {
		    ConvexPolygon* second = &polygons[j];
			
			IntersectionResult ir = getIntersection(first, second);
			if (!ir.intersect) {
				continue;
			}

			// Handle collison here
			IntersectionResult irCopy = ir;
			float32 copyDt = deltaTimeSeconds;
		
			do {
				first->restorePreviousBody();
				second->restorePreviousBody();
				
				ir = irCopy;
				copyDt = copyDt /= 2.f;

			    first->update(copyDt);
				second->update(copyDt);
				
				irCopy = getIntersection(first, second);

				if (copyDt <= 0.f) {
					printf("Error: Should not be happening.\n");
					break;
				}

			} while (irCopy.intersect);

			printf("Found intersection at timestamp: %f\n", copyDt);

			resolveCollision(&first->body, &second->body, &ir);
			float32 frameTimeRemaining = deltaTimeSeconds - copyDt;

			first->update(frameTimeRemaining);
			second->update(frameTimeRemaining);
		}
    }

    // Check collisions with walls
    for (int p = 0; p < 4; p++) {
        ConvexPolygon* polygon = &polygons[p];
        if (polygon->body.position.x <= 0.f) {
            polygon->body.position.x = 0.f;
            polygon->body.velocity = polygon->body.velocity - Vector2 { 1.f, 0.f } * (2 * (polygon->body.velocity.dot(Vector2 { 1.f, 0.f })));
        }
        if (polygon->body.position.y <= 0.f) {
            polygon->body.position.y = 0.f;
            polygon->body.velocity = polygon->body.velocity - Vector2 { 0.f, 1.f } * (2 * (polygon->body.velocity.dot(Vector2 { 0.f, 1.f })));
        } 
        if (polygon->body.position.x >= 800.f) {
            polygon->body.position.x = 800.f;
            polygon->body.velocity = polygon->body.velocity - Vector2 { -1.f, 0.f } * (2 * (polygon->body.velocity.dot(Vector2{ -1.f, 0.f })));
        }
        if (polygon->body.position.y >= 600.f) {
            polygon->body.position.y = 600.f;
            polygon->body.velocity = polygon->body.velocity - Vector2 { 0.f, -1.f } * (2 * (polygon->body.velocity.dot(Vector2 { 0.f, -1.f }))) ;
        }
    }
	
	// Renderer
	renderer.render();
	for (int p = 0; p < 4; p++) {
	    polygons[p].render(&renderer);
	}
}

void unload() {
    mainLoop.stop();
    renderer.unload();
	for (int p = 0; p < 4; p++) {
	    polygons[p].unload();
	}
}

//
// Interactions with DOM handled below
//
EM_BOOL onPlayClicked(int eventType, const EmscriptenMouseEvent* mouseEvent, void* userData) {
    printf("Play clicked\n");
    
    load();
    return true;
}

EM_BOOL onStopClicked(int eventType, const EmscriptenMouseEvent* mouseEvent, void* userData) {
    printf("Stop clicked\n");
    unload();
    return true;
}