#include <cmath>
#include <cstddef>
#include <iterator>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include "parcer.h"
#include "server_structs.h"
#include "socket.h"

#define DEBUG_CAR_INFO 0

const int SERVER_OUT_PORT = 12000;
const int SERVER_IN_PORT = 11000;
const char *SERVER_OUT_IP = "127.0.0.1";

const int MAX_PLAYERS = 64;

void init_carupdate(carAtributes *car) {
	car->isConnected = 0;
	car->isLoading = 0;

	car->car_model = (char *)malloc(64);
	car->driver_GUID = (char *)malloc(64);
	car->car_skin = (char *)malloc(64);
	car->driver_name = (char *)malloc(64);
	car->driver_team = (char *)malloc(64);

	strcpy(car->car_model, "");
	strcpy(car->driver_GUID, "");
	strcpy(car->car_skin, "");
	strcpy(car->driver_name, "");
	strcpy(car->driver_team, "");

	car->carID = 0;

	car->position.x = 0.0f;
	car->position.y = 0.0f;
	car->position.z = 0.0f;

	car->velocity.x = 0.0f;
	car->velocity.y = 0.0f;
	car->velocity.z = 0.0f;

	car->carGear = 0;
	car->carRPM = 0;
	car->lap_time = 0;
	car->cuts = 0;
	car->total_cuts = 0;
	car->total_cuts_alltime = 0; // TODO: SQL querry to get total cuts of all time;
                                 // TAG:1
    car->total_laps_completed = 0;
    car->contacts = 0;
    car->total_contacts = 0;     // TODO: SQL querry to get total contacts of all time;
                                 // TAG:2

	car->normalizedSplinePos = 0.0f;
}

