#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 linearForce = { 0, 0 };
    Vector2 velocity = { 0, 0 };
    Vector2 position = { 0, 0 };
    float32 mass = 1.f;

	float32 torque = 0.f;
	float32 rotationalVelocity = 0.f;
	float32 rotation = 0.f;
	float32 momentOfInertia = 1.f;
	float32 cofOfRestitution = 1.f;

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

    void applyForce(Vector2 force, Vector2 pointOfApplication) {
        linearForce += force;
	    torque += pointOfApplication.getPerp().dot(force);
    }

    void applyGravity() {
		applyForce(Vector2 { 0.f, -100.f }, Vector2 { 0.f, 0.f });
    }

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

		// New: Update the rotational velocity as well
		float32 rotationalAcceleration = torque / momentOfInertia;
		rotationalVelocity += (rotationalAcceleration * deltaTimeSeconds);
		rotation += (rotationalVelocity * deltaTimeSeconds);
		torque = 0.f;
    }
};

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

struct Rectangle {
	OrthographicShape shape;
    Rigidbody body;
	Rigidbody previousBody;
	Vector2 originalPoints[4];
	Vector2 transformedPoints[4];
	Edge edges[4];

	void load(OrthographicRenderer* renderer, Vector4 color, float32 width, float32 height) {
        color = color.toNormalizedColor();

		float32 halfWidth = width / 2.f;
		float32 halfHeight = height / 2.f;

	    OrthographicVertex vertices[6];
		vertices[0].position = Vector2 { -halfWidth, -halfHeight };
		vertices[1].position = Vector2 { -halfWidth, halfHeight };
		vertices[2].position = Vector2 { halfWidth, halfHeight };
		vertices[3].position = Vector2 { -halfWidth, -halfHeight };
		vertices[4].position = Vector2 { halfWidth, -halfHeight };
		vertices[5].position = Vector2 { halfWidth, halfHeight };
		
		for (int32 i = 0; i < 6; i++) {
			vertices[i].color = color;
		}

		originalPoints[0] = vertices[0].position;
		originalPoints[1] = vertices[1].position;
		originalPoints[2] = vertices[2].position;
		originalPoints[3] = vertices[4].position;
		
		shape.load(vertices, 6, renderer);
		body.reset();

		body.momentOfInertia = (width * width + height * height) * (body.mass / 12.f);
	}

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

		// Note: This helps us check rectangle collisions using SAT later on.
		// This is probably a slightly slow way of doing this, but we will ignore
		// that for now.
		for (int idx = 0; idx < 4; idx++) {
			transformedPoints[idx] = shape.model * originalPoints[idx];
		}

		for (int eidx = 0; eidx < 4; eidx++) {
			edges[eidx].start = transformedPoints[eidx];
			edges[eidx].end = transformedPoints[eidx == 3 ? 0 : eidx + 1];
			edges[eidx].normal = (edges[eidx].end - edges[eidx].start).getPerp().normalize();
		}
	}

	void restorePreviousBody() {
		body = previousBody;
	}

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

	void unload() {
		shape.unload();
	}
};

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

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;
Rectangle r1;
Rectangle r2;

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

    r1.load(&renderer, Vector4 { 55.f, 235.f, 35.f, 255.f }, 128.f, 64.f);
	r1.body.mass = 3.f;
    r1.body.position = Vector2 { context.width / 4.f, context.height / 4.f };
	r1.body.velocity = Vector2 { 100.f, 250.f };

	r2.load(&renderer, Vector4 { 235.f, 5.f, 35.f, 255.f }, 96.f, 64.f);
	r2.body.mass = 1.f;
    r2.body.position = Vector2 { context.width * (3.f / 4.f), context.height * (3.f / 4.f) };
	r2.body.velocity = Vector2 { -300.f, -150.f };
	r2.body.rotationalVelocity = 0.9f;

    mainLoop.run(update);
}

void handleCollisionWithWall(Rectangle* r) {
	if (r->body.position.x <= 0.f) {
        r->body.position.x = 0.f;
        r->body.velocity = r->body.velocity - Vector2 { 1.f, 0.f } * (2 * (r->body.velocity.dot(Vector2 { 1.f, 0.f })));
    }
    if (r->body.position.y <= 0.f) {
        r->body.position.y = 0.f;
        r->body.velocity = r->body.velocity - Vector2 { 0.f, 1.f } * (2 * (r->body.velocity.dot(Vector2 { 0.f, 1.f })));
    } 
    if (r->body.position.x >= 800.f) {
        r->body.position.x = 800.f;
        r->body.velocity = r->body.velocity - Vector2 { -1.f, 0.f } * (2 * (r->body.velocity.dot(Vector2{ -1.f, 0.f })));
    }
    if (r->body.position.y >= 600.f) {
        r->body.position.y = 600.f;
        r->body.velocity = r->body.velocity - Vector2 { 0.f, -1.f } * (2 * (r->body.velocity.dot(Vector2 { 0.f, -1.f }))) ;
    }
}

