#include "global_defs.h"
#include "handle_devices.h"

void print_single_event(int event_index) {
}

int main(void)
{
	system("clear");
	setvbuf(stdout, NULL, _IONBF, BUFSIZ);


	int controller_event_fptrs[NUM_EVENTS];
	uint64_t connected_controllers = 0;


        open_wii(controller_event_fptrs, &connected_controllers);

        open_ps4_bt(controller_event_fptrs, &connected_controllers);

        open_ps4_wired(controller_event_fptrs, &connected_controllers);

        open_steam(controller_event_fptrs, &connected_controllers);

        open_xbox_360(controller_event_fptrs, &connected_controllers);
	
	
	if (connected_controllers == 0) {
		fprintf(stderr, "No device matching the programs requirments (DualShock 4, Xbox 360, Valve Steam, or Wii Controller) was found, please double check the connection if you do not think that this is the case.\n");
		return(-1);
	}	

DUMB_USER:
	printf("\n\nPress the number corresponding to the device above that you would like to use and then press ENTER.\n");

	short choice;
	scanf("%d", &choice);

	struct input_event event1, event2, event3, event4;
	int ievt_size = sizeof(struct input_event);	
	size_t start_sec;
	
	switch (choice) {
		case 1: //valve steam controller
			{
			close_unneeded_files(1, controller_event_fptrs, VALVE_STEAM);
			print_one_event(controller_event_fptrs, VALVE_STEAM, 1);
			break;
			}
		case 2: //xbox 360 controller
			{
			close_unneeded_files(1, controller_event_fptrs, XBOX_360);
			print_one_event(controller_event_fptrs, XBOX_360, 1);
			break;
			}
		case PS4_WIRED_TOUCH_BIT:
			{
			close_unneeded_files(1, controller_event_fptrs, PS4_WIRED_TOUCH);
			print_one_event(controller_event_fptrs, PS4_WIRED_TOUCH, 1);
			break;
			}
		case PS4_WIRED_GYRO_BIT:
			{
			close_unneeded_files(1, controller_event_fptrs, PS4_WIRED_GYRO);
			print_one_event(controller_event_fptrs, PS4_WIRED_GYRO, 2);
			break;
			}
		case PS4_WIRED_BUTTONS_BIT:
			{
			close_unneeded_files(1, controller_event_fptrs, PS4_WIRED_BUTTONS);
			print_one_event(controller_event_fptrs, PS4_WIRED_BUTTONS, 3);
			break;
			}
		case PS4_WIRED_TOUCH_AND_GYRO:
			{
			close_unneeded_files(2, controller_event_fptrs, PS4_WIRED_TOUCH, PS4_WIRED_GYRO);
			read(controller_event_fptrs[PS4_WIRED_TOUCH], &event1, ievt_size);
			read(controller_event_fptrs[PS4_WIRED_GYRO], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[PS4_WIRED_TOUCH], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
					read(controller_event_fptrs[PS4_WIRED_GYRO], &event2, ievt_size);
					printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
							event2.time.tv_sec - start_sec, 
							event2.time.tv_usec, 
							event2.type, 
							event2.code, 
							event2.value);
				}
			}
			break;
			}
		case PS4_WIRED_TOUCH_AND_BUTTONS:
			{
			close_unneeded_files(2, controller_event_fptrs, PS4_WIRED_TOUCH, PS4_WIRED_BUTTONS);
			read(controller_event_fptrs[PS4_WIRED_TOUCH], &event1, ievt_size);
			read(controller_event_fptrs[PS4_WIRED_BUTTONS], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
					read(controller_event_fptrs[PS4_WIRED_TOUCH], &event1, ievt_size);
					printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
							event1.time.tv_sec - start_sec, 
							event1.time.tv_usec, 
							event1.type, 
							event1.code, 
							event1.value);
				}
			} else {
				while (1) {
					read(controller_event_fptrs[PS4_WIRED_BUTTONS], &event2, ievt_size);
					printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
							event2.time.tv_sec - start_sec, 
							event2.time.tv_usec, 
							event2.type, 
							event2.code, 
							event2.value);
					}
			}
			break;
			}
		case PS4_WIRED_GYRO_AND_BUTTONS:
			{
			close_unneeded_files(2, controller_event_fptrs, PS4_WIRED_GYRO, PS4_WIRED_BUTTONS);
			read(controller_event_fptrs[PS4_WIRED_GYRO], &event1, ievt_size);
			read(controller_event_fptrs[PS4_WIRED_BUTTONS], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[PS4_WIRED_GYRO], &event1, ievt_size);
				printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
				read(controller_event_fptrs[PS4_WIRED_BUTTONS], &event2, ievt_size);
				printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
						event2.time.tv_sec - start_sec, 
						event2.time.tv_usec, 
						event2.type, 
						event2.code, 
						event2.value);
				}
			}
			break;
			}
		case PS4_WIRED_ALL_BITS:   
			{
			close_unneeded_files(3, controller_event_fptrs, PS4_WIRED_TOUCH, PS4_WIRED_GYRO, PS4_WIRED_BUTTONS);
			read(controller_event_fptrs[PS4_WIRED_TOUCH], &event1, ievt_size);
			read(controller_event_fptrs[PS4_WIRED_GYRO], &event2, ievt_size);
			read(controller_event_fptrs[PS4_WIRED_BUTTONS], &event3, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[PS4_WIRED_TOUCH], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				pid = fork();
				if (pid == 0) {
					while (1) {
					read(controller_event_fptrs[PS4_WIRED_GYRO], &event2, ievt_size);
					printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
							event2.time.tv_sec - start_sec, 
							event2.time.tv_usec, 
							event2.type, 
							event2.code, 
							event2.value);
					}
				} else {
					while (1) {
					read(controller_event_fptrs[PS4_WIRED_BUTTONS], &event3, ievt_size);
					printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
							event3.time.tv_sec - start_sec, 
							event3.time.tv_usec, 
							event3.type, 
							event3.code, 
							event3.value);
					}
				}
			}
			break;
			}
		case PS4_BT_TOUCH_BIT:	   
			{
			close_unneeded_files(1, controller_event_fptrs, PS4_BT_TOUCH );
			print_one_event(controller_event_fptrs, PS4_BT_TOUCH, 1);
			break;
			}
		case PS4_BT_GYRO_BIT:	   
			{
			close_unneeded_files(1, controller_event_fptrs, PS4_BT_GYRO );
			print_one_event(controller_event_fptrs, PS4_BT_GYRO, 2);
			break;
			}
		case PS4_BT_BUTTONS_BIT:				       
			{
			close_unneeded_files(1, controller_event_fptrs, PS4_BT_BUTTONS );
			print_one_event(controller_event_fptrs, PS4_BT_BUTTONS, 3);
			break;
			}
		case PS4_BT_TOUCH_AND_GYRO:
			{
			close_unneeded_files(2, controller_event_fptrs, PS4_BT_TOUCH, PS4_BT_GYRO);
			read(controller_event_fptrs[PS4_BT_TOUCH], &event1, ievt_size);
			read(controller_event_fptrs[PS4_BT_GYRO], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[PS4_BT_TOUCH], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
					read(controller_event_fptrs[PS4_BT_GYRO], &event2, ievt_size);
					printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
							event2.time.tv_sec - start_sec, 
							event2.time.tv_usec, 
							event2.type, 
							event2.code, 
							event2.value);
				}
			}
			break;
			}
		case PS4_BT_TOUCH_AND_BUTTONS:
			{
			close_unneeded_files(2, controller_event_fptrs, PS4_BT_TOUCH, PS4_BT_BUTTONS);
			read(controller_event_fptrs[PS4_BT_TOUCH], &event1, ievt_size);
			read(controller_event_fptrs[PS4_BT_BUTTONS], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
					read(controller_event_fptrs[PS4_BT_TOUCH], &event1, ievt_size);
					printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
							event1.time.tv_sec - start_sec, 
							event1.time.tv_usec, 
							event1.type, 
							event1.code, 
							event1.value);
				}
			} else {
				while (1) {
					read(controller_event_fptrs[PS4_BT_BUTTONS], &event2, ievt_size);
					printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
							event2.time.tv_sec - start_sec, 
							event2.time.tv_usec, 
							event2.type, 
							event2.code, 
							event2.value);
					}
			}
			break;
			}
		case PS4_BT_GYRO_AND_BUTTONS:
			{
			close_unneeded_files(2, controller_event_fptrs, PS4_BT_GYRO, PS4_BT_BUTTONS);
			read(controller_event_fptrs[PS4_BT_GYRO], &event1, ievt_size);
			read(controller_event_fptrs[PS4_BT_BUTTONS], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[PS4_BT_GYRO], &event1, ievt_size);
				printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
				read(controller_event_fptrs[PS4_BT_BUTTONS], &event2, ievt_size);
				printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
						event2.time.tv_sec - start_sec, 
						event2.time.tv_usec, 
						event2.type, 
						event2.code, 
						event2.value);
				}
			}
			break;
			}
		case PS4_BT_ALL_BITS:	   
			{
			close_unneeded_files(3, controller_event_fptrs, PS4_BT_TOUCH, PS4_BT_GYRO, PS4_BT_BUTTONS);
			read(controller_event_fptrs[PS4_BT_TOUCH], &event1, ievt_size);
			read(controller_event_fptrs[PS4_BT_GYRO], &event2, ievt_size);
			read(controller_event_fptrs[PS4_BT_BUTTONS], &event3, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[PS4_BT_TOUCH], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				pid = fork();
				if (pid == 0) {
					while (1) {
					read(controller_event_fptrs[PS4_BT_GYRO], &event2, ievt_size);
					printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
							event2.time.tv_sec - start_sec, 
							event2.time.tv_usec, 
							event2.type, 
							event2.code, 
							event2.value);
					}
				} else {
					while (1) {
					read(controller_event_fptrs[PS4_BT_BUTTONS], &event3, ievt_size);
					printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
							event3.time.tv_sec - start_sec, 
							event3.time.tv_usec, 
							event3.type, 
							event3.code, 
							event3.value);
					}
				}
			}
			break;
			}
		case NINTENDO_GYRO_BIT:
			{
			close_unneeded_files(1, controller_event_fptrs, WII_GYRO);
			print_one_event(controller_event_fptrs, WII_GYRO, 1);
			break;
			}
		case NINTENDO_IR_BIT:	   
			{
			close_unneeded_files(1, controller_event_fptrs, WII_IR);
			print_one_event(controller_event_fptrs, WII_IR, 2);
			break;
			}
		case NINTENDO_BUTTONS_BIT: 
			{
			close_unneeded_files(1, controller_event_fptrs, WII_BUTTONS);
			print_one_event(controller_event_fptrs, WII_BUTTONS, 3);
			break;
			}
		case NINTENDO_NUNCHUK_BIT: 
			{
			close_unneeded_files(1, controller_event_fptrs, WII_NUNCHUK);
			print_one_event(controller_event_fptrs, WII_NUNCHUK, 4);
			break;
			}
		case NINTENDO_GYRO_AND_IR: 
			{
			close_unneeded_files(2, controller_event_fptrs, WII_GYRO, WII_IR);
			read(controller_event_fptrs[WII_GYRO], &event1, ievt_size);
			read(controller_event_fptrs[WII_IR], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[WII_GYRO], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
				read(controller_event_fptrs[WII_IR], &event2, ievt_size);
				printf("2 %zu.%-6zu  %d  %3d  %9d\n", 
						event2.time.tv_sec - start_sec, 
						event2.time.tv_usec, 
						event2.type, 
						event2.code, 
						event2.value);
				}
			}
			break;
			}
		case NINTENDO_GYRO_AND_BUTTONS:
			{
			close_unneeded_files(2, controller_event_fptrs, WII_GYRO, WII_BUTTONS);
			read(controller_event_fptrs[WII_GYRO], &event1, ievt_size);
			read(controller_event_fptrs[WII_BUTTONS], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[WII_GYRO], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
				read(controller_event_fptrs[WII_BUTTONS], &event2, ievt_size);
				printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
						event2.time.tv_sec - start_sec, 
						event2.time.tv_usec, 
						event2.type, 
						event2.code, 
						event2.value);
				}
			}
			break;
			}
		case NINTENDO_GYRO_AND_NUNCHUK:
			{
			close_unneeded_files(2, controller_event_fptrs, WII_GYRO, WII_NUNCHUK);
			read(controller_event_fptrs[WII_GYRO], &event1, ievt_size);
			read(controller_event_fptrs[WII_BUTTONS], &event2, ievt_size);
			start_sec = event1.time.tv_sec;
			int pid = fork();
			if (pid == 0) {
				while (1) {
				read(controller_event_fptrs[WII_GYRO], &event1, ievt_size);
				printf("1 %zu.%-6zu  %d  %3d  %9d\n", 
						event1.time.tv_sec - start_sec, 
						event1.time.tv_usec, 
						event1.type, 
						event1.code, 
						event1.value);
				}
			} else {
				while (1) {
				read(controller_event_fptrs[WII_BUTTONS], &event2, ievt_size);
				printf("3 %zu.%-6zu  %d  %3d  %9d\n", 
						event2.time.tv_sec - start_sec, 
						event2.time.tv_usec, 
						event2.type, 
						event2.code, 
						event2.value);
				}
			}
			break;
			}
		case NINTENDO_IR_AND_BUTTONS:
			{
			close_unneeded_files(2, controller_event_fptrs, WII_IR, WII_BUTTONS);
			break;
			}
		case NINTENDO_IR_AND_NUNCHUK:
			{
			close_unneeded_files(2, controller_event_fptrs, WII_IR, WII_NUNCHUK);
			break;
			}
		case NINTENDO_BUTTONS_AND_NUNCHUK:
			{
			close_unneeded_files(2, controller_event_fptrs, WII_BUTTONS, WII_NUNCHUK);
			break;
			}
		case NINTENDO_GYRO_IR_AND_BUTTONS:
			{
			close_unneeded_files(3, controller_event_fptrs, WII_GYRO, WII_IR, WII_BUTTONS);
			break;
			}
		case NINTENDO_GYRO_IR_AND_NUNCHUK:
			{
			close_unneeded_files(3, controller_event_fptrs, WII_GYRO, WII_IR, WII_NUNCHUK);
			break;
			}
		case NINTENDO_GYRO_BUTTONS_AND_NUNCHUK:
			{
			close_unneeded_files(3, controller_event_fptrs, WII_GYRO, WII_BUTTONS, WII_NUNCHUK);
			break;
			}
		case NINTENDO_IR_BUTTONS_AND_NUNCHUK:
			{
			close_unneeded_files(3, controller_event_fptrs, WII_IR, WII_BUTTONS, WII_NUNCHUK);
			break;
			}
		case NINTENDO_ALL_BITS:	   
			{
			close_unneeded_files(4, controller_event_fptrs, WII_GYRO, WII_IR, WII_BUTTONS, WII_NUNCHUK);
			break;
			}
		default:
			{
			fprintf(stderr, "ERROR: Do not know how you made it here.\n");
			exit(-1);
			break;
			}
	}
	return 0;
}