/*
 * 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 <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, PPX };

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

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

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


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, PPX=2).\n"
		"	-v[level]	Sets the verbosity level (0-3).\n"
	      );
	return 0;
}

int main(int argc, char **argv) {
	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;

		/* Bitmask used in Per Pixel, and Tile Heightmap collision. */
		uint8_t **bitmask;

		/* 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;
	};

	/* Create the Cursor, and the Floor */
	struct colis cursor;
	struct colis floor;

	/*
	 * Create a temporary Cursor/Floor, because it simplifies
	 * the process of getting collision data, to one for loop.
	 */
	struct colis tmp;
	int hmpeak;
	/* Get collision type. */
	char *buf = NULL;
	size_t size;

	getline(&buf, &size, stdin);

	if (colltype == -1)
		colltype = atoi(strtok(buf, "\n"));

	for (int coll = 0; coll <= 1; coll++) {
		buf = NULL;
		getline(&buf, &size, stdin);
		/*
		 * Format is:
		 *
		 * <w>, <h>
		 */
		tmp.w = atoi(strtok(buf, ","));
		tmp.h = atoi(strtok(NULL, "\n"));
		/* Initialize y axis of bitmask. */
		if (colltype == THM || colltype == PPX)
			tmp.bitmask = malloc(sizeof(uint8_t *)*tmp.h);
		/* Initialize x axis of bitmask. */
		if (colltype == PPX)
			for(unsigned int i = 0; i<tmp.h; i++)
				tmp.bitmask[i] = malloc(sizeof(uint8_t)*tmp.w);
		/* Get Per Pixel data. */
		if (colltype == PPX) {
			for (unsigned int j = 0; j<tmp.h; j++) {
				buf = NULL;
				size_t newidth = getline(&buf, &size, stdin);
				/*
				 * Format is:
				 *
				 * 000111000... Until bit w-1.
				 * .
				 * .
				 *
				 * Until bit h-1.
				 */
				tmp.w = (newidth >= tmp.w) ? tmp.w : newidth;
				for (unsigned int i = 0; i <tmp.w; i++)
					tmp.bitmask[j][i] = buf[i] - '0';
			}
		}
		/* Get Tile Heightmap data. */
		if (colltype == THM && coll) {
			/* Get vertical flip flag */
			buf = NULL;
			getline(&buf, &size, stdin);
			floor.flp = buf[0] - '0';
			/* Get Heightmap */
			buf = NULL;
                        size_t newheight = getline(&buf, &size, stdin);
			/*
			 * Format is:
			 *
			 * 0, 1, 2, 3, ... Until element h-1.
			 */
			tmp.h = (newheight >= tmp.h) ? tmp.h : newheight;
			for (unsigned int i = 0; i <tmp.h; i++) {
				char *tmptok = strtok((i == 0) ? buf : NULL,",");
				tmptok = (tmptok == NULL) ? strtok(NULL,"\n") : tmptok;
				tmp.bitmask[i] = (uint8_t *)((atoi(tmptok) <= tmp.h) ? atoi(tmptok) : tmp.h);
				hmpeak = (atoi(tmptok)+1 >= hmpeak) ? atoi(tmptok)+1 : hmpeak;
			}

		}

		/*
		 * Copy width, height, and bitmask over
		 * to either the Cursor, or the Floor.
		 */
		(coll) ? (floor.w = tmp.w) : (cursor.w = tmp.w);
		(coll) ? (floor.h = tmp.h) : (cursor.h = tmp.h);
		(coll) ? (floor.bitmask = tmp.bitmask) : (cursor.bitmask = tmp.bitmask);
		/* Debugging stuff. */
		if (verbose >= 1) {
			if (colltype == THM && coll)
				 for (unsigned int i = 0; i<floor.h; i++)
					 printf((i < floor.h-1 && i % 16 != 0 || i == 0) ? "%u, " : ("%u\n"), floor.bitmask[i]);


			if (colltype == PPX) {
				for (unsigned int j = 0; j<((coll) ? floor.h : cursor.h); j++) {
					for (unsigned int i = 0; i<((coll) ? floor.w : cursor.w); i++)
						if((coll) ? floor.bitmask[j][i] : cursor.bitmask[j][i])
							printf("%u", (coll) ? floor.bitmask[j][i] : cursor.bitmask[j][i]);
						else
							printf(" ");
					printf("\n");
				}
			}
		}


		uint8_t delms = 0;
		char *tmp2;
		buf = NULL;
		getline(&buf, &size, stdin);
		for (int j = 0; buf[j] != '\0'; j++)
			if (buf[j] == ',')
				delms++;
		postype = (delms == 2) ? 1 : 0;
		/* Check for floating point coordinates. */
		uint8_t flt;
		flt = (strchr(buf, '.') != NULL) ? 1 : 0;
		if (flt) {
			tmp.pos.fx = atof(strtok(buf,","));
			if(postype)
				tmp.pos.fy = atof(strtok(NULL,","));
			tmp2 = strtok(NULL, "\n");
			TERASGN(postype, tmp.pos.fz, tmp.pos.fy, atof((tmp2 == NULL ? strtok(NULL,"\0") : tmp2)));
			(coll) ? (floor.pos = tmp.pos) : (cursor.pos = tmp.pos);
			if (verbose >= 1) {
				printf("%07.06f, %07.06f%s", (!coll) ? cursor.pos.fx : floor.pos.fx, (!coll) ? cursor.pos.fy : floor.pos.fy, (postype) ? ", " : "\n");
				if(postype)
                           		printf("%07.06f\n", (!coll) ? cursor.pos.fz : floor.pos.fz);
			}
		} else {
			tmp.pos.x = atoi(strtok(buf,","));
			/* Are we using 3D coordinates, or 2D coordinats? */
			if(postype)
				tmp.pos.y = atoi(strtok(NULL,","));
			tmp2 = strtok(NULL, "\n");
			TERASGN(postype, tmp.pos.z, tmp.pos.y, atoi((tmp2 == NULL ? strtok(NULL,"\0") : tmp2)));
			(coll) ? (floor.pos = tmp.pos) : (cursor.pos = tmp.pos);
			if (verbose >= 1) {
				printf("%i, %i%s", (!coll) ? cursor.pos.x : floor.pos.x, (!coll) ? cursor.pos.y : floor.pos.y, (postype) ? ", " : "\n");
				if(postype)
                           		printf("%i\n", (!coll) ? cursor.pos.z : floor.pos.z);
			}
		}
		/* Get X, and Y velocity. */
		if(!coll) {
			buf = NULL;
			getline(&buf, &size, stdin);
			cursor.xvel = atof(strtok(buf, ","));
			cursor.yvel = atof(strtok(NULL, "\n"));
		}

		/* Tile Heightmap Collision. */
		if (colltype == THM && coll) {
			if (!flt) {
				cursor.a1 = cursor.pos.x;
				cursor.a2 = cursor.pos.x+cursor.w;
				cursor.b1 = cursor.pos.y;
				cursor.b2 = cursor.pos.y+cursor.h;
				floor.a1 = floor.pos.x;
                                floor.a2 = floor.pos.x+floor.w;
                                floor.b1 = floor.pos.y;
                                floor.b2 = floor.pos.y+floor.h;

				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)) ? 1 : 0;
				/* Check for a collision, on the y axis. */
				cursor.cly = ((cursor.b2 >= (floor.b1-hmpeak-1)-(int)cursor.yvel && cursor.a2 >= floor.a1) && (cursor.b1 <= (floor.b2+hmpeak+1)-(int)cursor.yvel && cursor.a1 <= floor.a2)) ? 1 : 0;

				int newy = 0;
				if (cursor.cly) {
					if (cursor.a2-floor.a1 < floor.h) {
						cursor.yvel = 0;
						newy = (int)floor.bitmask[cursor.a2-floor.a1];
						/* Is the Floor, really a floor? */
						if (cursor.b2 > (floor.b2-hmpeak-1)-(int)cursor.yvel && floor.b2-cursor.b2 >= 0 && !floor.flp)
							cursor.pos.y = (floor.b2-newy-1)-(int)cursor.yvel;
						else if (cursor.b1 < floor.b2-(int)cursor.yvel && floor.b2-cursor.b2 < 0 && !floor.flp)
							cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel;
						/* Is the Floor, actually a ceiling? */
						if (cursor.b1 < (floor.b1+hmpeak+1)-(int)cursor.yvel && floor.b1-cursor.b1 >= 0 && floor.flp)
							cursor.pos.y = (floor.pos.y+newy+1)-(int)cursor.yvel;
						else if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && floor.b1-cursor.b1 < 0 && cursor.yvel > 0 && floor.flp)
							cursor.pos.y = (floor.pos.y-(int)cursor.yvel-1)-cursor.h;
					}
				}
				if (cursor.clx) {
					/* Is the Cursor coming from the left? */
					if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b2-cursor.b2 < 0 && !floor.flp && cursor.xvel > 0)
						cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
					else if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b2-cursor.b2 < 0 && !floor.flp && cursor.xvel < 0)
						cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
					/* Is the Cursor coming from the right? */
					if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b1-cursor.b1 < 0 && floor.flp && cursor.xvel < 0)
						cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
					else if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b1-cursor.b1 < 0 && floor.flp && cursor.xvel > 0)
						cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
					cursor.xvel = 0;
				}
				cursor.gnded = (cursor.pos.y == floor.pos.y-(cursor.h-newy)) ? 1 : 0;

				printf("%u\n%u\n%i\nfloor.b2-cursor.b2: %i, floor.b1-cursor.b1: %i\n%i, %i\n%07.06f, %07.06f\n", cursor.cly, cursor.gnded, newy, floor.b2-cursor.b2, floor.b1-cursor.b1, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
			} else {
				cursor.c1 = cursor.pos.fx;
				cursor.c2 = cursor.pos.fx+cursor.w;
				cursor.d1 = cursor.pos.fy;
				cursor.d2 = cursor.pos.fy+cursor.h;
				floor.c1 = floor.pos.fx;
				floor.c2 = floor.pos.fx+floor.w;
				floor.d1 = floor.pos.fy;
				floor.d2 = floor.pos.fy+floor.h;

				/* Check for a collision, on the y axis. */
				cursor.cly = ((cursor.d2 > floor.d1-cursor.yvel-1 && cursor.c2 > floor.c1) && (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.c1 < floor.c2)) ? 1 : 0;

				int newy = 0;
				if (cursor.cly) {
					if (cursor.c2-floor.c1 < floor.h) {
						newy = (int)floor.bitmask[(int)cursor.c2-(int)floor.c1];
						/* Is the Floor, really a floor? */
						if (cursor.d2 > floor.d1-cursor.yvel-1 && !floor.flp)
							cursor.pos.fy = floor.pos.fy-(cursor.h-newy)-cursor.yvel+1;
						/* Is the Floor, actually a ceiling? */
						else if (cursor.d1 < floor.d2-cursor.yvel+1 && floor.flp)
							cursor.pos.fy = (floor.pos.fy+newy)-cursor.yvel-1;
					}
				}
				cursor.gnded = (cursor.pos.fy == floor.pos.fy-(cursor.h-newy)) ? 1 : 0;

				printf("%u\n%u\n%i\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.cly, cursor.gnded, newy, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
			}
		}

		/* Axis Aligned Bounding Box Collision. */
		if (colltype == AABB && coll) {
			if (!flt) {
				cursor.a1 = cursor.pos.x;
				cursor.a2 = cursor.pos.x+cursor.w;
				cursor.b1 = cursor.pos.y;
				cursor.b2 = cursor.pos.y+cursor.h;
				floor.a1 = floor.pos.x;
				floor.a2 = floor.pos.x+floor.w;
				floor.b1 = floor.pos.y;
				floor.b2 = floor.pos.y+floor.h;
				/* Is the Cursor is on the ground? */
				cursor.gnded = (cursor.b2 == floor.b1-(int)cursor.yvel-1) ? 1 : 0;

				/* Check for collisions, on both axies. */
				cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
				cursor.cly = ((cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.a2 > floor.a1) && (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.a1 < floor.a2)) ? 1 : 0;

				if (cursor.clx) {
					/* Is the Cursor coming from the left? */
					if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.xvel > 0)
						cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
					/* Is the Cursor coming from the right? */
					else if (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.xvel < 0)
						cursor.pos.x = (floor.pos.x+floor.w)-(int)cursor.xvel+1;
					cursor.xvel = 0;
				}
				if (cursor.cly) {
					/* Is the Cursor coming from the top? */
					if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.yvel > 0)
						cursor.pos.y = (floor.pos.y-(int)cursor.yvel)-cursor.h-1;
					/* Is the Cursor coming from the bottom? */
					else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.yvel < 0)
						cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
					cursor.yvel = 0;
				}

				if (verbose >= 1) {
					printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
					printf("x: %i, y: %i\n", cursor.pos.x, cursor.pos.y);
					printf("floor.x: %i, floor.y: %i\n", floor.pos.x, floor.pos.y);
					printf ("r: %i\n", (floor.pos.x+floor.w)-(int)cursor.xvel+1);
				}
				printf("%u, %u\n%u\n%i, %i\n%07.06f, %07.06f\n\0", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
			} else {
				cursor.c1 = cursor.pos.fx;
				cursor.c2 = cursor.pos.fx+cursor.w;
				cursor.d1 = cursor.pos.fy;
				cursor.d2 = cursor.pos.fy+cursor.h;
				floor.c1 = floor.pos.fx;
				floor.c2 = floor.pos.fx+floor.w;
				floor.d1 = floor.pos.fy;
				floor.d2 = floor.pos.fy+floor.h;

				cursor.gnded = (cursor.d2 == floor.d1-cursor.yvel-1) ? 1 : 0;
				cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
				cursor.cly = ((cursor.d2 > floor.d1-cursor.yvel-1 && cursor.c2 > floor.c1) && (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.c1 < floor.c2)) ? 1 : 0;

				if (cursor.clx) {
					if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.xvel > 0)
						cursor.pos.fx = (floor.pos.fx-cursor.xvel)-(double)cursor.w-1;
					else if (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.xvel < 0)
						cursor.pos.fx = (floor.pos.fx+(double)floor.w)-cursor.xvel+1;
					cursor.xvel = 0;
				}
				if (cursor.cly) {
					if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.yvel > 0)
						cursor.pos.fy = (floor.pos.fy-cursor.yvel)-(double)cursor.h-1;
					else if (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.yvel < 0)
						cursor.pos.fy = (floor.pos.fy+(double)floor.h)-cursor.yvel+1;
					cursor.yvel = 0;
				}
				if (verbose >= 1) {
					printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
					printf("fx: %07.06f, fy: %07.06f\n", cursor.pos.fx, cursor.pos.fy);
					printf("floor.fx: %07.06f, floor.fy: %07.06f\n", floor.pos.fx, floor.pos.fy);
				}
				printf("%u, %u\n%u\n%07.06f, %07.06f\n%07.06f, %07.06f\n\0", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
			}
		}
	}
	uint8_t a = 0;
	unsigned int i = 0;
	free(buf);
	if(colltype == THM || colltype == PPX) {
		while (!a && colltype == PPX)
			(i<tmp.h) ? (free(tmp.bitmask[i]), ++i) : (a=1);
		free(cursor.bitmask);
		free(floor.bitmask);
	}
	fflush(stdout);

	return 0;
}