/*
 * Main Program file.
 *
 * Platform: 	Anything with a C compiler.
 * Author:	mr b0nk 500 <b0nk@mrb0nk500.xyz>
 * Notes: 	Who would even use this kind of collision checker?
 * Created:	September 27, 2019 @ 09:25PM
 */

#include <ctype.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define TERASGN(a, b, c, d) (a) ? (b = d) : (c = d)

enum {THM, AABB};

/* Collision type */
int colltype = -1;

/* Position type */
int postype = -1;

/* Level of verbosity. */
int verbose = 0;

/* Options string. */
const char *opts = "c:v:h";

struct pos {
	int x;
	int y;
	int z;
	double fx;
	double fy;
	double fz;
};

struct colis {
	/* Cursor/Floor's width, and height */
	int w;
	int h;

	/* Cursor's X, and Y velocity. */
	double xvel;
	double yvel;

	/* Cursor/Floor's coordinates. */
	struct pos pos;

	/* The four corners of either the Cursor, or the Floor. */
	int a1;
	int a2;
	int b1;
	int b2;

	/* The four floating point corners of either the Cursor, or the Floor. */
	double c1;
	double c2;
	double d1;
	double d2;

	/* Heightmap, used in Tile Heightmap collision. */
	uint8_t *heightmap;

	/* X axis collision. */
	unsigned int clx : 1;

	/* Y axis collision. */
	unsigned int cly : 1;

	/* Cursor is on the ground. */
	unsigned int gnded : 1;

	/* Vertical flip flag. */
	unsigned int flp : 1;
};

static int usage() {
	printf(
		"clld Version MFIYA.\n"
		"Usage: clld [options]\n"
		"Options:\n"
		"	-c[type]	Force the collision type to be\n"
		"			the specified type (THM=0, AABB=1).\n"
		"	-v[level]	Sets the verbosity level (0-3).\n"
		"	-h		What do you fucking think it does.\n"
		"			Anyways, it brings up this cool help\n"
		"			message.\n"
	      );
	return 0;
}