int main(void) {

	printf("[+] Starting server...\n");
	printf("[+] Server listening on port %d\n", SERVER_IN_PORT);
	printf("[+] Server sending to %s:%d\n\n", SERVER_OUT_IP, SERVER_OUT_PORT);

	int send_sock_fd = connect_udp_socket("127.0.0.1", 11000);    // SEND requests to Server
	int recv_sock_fd = create_bound_udp_socket("0.0.0.0", 12000); // LISTEN to server updates

	if (send_sock_fd < 0 || recv_sock_fd < 0) {
		fprintf(stderr, "[!] Failed to create sockets (%d)(%d)\n", send_sock_fd, recv_sock_fd);
		return EXIT_FAILURE;
	}

	unsigned long offset = 0;
	int ok = 1;
	char buffer[1024];

	trackAtributes trackInfo;
	carAtributes players[MAX_PLAYERS];

	carAtributes update;

	// Basically a contrutor for carAtributes (because all strings in carAtributes are pointers)
	for (int i = 0; i < MAX_PLAYERS; i++) {
		init_carupdate(&players[i]);
	}
	init_carupdate(&update);

	trackInfo.server_name = (char *)malloc(128);
	trackInfo.track = (char *)malloc(128);
	trackInfo.track_config = (char *)malloc(64);
	trackInfo.weather_graphics = (char *)malloc(64);
	trackInfo.session_name = (char *)malloc(64);

	char message[124] = {0}; // just a place to put info messages from the server itself

	printf("\n");
	while (1) {
		offset = 0;
		u_int8_t str_len_8 = 0;
		memset(buffer, 0, sizeof(buffer));

		// FIX: Its not garanted to receive a full packet in one recvfrom call, but the error -1 is not handled by a unsigned size_t
		size_t recv_bytes = (size_t)recvfrom(recv_sock_fd, buffer, sizeof(buffer), 0, NULL, NULL);

		// Convert buffer to utf-8 string and print it
#if DEBUG_CAR_INFO
		printf("[+] Received %zd bytes from client\n", recv_bytes);
#endif

		// The first byte of the messages is always an ACSP_MessageType
		switch ((int)buffer[0]) {
			// ============================
			// SERVER → CLIENT MESSAGES
			// ============================
		case ACSP_SESSION_INFO:
			printf("[+] Message Type: ACSP_SESSION_INFO\n");
			goto skip_message;
		case ACSP_NEW_SESSION: // DONE
			printf("[+] Message Type: ACSP_NEW_SESSION\n");
		skip_message:
			offset = 1; // Reset offset to 1 to read after message types

			trackInfo.protocol_version = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.session_index = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.current_session_index = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.session_count = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			trackInfo.session_type = (SessionType)trackInfo.session_index; // FOR BACKWARD COMPATIBILITY

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.server_name, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track_config, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.session_name, str_len_8, &ok);

			trackInfo.typ = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.laps = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.wait_time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.ambient_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.road_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.weather_graphics, str_len_8, &ok);

			// FIX: elapsed_ms was/is incorrectly read
			// TEST: Verify with actual server
			trackInfo.elapsed_ms = read_uint32((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			if (!ok) {
				fprintf(stderr, "[-] Error parsing NEW_SESSION packet (offset=%zu)\n", offset);
				break;
			}

			printf("\tServer Name: \"%s\"\n", trackInfo.server_name);
			printf("\tTrack: \"%s\"\n", trackInfo.track);
			printf("\tTrack Config: \"%s\"\n", trackInfo.track_config);
			printf("\tSession Name: \"%s\"\n", trackInfo.session_name);

			printf("\tProtocol Version: %d\tSession Index: %d/%d\tCurrent Session Index: %d\n", trackInfo.protocol_version, trackInfo.session_index, trackInfo.session_count,
			       trackInfo.current_session_index);

			printf("\tType: %d\tTime: %d mins\tLaps: %d\tWait Time: %d secs\n", trackInfo.typ, trackInfo.time, trackInfo.laps, trackInfo.wait_time);
			printf("\tAmbient Temp: %d C\tRoad Temp: %d C\n", trackInfo.ambient_temp, trackInfo.road_temp);
			printf("\tWeather Graphics: %s\n", trackInfo.weather_graphics);
			printf("\tElapsed Time: %d ms (%2d:%2d:%2d)\n\n", trackInfo.elapsed_ms, trackInfo.elapsed_ms / 60000, (trackInfo.elapsed_ms % 60000) / 1000,
			       (trackInfo.elapsed_ms % 60000) % 1000);

			break;

		case ACSP_NEW_CONNECTION: // DONE:
			printf("[+] Message Type: ACSP_NEW_CONNECTION\n");
			offset = 1; // Reset offset to 1 to read after message types

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_name, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_GUID, str_len_8, &ok);

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, update.car_model, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, update.car_skin, str_len_8, &ok);

			if (!ok) {
				fprintf(stderr, "[-] Error parsing NEW_CONNECTION packet (offset=%zu)\n", offset);
				break;
			}

			update.isConnected = 1; // Mark as connected
			update.isLoading = 1;   // Mark as loading

			printf("\tDriver Name: \"%s\"\n", update.driver_name);
			printf("\tDriver GUID: \"%s\"\n", update.driver_GUID);
			printf("\tCar ID: %d\n", update.carID);
			printf("\tCar Model: \"%s\"\n", update.car_model);
			printf("\tCar Skin: \"%s\"\n\n", update.car_skin);

			// Store player player into the respective Index
			if (update.carID < MAX_PLAYERS) {
				memcpy(&players[update.carID], &update, sizeof(carAtributes));
			}

			break;

		case ACSP_CONNECTION_CLOSED: // DONE:
			printf("[+] Message Type: ACSP_CONNECTION_CLOSED\n");
			offset = 1; // Reset offset to 1 to read after message types

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_name, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_GUID, str_len_8, &ok);

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, update.car_model, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, update.car_skin, str_len_8, &ok);

			if (!ok) {
				fprintf(stderr, "[-] Error parsing NEW_CONNECTION packet (offset=%zu)\n", offset);
				break;
			}

			update.isConnected = 0; // Mark as disconnected

			printf("\tDriver Name: \"%s\"\n", update.driver_name);
			printf("\tDriver GUID: \"%s\"\n", update.driver_GUID);
			printf("\tCar ID: %d\n", update.carID);
			printf("\tCar Model: \"%s\"\n", update.car_model);
			printf("\tCar Skin: \"%s\"\n\n", update.car_skin);

			// Store player player into the respective Index
			if (update.carID < MAX_PLAYERS) {
				memcpy(&players[update.carID], &update, sizeof(carAtributes));
			}

			break;

		case ACSP_CAR_UPDATE: // DONE:
#if DEBUG_CAR_INFO
			printf("[+] Message Type: ACSP_CAR_UPDATE\n");
#endif
			offset = 1;

			memcpy(&update.carID, buffer, sizeof(uint8_t));
			offset = 1 + sizeof(uint8_t);
			memcpy(&update.position, buffer + offset, sizeof(postion));
			offset += sizeof(postion);
			memcpy(&update.velocity, buffer + offset, sizeof(postion));
			offset += sizeof(postion);
			memcpy(&update.carGear, buffer + offset, sizeof(u_int8_t));
			offset += sizeof(u_int8_t);
			memcpy(&update.carRPM, buffer + offset, sizeof(uint16_t));
			offset += sizeof(uint16_t);
			memcpy(&update.normalizedSplinePos, buffer + offset, sizeof(float_t));
			offset += sizeof(float_t);