/*
  Do not worry about how w are exactly finding the intersection here, for now.
  We are using the Separating Axis Theorem to do so here. In the 2D -> Collisions
  section of the website, we describe this method at length.
*/
Vector2 getProjection(Vector2* vertices, Vector2 axis) {
	float32 min = axis.dot(vertices[0]);
	float32 max = min;

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

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

	return Vector2 { min, max };
}

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

inline float32 getProjectionOverlap(Vector2 first, Vector2 second) {
	float32 firstOverlap = (first.x - second.y);  // TODO: Does this need to be absolute value?
	float32 secondOverlap = (second.x - first.y);
	return firstOverlap > secondOverlap ? secondOverlap : firstOverlap;
}

struct IntermediateIntersectionResult {
	float32 minOverlap = FLT_MAX;
	Edge* minOverlapEdge;
	bool isOverlapOnFirstEdge = true;
};

bool checkEdgeOverlap(Edge* edges, Rectangle* first, Rectangle* second, IntermediateIntersectionResult* iir, bool isFirstEdge) {
	// Returns true if SAT passes for the provided set of edges.
	for (int i = 0; i < 4; i++) {
		Vector2 normal = edges[i].normal;

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

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

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

	return true;
}

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

    IntermediateIntersectionResult iir;
	if (!checkEdgeOverlap(first->edges, first, second, &iir, true)) {
		return ir;
	}

	if (!checkEdgeOverlap(second->edges, first, second, &iir, false)) {
		return ir;
	}
	
	ir.intersect = true;
	ir.relativeVelocity = first->body.velocity - second->body.velocity;
	ir.collisionNormal = iir.minOverlapEdge->normal;

	float32 minDistanceFromEdge = FLT_MAX;
	Vector2 pointOfContact;
	Vector2* pointsToCheck = iir.isOverlapOnFirstEdge ? second->transformedPoints : first->transformedPoints;
	for (int p = 0; p < 4; p++) {
		Vector2 point = pointsToCheck[p];

		float32 distanceFromEdge = MIN((iir.minOverlapEdge->start - point).length(), (iir.minOverlapEdge->end - point).length());

		if (distanceFromEdge < minDistanceFromEdge) {
			minDistanceFromEdge = distanceFromEdge;
			pointOfContact = point;
		}
	}


    ir.firstPointOfApplication = pointOfContact - first->body.position;
    ir.secondPointOfApplication = pointOfContact - second->body.position;;

	return ir;
}

/**
In this method, we resolve the collision of two rigidbodies using the IntersectionResult
that we gathered from the collision information. Note that this particular tutorial
is not about how we find this collision, but rather how we use this collision. To see the
variety of ways of how this IntersectionResult can be calculated go to the 2D->Collision
section of the website.
***/
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 cofOfRestitution = (first->cofOfRestitution + second->cofOfRestitution) / 2.f;
    float32 numerator = (relativeVelocity * (-1 * (1.f + cofOfRestitution))).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;

    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) {
    r1.update(deltaTimeSeconds);
	r2.update(deltaTimeSeconds);

	// Let's backtrack the simulation to find the precise point at which we collided.
	// There exists many ways to find this precise point. This is by far the most
	// expensive, but it gets the job done.
	IntersectionResult ir = getIntersection(&r1, &r2);
	if (ir.intersect) {
		IntersectionResult irCopy = ir;
		float32 copyDt = deltaTimeSeconds;
		float32 subdivisionAmountSeconds = deltaTimeSeconds / 16.f;
		
		do {
		    r1.restorePreviousBody();
			r2.restorePreviousBody();
				
			ir = irCopy;
			copyDt = copyDt - subdivisionAmountSeconds;

			r1.update(copyDt);
		    r2.update(copyDt);
				
			irCopy = getIntersection(&r1, &r2);

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

		} while (irCopy.intersect);

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

		// The following function is the main one that we're talking about in this tutorial.
		// This function will take the collision data, and repel the objects away from one
		// another using what we know from physics.
		resolveCollision(&r1.body, &r2.body, &ir);
		float32 frameTimeRemaining = deltaTimeSeconds - copyDt;

		r1.update(frameTimeRemaining);
	    r2.update(frameTimeRemaining);
	}

	// Keep within the bounds
	handleCollisionWithWall(&r1);
	handleCollisionWithWall(&r2);
	
	// Renderer
	renderer.render();
    r1.render(&renderer);
	r2.render(&renderer);
}

void unload() {
    mainLoop.stop();
    renderer.unload();
    r1.unload();
	r2.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;
}