/* Tile Heightmap Collision. */
int thm(uint8_t flt, int hmpeak, struct colis cursor, struct colis floor) {
	int newy = 0;
	if (!flt) {
		cursor.clx = (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1 < floor.b2);
		cursor.cly = (cursor.b2 >= floor.b1-(int)cursor.yvel && cursor.a2 >= floor.a1) && (cursor.b1 <= floor.b2-(int)cursor.yvel && cursor.a1 <= floor.a2);
		uint8_t l;
		uint8_t r;
		uint8_t t;
		uint8_t b;
		if (!floor.flp) {
			l = (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b2-cursor.b2 < (int)floor.heightmap[0] && cursor.xvel > 0);
			r = (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b2-cursor.b2 < (int)floor.heightmap[floor.w-1] && cursor.xvel < 0);
			t = (cursor.b2 > (floor.b2-hmpeak)-(int)cursor.yvel && floor.b2-cursor.b2 >= 0);
			b = (cursor.b1 < floor.b2-(int)cursor.yvel+1 && floor.b2-cursor.b1 <= 0);
		} else {
			l = (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b1-cursor.b1 > -(int)floor.heightmap[0] && cursor.xvel > 0);
			r = (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b1-cursor.b1 > -(int)floor.heightmap[floor.w-1] && cursor.xvel < 0);
			t = (cursor.b2 > floor.b1-(int)cursor.yvel-1 && floor.b1-cursor.b2 >= 0 && cursor.yvel > 0);
			b = (cursor.b1 < (floor.b1+hmpeak)-(int)cursor.yvel && cursor.b1-floor.b1 >= 0);
		}

		if (cursor.clx) {
			if (cursor.a2-floor.a1 < 0 || cursor.a2-floor.a1 > floor.w) {
				if (l)
					cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
				else if (r)
					cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
				cursor.xvel = 0;
			}
		}
		if (cursor.cly) {
			if (cursor.a2-floor.a1 < floor.w) {
				newy = (int)floor.heightmap[cursor.a2-floor.a1];
				if (t)
					(!floor.flp) ? (cursor.pos.y = ((floor.b2-cursor.h)-newy)-(int)cursor.yvel) : (cursor.pos.y = (floor.pos.y-cursor.h)-(int)cursor.yvel);
				else if (b)
					(!floor.flp) ? (cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1) : (cursor.pos.y = (floor.pos.y+newy)-(int)cursor.yvel);
				cursor.yvel = 0;
			}
		}
		cursor.gnded = (cursor.pos.y == ((floor.b2-cursor.h)-newy)-(int)cursor.yvel) ? 1 : 0;
		printf("%u, %u\n%u\n%i\n%i, %i\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
	} else {
		cursor.clx = (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1 < floor.d2);
		cursor.cly = (cursor.d2 >= floor.d1-cursor.yvel && cursor.c2 >= floor.c1) && (cursor.d1 <= floor.d2-cursor.yvel && cursor.c1 <= floor.c2);
		uint8_t l;
		uint8_t r;
		uint8_t t;
		uint8_t b;
		if (!floor.flp) {
			l = (cursor.c2 > floor.c1-cursor.xvel-1 && floor.d2-cursor.d2 < (int)floor.heightmap[0] && cursor.xvel > 0);
			r = (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && floor.d2-cursor.d2 < (int)floor.heightmap[floor.w-1] && cursor.xvel < 0);
			t = (cursor.d2 > (floor.d2-hmpeak)-cursor.yvel && floor.d2-cursor.d2 >= 0);
			b = (cursor.d1 < floor.d2-cursor.yvel+1 && floor.d2-cursor.d1 <= 0);
		} else {
			l = (cursor.c2 > floor.c1-cursor.xvel-1 && floor.d1-cursor.d1 > -(int)floor.heightmap[0] && cursor.xvel > 0);
			r = (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && floor.d1-cursor.d1 > -(int)floor.heightmap[floor.w-1] && cursor.xvel < 0);
			t = (cursor.d2 > floor.d1-cursor.yvel-1 && floor.d1-cursor.d2 >= 0 && cursor.yvel > 0);
			b = (cursor.c1 < (floor.d1+hmpeak)-cursor.yvel && cursor.d1-floor.d1 >= 0);
		}

		if (cursor.clx) {
			if (cursor.c2-floor.c1 < -1 || cursor.c2-floor.c1 > floor.w) {
				if (l)
					cursor.pos.fx = (floor.pos.fx-cursor.xvel)-cursor.w-1;
				else if (r)
					cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
				cursor.xvel = 0;
			}
		}
		if (cursor.cly) {
			if (cursor.c2-floor.c1 < floor.w) {
				newy = (int)floor.heightmap[(int)cursor.c2-(int)floor.c1];
				if (t)
					(!floor.flp) ? (cursor.pos.fy = ((floor.d2-cursor.h)-newy)-cursor.yvel) : (cursor.pos.fy = (floor.pos.fy-cursor.h)-cursor.yvel);
				else if (b)
					(!floor.flp) ? (cursor.pos.fy = (floor.pos.fy+floor.h)-cursor.yvel) : (cursor.pos.fy = (floor.pos.fy+newy)-cursor.yvel);
				cursor.yvel = 0;
			}
		}
		cursor.gnded = (cursor.pos.fy == ((floor.d2-cursor.h)-newy)-cursor.yvel) ? 1 : 0;
		printf("%u, %u\n%u\n%i\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
	}
	return 0;
}

/* Axis Aligned Bounding Box Collision. */
int aabb(uint8_t flt, struct colis cursor, struct colis floor) {
	uint8_t l = (!flt) ? (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) : (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1);
	uint8_t r = (!flt) ? (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.b1 < floor.b2) : (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.d1 < floor.d2);
	uint8_t t = (!flt) ? (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.a2 > floor.a1) : (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.c2 > floor.c1);
	uint8_t b = (!flt) ? (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.a1 < floor.a2) : (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.c1 < floor.c2);
	cursor.clx = l && r;
	cursor.cly = t && b;
	/* Is the Cursor is on the ground? */
	cursor.gnded = (cursor.b2 == floor.b1-(int)cursor.yvel-1) ? 1 : 0;
	/* Is the Cursor coming from the left? */
	if (l && cursor.xvel > 0)
		(!flt) ? (cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1) : (cursor.pos.fx = (floor.pos.fx-cursor.xvel)-(double)cursor.w-1);
	/* Is the Cursor coming from the right? */
	else if (r && cursor.xvel < 0)
		(!flt) ? (cursor.pos.x = (floor.pos.x+floor.w)-(int)cursor.xvel+1) : (cursor.pos.fx = (floor.pos.fx+(double)floor.w)-cursor.xvel+1);
	cursor.xvel = 0;
	/* Is the Cursor coming from the top? */
	if (t && cursor.yvel > 0)
		(!flt) ? (cursor.pos.y = (floor.pos.y-(int)cursor.yvel)-cursor.h-1) : (cursor.pos.fy = (floor.pos.fy-cursor.yvel)-(double)cursor.h-1);
	/* Is the Cursor coming from the bottom? */
	else if (b && cursor.yvel < 0)
		(!flt) ? (cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1) : (cursor.pos.fy = (floor.pos.fy+(double)floor.h)-cursor.yvel+1);
	cursor.yvel = 0;
	if (!flt)
		printf("%u, %u\n%u\n%i, %i\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
	else
		printf("%u, %u\n%u\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
	return 0;
}


int main(int argc, char **argv) {
	int c;
	/* Enable custom error messages, and optional arguments/ */
	opterr = 0;
	/* Get options. */
	while ((c = getopt(argc, argv, opts)) != -1) {
		switch(c) {
			case 'c':
				colltype = atoi(optarg);
				break;
			case 'v':
				verbose = atoi(optarg);
				break;
			case 'h':
				usage();
				return 2;
			case '?':
				if (isprint(optopt)) {
					if (optopt == 'c') {
						fprintf(stderr, "Setting colltype to default.\n");
						colltype = -1;
						break;
					} else if (optopt == 'v') {
						fprintf(stderr, "Enabling single level verbosity.\n");
						verbose = 1;
						break;
					} else {
						fprintf(stderr
							, "The option that you have typed in, which in this case\n"
							  "is -%c, does not exist.\n"
							  "Try looking at the help message, or RTFM, next time.\n"
							, optopt);
					}
				} else {
					fprintf(stderr
						, "What the fuck are you trying to type in, a binary blob?\n"
						  "Because of this, clld will exit, so, stop acting like a\n"
						  "jackass.\n");
				}
				return -1;
			default: ;
		}
	}

	/* Create the Cursor, and the Floor */
	struct colis cursor;
	struct colis floor;
	colltype = AABB;
	cursor.h = 16;
	cursor.w = 16;
	cursor.pos.x = 17;
	cursor.pos.y = 24;
	cursor.xvel = 1;
	cursor.yvel = 0;
	floor.w = 16;
	floor.h = 16;
	floor.flp = 0;
	int hmpeak;
	if (colltype == THM) {
		floor.heightmap = malloc(sizeof(uint8_t *)*floor.w);
		for (int i = 0; i <floor.w; i++)
			floor.heightmap[i] = i+1;
		hmpeak = floor.heightmap[floor.w-1];
	}
	uint8_t flt = 0;
	floor.pos.x = 32;
	floor.pos.y = 32;
	(!flt) ? (cursor.a1 = cursor.pos.x) : (cursor.c1 = cursor.pos.fx);
	(!flt) ? (cursor.a2 = cursor.pos.x+cursor.w) : (cursor.c2 = cursor.pos.fx+cursor.w);
	(!flt) ? (cursor.b1 = cursor.pos.y) : (cursor.d1 = cursor.pos.fy);
	(!flt) ? (cursor.b2 = cursor.pos.y+cursor.h) : (cursor.d2 = cursor.pos.fy+cursor.h);
	(!flt) ? (floor.a1 = floor.pos.x) : (floor.c1 = floor.pos.fx);
	(!flt) ? (floor.a2 = floor.pos.x+floor.w) : (floor.c2 = floor.pos.fx+floor.w);
	(!flt) ? (floor.b1 = floor.pos.y) : (floor.d1 = floor.pos.fy);
	(!flt) ? (floor.b2 = floor.pos.y+floor.h) : (floor.d2 = floor.pos.fy+floor.h);

	if (colltype == THM)
		thm(flt, hmpeak, cursor, floor);
	/* Axis Aligned Bounding Box Collision. */
	if (colltype == AABB)
		aabb(flt, cursor, floor);
	/*uint8_t a = 0;
	unsigned int i = 0;
	free(buf);*/
	if(colltype == THM) {
		free(floor.heightmap);
	}
	fflush(stdout);

	return 0;
}