#if DEBUG_CAR_INFO
			printf("\tCar %d Position: X: %.2f Y: %.2f Z: %.2f ", update.carID, update.position.x, update.position.y, update.position.z);
			printf("Gear: %d RPM: %d\n", update.carGear, update.carRPM);
#endif

			// Store player player into the respective index
			if (update.carID < MAX_PLAYERS) {
				memcpy(&players[update.carID].position, &update.position, sizeof(postion));
				memcpy(&players[update.carID].velocity, &update.velocity, sizeof(postion));
				players[update.carID].carGear = update.carGear;
				players[update.carID].carRPM = update.carRPM;
				players[update.carID].normalizedSplinePos = update.normalizedSplinePos;
			}

			break;

		case ACSP_CAR_INFO: // DONE:
			printf("[+] Message Type: ACSP_CAR_INFO\n");
			offset = 1; // Reset offset to 1 to read after message types;

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			update.isConnected = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.car_model, str_len_8, &ok);
			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.car_skin, str_len_8, &ok);
			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_name, str_len_8, &ok);
			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_team, str_len_8, &ok);
			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, update.driver_GUID, str_len_8, &ok);

			if (!ok) {
				fprintf(stderr, "[-] Error parsing CAR_INFO packet (offset=%zu)\n", offset);
			}

			printf("\tCar ID: %d\n", update.carID);
			printf("\tIs Connected: %d\n", update.isConnected);
			printf("\tCar Model: \"%s\"\n", update.car_model);
			printf("\tCar Skin: \"%s\"\n", update.car_skin);
			printf("\tDriver Name: \"%s\"\n", update.driver_name);
			printf("\tDriver Team: \"%s\"\n", update.driver_team);
			printf("\tDriver GUID: \"%s\"\n\n", update.driver_GUID);

			// Store player player into the respective Index
			if (update.carID < MAX_PLAYERS) {
				memcpy(&players[update.carID], &update, sizeof(carAtributes));
			}

			break;

		case ACSP_END_SESSION: // DONE: (only session type cycling)
			printf("[+] Message Type: ACSP_END_SESSION\n");
			// Advance session_type to the next in the enum;

			trackInfo.session_type = (SessionType)((trackInfo.session_type + 1) % 3);

			if (trackInfo.session_type == 0) {
				memcpy(trackInfo.session_name, "Practice", 9);
			} else if (trackInfo.session_type == 1) {
				memcpy(trackInfo.session_name, "Race", 5);
			} else if (trackInfo.session_type == 2) {
				memcpy(trackInfo.session_name, "Qualify", 8);
			}

			printf("\tNext Session Name: %s\n", trackInfo.session_name);
			printf("\tNext Session Type: %d\n\n", trackInfo.session_type);

			break;

		case ACSP_VERSION: // DONE:
			printf("[+] Message Type: ACSP_VERSION\n");
			offset = 1; // Reset offset to 1 to read after message types
			trackInfo.protocol_version = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			printf("\tProtocol Version: %d\n\n", trackInfo.protocol_version);

			break;

		case ACSP_CHAT: // DONE: Receive chat messages
			printf("[+] Message Type: ACSP_CHAT\n");
			offset = 1; // Reset offset to 1 to read after message types

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, message, str_len_8, &ok);

			printf("\tCar ID: %d (%s)\n", update.carID, players[update.carID].driver_name);
			printf("\tMessage: \"%s\"\n\n", message);

			break;

		case ACSP_CLIENT_LOADED: // DONE: Check for client loaded status
			printf("[+] Message Type: ACSP_CLIENT_LOADED\n");
			offset = 1; // Reset offset to 1 to read after message types

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			players[update.carID].isLoading = 0;
			printf("\tCar ID: %d (%s) Finished Loading into the session\n\n", update.carID, players[update.carID].driver_name);

			break;

		case ACSP_ERROR: // DONE: Simple error message from server
			printf("[+] Message Type: ACSP_ERROR\n");
			offset = 1; // Reset offset to 1 to read after message types

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, message, str_len_8, &ok);

			printf("\tServer Message: \"%s\"\n\n", message);
			break;

		case ACSP_LAP_COMPLETED: // DONE: Handle lap completed events
			printf("[+] Message Type: ACSP_LAP_COMPLETED\n");
			offset = 1; // Reset offset to 1 to read after message types

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			// TEST: Possiblity of lap_time not behing correct
			// TODO: Verify with actual server
			update.lap_time = read_uint32((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			update.cuts = read_uint32((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			update.total_cuts = read_uint32((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			printf("\tCar ID: %d (%s)\n", update.carID, players[update.carID].driver_name);
			printf("\tLap Time: %5d ms\n", update.lap_time);
			printf("\tCuts this lap: %d\n", update.cuts);
			printf("\tTotal Cuts (this session): %d\n\n", update.total_cuts);

			break;

		// ============================
		// EVENTS
		// ============================
		case ACSP_CLIENT_EVENT: {
			printf("[+] Message Type: ACSP_CLIENT_EVENT\n");
			offset = 1; // Reset offset to 1 to read after message types

			u_int8_t event_type = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			update.carID = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			u_int8_t event_car_id = 255; // If event doesnt involve another car, set to 255

			switch (event_type) {
			// ============================
			// EVENT TYPES
			// ============================
			case ACSP_CE_COLLISION_WITH_CAR: {
				printf("[+] Event Type: ACSP_CE_COLLISION_WITH_CAR\n");
				event_car_id = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

				printf("Car ID: %d (%s) collided with Car ID: %d (%s)\n", update.carID, players[update.carID].driver_name, event_car_id, players[event_car_id].driver_name);

                
                players[update.carID].collisions++;
                players[event_car_id].collisions++;

                // TODO: Update total contacts for both players in the database
                // TAG:2 Update total contacts for both players
                
			} break;

			case ACSP_CE_COLLISION_WITH_ENV: {
				printf("[+] Event Type: ACSP_CE_COLLISION_WITH_ENV\n");

				printf("Car ID: %d (%s) collided with the environment\n", update.carID, players[update.carID].driver_name);

                players[update.carID].contacts++;

                // TODO: Update total contacts for the player in the database
                // TAG:2 Update total contacts for the player
			} break;
			}

            // TODO: possible iRacing style impact severity system
            // With X velues and (e.g >5 m/s = 0x, >10 m/s = 2x, >15 m/s = 4x) && Blackflag limits (e.g x17 = DQ)

			float impact_speed = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			postion world_pos = {0};
			world_pos.x = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			world_pos.y = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			world_pos.z = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

            postion rel_pos = {0};
            rel_pos.x = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
            rel_pos.y = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
            rel_pos.z = read_float((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

            printf("\tImpact Speed: %.2f m/s\n", impact_speed);
            printf("\tWorld Position: X: %.2f Y: %.2f Z: %.2f\n", world_pos.x, world_pos.y, world_pos.z);
            printf("\tRelative Position: X: %.2f Y: %.2f Z: %.2f\n\n", rel_pos.x, rel_pos.y, rel_pos.z);


		} break;

		// TODO: Add for ranking system
		// OPTIMIZE: Make sure DB queries are optimized for speed has there can be more that 30 players querying at the same time
		//
		// ============================
		// CLIENT → SERVER COMMANDS
		// ============================
		case ACSP_REALTIMEPOS_INTERVAL:
			printf("[+] Command: ACSP_REALTIMEPOS_INTERVAL\n");
			break;

		case ACSP_GET_CAR_INFO:
			printf("[+] Command: ACSP_GET_CAR_INFO\n");
			break;

		case ACSP_SEND_CHAT:
			printf("[+] Command: ACSP_SEND_CHAT\n");
			break;

		case ACSP_BROADCAST_CHAT:
			printf("[+] Command: ACSP_BROADCAST_CHAT\n");
			break;

		case ACSP_GET_SESSION_INFO:
			printf("[+] Command: ACSP_GET_SESSION_INFO\n");
			break;

		case ACSP_SET_SESSION_INFO:
			printf("[+] Command: ACSP_SET_SESSION_INFO\n");
			break;

		case ACSP_KICK_USER:
			printf("[+] Command: ACSP_KICK_USER\n");
			break;

		case ACSP_NEXT_SESSION:
			printf("[+] Command: ACSP_NEXT_SESSION\n");
			break;

		case ACSP_RESTART_SESSION:
			printf("[+] Command: ACSP_RESTART_SESSION\n");
			break;

		case ACSP_ADMIN_COMMAND:
			printf("[+] Command: ACSP_ADMIN_COMMAND\n");
			break;

		// ============================
		// DEFAULT HANDLER
		// ============================
		default:
			printf("[!] Unknown Message Type: %d\n\n", buffer[0]);
			break;
		}

		usleep(10000); // Sleep for 10ms
	}
	close(send_sock_fd);
	close(recv_sock_fd);

	free(trackInfo.server_name);
	free(trackInfo.track);
	free(trackInfo.track_config);
	free(trackInfo.weather_graphics);
	free(trackInfo.session_name);
	return 0;
}