#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include <enet/enet.h>
#include <GL/glfw.h>

#include "common.h"
#include "game.h"

GLUquadricObj *quadratic;
ENetHost *host;
ENetPeer *client_peer;
player_t *local_player;

void key_callback(int key, int state) {

}

void setup_opengl() {
	// Initialise GLFW
	if (!glfwInit()) {
		fprintf(stderr, "Failed to initialize GLFW\n");
		exit(EXIT_FAILURE);
	}

	// Open OpenGL window
	if (!glfwOpenWindow(640, 480, 0, 0, 0, 0, 0, 0, GLFW_WINDOW)) {
		fprintf(stderr, "Failed to open GLFW window\n");
		glfwTerminate();
		exit(EXIT_FAILURE);
	}
	//glfwDisable(GLFW_MOUSE_CURSOR);
	glfwSetWindowTitle("Gremlin Lan Party Game");
	glfwSetKeyCallback(key_callback);
	// Enable sticky keys
	glfwEnable(GLFW_STICKY_KEYS);

	// general settings
	glShadeModel(GL_SMOOTH);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	glEnable(GL_CULL_FACE);

	// setup depth buffer
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);

	GLfloat LightAmbient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
	GLfloat LightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	GLfloat LightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f };

	// setup directional light
	glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
	glLightfv(GL_LIGHT1, GL_POSITION, LightPosition);
	glEnable(GL_LIGHT1);
	glEnable(GL_LIGHTING);

	// Enable vertical sync (on cards that support it)
	glfwSwapInterval(1);
}

void draw_team(team_t *team) {
	size_t i = 0;
	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, team->color);
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glTranslated(team->x, team->y, team->z);
	gluSphere(quadratic, 50.f, 32, 32);
	glPopMatrix();
}

void draw_player(player_t *player) {
	if (player->status == 0)
		return;
	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, player->team->color);
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glTranslated(player->x, player->y, player->z);
	gluSphere(quadratic, 10.f, 32, 32);
	glPopMatrix();
}

void setup_network(const char *remote) {
	if (enet_initialize() != 0) {
		fprintf(stderr, "An error occurred while initializing ENet.\n");
		exit(EXIT_FAILURE);
	}

	if (remote == NULL) {
		ENetAddress address;

		address.host = ENET_HOST_ANY;
		address.port = 1234;

		host = enet_host_create(&address, 32, 2, 0, 0);
		if (host == NULL) {
			fprintf(stderr,
					"An error occurred while trying to create an ENet server host.\n");
			exit(EXIT_FAILURE);
		}
	} else {
		ENetAddress address;
		ENetEvent event;

		host = enet_host_create(NULL, 1, 2, 57600 / 8, 14400 / 8);
		if (host == NULL) {
			fprintf(stderr,
					"An error occurred while trying to create an ENet client host.\n");
			exit(EXIT_FAILURE);
		}

		enet_address_set_host(&address, remote);
		address.port = 1234;

		/* Initiate the connection, allocating the two channels 0 and 1. */
		client_peer = enet_host_connect(host, &address, 2, 0);

		if (client_peer == NULL) {
			fprintf(stderr,
					"No available peers for initiating an ENet connection.\n");
			exit(EXIT_FAILURE);
		}

		/* Wait up to 5 seconds for the connection attempt to succeed. */
		if (enet_host_service(host, &event, 5000) > 0 && event.type
				== ENET_EVENT_TYPE_CONNECT) {
			puts("Connection succeeded.");
		} else {
			/* Either the 5 seconds are up or a disconnect event was */
			/* received. Reset the peer in the event the 5 seconds   */
			/* had run out without any significant event.            */
			enet_peer_reset(client_peer);

			fprintf(stderr, "Connection to %s failed.", remote);
		}
	}

}

#define MESSAGE_PLAYER_SPAWN 0
#define MESSAGE_PLAYER_KILL 1
#define MESSAGE_ACCEPT 2
#define MESSAGE_PLAYER_UPDATE 3
#define MESSAGE_PLAYER_ACCELERATE 4

typedef struct message_t {
	uint16_t msg_id;
} message_t;

typedef struct player_spawn_message_t {
	uint16_t msg_id;
	uint8_t team_id;
	uint8_t player_id;
} player_spawn_message_t;

typedef struct player_kill_message_t {
	uint16_t msg_id;
	uint8_t player_id;
} player_kill_message_t;

typedef struct accept_message_t {
	uint16_t msg_id;
	uint8_t player_id;
} accept_message_t;

typedef struct player_update_message_t {
	uint16_t msg_id;
	uint8_t player_id;
	unsigned int session;
	double x, y, z;
	double vx, vy, vz;
} player_update_message_t;

typedef struct player_accelerate_message_t {
	uint16_t msg_id;
	uint8_t player_id;
	double x, y, z;
} player_accelerate_message_t;

void send_player_updates(game_t *game) {
	size_t i;
	for (i = 0; i < GAME_PLAYER_COUNT; i++) {
		if (game->player[i].status == 0)
			continue;
		player_update_message_t msg;
		msg.msg_id = MESSAGE_PLAYER_UPDATE;
		msg.player_id = game->player[i].id;
		msg.x = game->player[i].x;
		msg.y = game->player[i].y;
		msg.z = game->player[i].z;
		msg.vx = game->player[i].vx;
		msg.vy = game->player[i].vy;
		msg.vz = game->player[i].vz;
		ENetPacket * packet = enet_packet_create (&msg, sizeof(msg), 0);
		enet_host_broadcast(host, 0, packet);
	}
}

void service_network(game_t *game) {
	ENetEvent event;

	/* Wait up to 1000 milliseconds for an event. */
	while (enet_host_service(host, &event, 0) > 0) {
		switch (event.type) {
		case ENET_EVENT_TYPE_CONNECT:
			printf("A new client connected from %x:%u.\n",
					event.peer->address.host, event.peer->address.port);
			{
				// bring new client up to date
				size_t i;
				for (i = 0; i < GAME_PLAYER_COUNT; i++) {
					if (game->player[i].status == 0)
						continue;
					// send player spawn message
					player_spawn_message_t spwan_msg;
					spwan_msg.msg_id = MESSAGE_PLAYER_SPAWN;
					spwan_msg.team_id = game->player[i].team->id;
					spwan_msg.player_id =  game->player[i].id;
					ENetPacket * packet = enet_packet_create (&spwan_msg, sizeof(spwan_msg), ENET_PACKET_FLAG_RELIABLE);
					enet_peer_send(event.peer, 0, packet);
				}

				team_t *team = game_team_with_least_players(game);
				player_t *player = game_spawn_player(game, team);
				printf("Spwan as %d.%d\n", team->id, player->id);
				event.peer->data = player;

				// send player spawn message
				player_spawn_message_t spwan_msg;
				spwan_msg.msg_id = MESSAGE_PLAYER_SPAWN;
				spwan_msg.team_id = team->id;
				spwan_msg.player_id = player->id;
				ENetPacket * packet = enet_packet_create (&spwan_msg, sizeof(spwan_msg), ENET_PACKET_FLAG_RELIABLE);
				enet_host_broadcast(host, 0, packet);

				// send team and player
				accept_message_t msg;
				msg.msg_id = MESSAGE_ACCEPT;
				msg.player_id = player->id;
				packet = enet_packet_create (&msg, sizeof(msg), ENET_PACKET_FLAG_RELIABLE);
				enet_peer_send (event.peer, 0, packet);

				// send state
			}
			break;

		case ENET_EVENT_TYPE_RECEIVE: {
#if 0
			printf(
					"A packet of length %u was received from %s on channel %u.\n",
					event.packet->dataLength, event.packet->data,
					event.peer->data, event.channelID);
#endif
			/* Clean up the packet now that we're done using it. */
			message_t *msg = (message_t *)event.packet->data;
			switch(msg->msg_id) {
			case MESSAGE_PLAYER_SPAWN:
				{
					player_spawn_message_t *sm = (player_spawn_message_t *)event.packet->data;
					team_t *team = game_team(game, sm->team_id);
					player_t *player = game_spawn_player_id(game, team, sm->player_id);
				}
				break;
			case MESSAGE_PLAYER_KILL:
				{
					player_kill_message_t *sm = (player_kill_message_t *)event.packet->data;
					player_t *player = game_player(game, sm->player_id);
					player->status = 0;
					player->team = 0;
				}
				break;
			case MESSAGE_ACCEPT:
				{
					accept_message_t *am = (accept_message_t *)event.packet->data;
					local_player = game_player(game, am->player_id);
					printf("Spwan as %d.%d\n", local_player->team->id,  local_player->id);
				}
				break;
			case MESSAGE_PLAYER_UPDATE:
				{
					player_update_message_t *um = (player_update_message_t *)event.packet->data;
					player_t *player = game_player(game, um->player_id);
					player->x = um->x;
					player->y = um->y;
					player->z = um->z;
					player->vx = um->vx;
					player->vy = um->vy;
					player->vz = um->vz;
				}
				break;
			case MESSAGE_PLAYER_ACCELERATE:
				{
					player_accelerate_message_t *um = (player_accelerate_message_t *)event.packet->data;
					player_t *player = game_player(game, um->player_id);
					player->vx += um->x;
					player->vy += um->y;
					player->vz += um->z;
				}
				break;
			};

			enet_packet_destroy(event.packet);

			break;
									  }
		case ENET_EVENT_TYPE_DISCONNECT:
			printf("%s disconected.\n", event.peer -> data);
			{
			/* Reset the peer's client information. */
			player_t *player = (player_t *)event.peer->data;
			player->status = 0;
			player->team = 0;

			// send player spawn message
			player_kill_message_t msg;
			msg.msg_id = MESSAGE_PLAYER_KILL;
			msg.player_id = player->id;
			ENetPacket * packet = enet_packet_create (&msg, sizeof(msg), ENET_PACKET_FLAG_RELIABLE);
			enet_host_broadcast(host, 0, packet);
			}
			event.peer->data = NULL;
			break;
		}
	}

}

void accelerate(double x, double y, double z) {
	local_player->vx += x;
	local_player->vy += y;
	local_player->vz += z;
	if (client_peer) {
		player_accelerate_message_t msg;
		msg.msg_id = MESSAGE_PLAYER_ACCELERATE;
		msg.player_id = local_player->id;
		msg.x = x;
		msg.y = y;
		msg.z = z;
		ENetPacket * packet = enet_packet_create (&msg, sizeof(msg), ENET_PACKET_FLAG_RELIABLE);
		enet_peer_send (client_peer, 0, packet);
	}
}

int main(int argc, char ** argv) {
	int width, height, x, y, last_x, last_y;
	double time, last_time, phi = 0.0, theta = 0.0, last_player_update;
	GLboolean running;
	int server = 0;

	quadratic = gluNewQuadric();
	gluQuadricNormals(quadratic, GLU_SMOOTH);
	gluQuadricTexture(quadratic, GL_TRUE);

	game_t game;

	game_setup(&game);


	setup_opengl();

	if (argc > 1) {
		server = 0;
		setup_network(argv[1]);
	} else {
		server = 1;
		setup_network(NULL);
		team_t *team = game_team(&game, 0);
		local_player = game_spawn_player(&game, team);
	}
	float plane_color[] = {0.2f, 0.3f, 0.4f, 1.0f};
	size_t i;
	running = GL_TRUE;
	last_time = glfwGetTime();
	last_player_update = last_time;
	glfwGetMousePos(&last_x, &last_y);
	while (running) {
		// Get time and mouse position
		time = glfwGetTime();
		double dt = time - last_time;
		glfwGetMousePos(&x, &y);
		if (glfwGetMouseButton(GLFW_MOUSE_BUTTON_2) == GLFW_PRESS) {
			phi += (x - last_x) * 0.01;
			theta += (y - last_y) * -0.01;
			if (theta > 1.5)
				theta = 1.5;
			if (theta < -1.5)
				theta = -1.5;
		}
		last_x = x;
		last_y = y;

		double rx = cos(phi) * cos(theta);
		double ry = sin(theta);
		double rz = sin(phi) * cos(theta);
		double v = 50.0f * dt;
		if (glfwGetKey('W')) {
			accelerate(rx * v, ry * v, rz * v);
		} else if (glfwGetKey('S')) {
			accelerate(rx * -v, ry * -v, rz * -v);
		} else if (glfwGetKey('A')) {
			accelerate(rz * v, 0, -rx * v);
		} else if (glfwGetKey('D')) {
			accelerate(-rz * v, 0, rx *v);
		}

		// Get window size (may be different than the requested size)
		glfwGetWindowSize(&width, &height);
		height = height > 0 ? height : 1;

		// Set viewport
		glViewport(0, 0, width, height);

		// Clear color buffer
		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		// Select and setup the projection matrix
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(60.0f, (GLfloat) width / (GLfloat) height, 1.0f,
				10000.0f);

		// Select and setup the modelview matrix
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		if (local_player) {
			gluLookAt(local_player->x, local_player->y,
					local_player->z, // Eye-position
					local_player->x + cos(phi) * cos(theta) * 10.0f,
					local_player->y + sin(theta) * 10.0f, local_player->z
							+ sin(phi) * cos(theta) * 10.0f, // View-point
					0.0f, 1.0f, 0.0f); // Up-vector
		} else {
			gluLookAt(100.0f, 100.0f, 100.0f, // Eye-position
					100.0f + cos(phi) * cos(theta) * 10.0f, 100.0f + sin(theta)
							* 10.0f, 100.0f + sin(phi) * cos(theta) * 10.0f, // View-point
					0.0f, 1.0f, 0.0f); // Up-vector
		}

		glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, plane_color);
		// Draw a textured quad
		glBegin(GL_QUADS);
		glVertex3f(-5000.0f, 5000.0f, -5000.0f);
		glVertex3f(5000.0f, 5000.0f, -5000.0f);
		glVertex3f(5000.0f, 5000.0f, 5000.0f);
		glVertex3f(-5000.0f, 5000.0f, 5000.0f);
		glEnd();

		service_network(&game);
		if (server) {
			if (time > last_player_update + 0.1)
			{
				send_player_updates(&game);
				last_player_update = time;
			}
		}

		game_update_players(&game, dt);

		for (i = 0; i < GAME_TEAM_COUNT; i++)
			draw_team(&game.team[i]);

		for (i = 0; i < GAME_PLAYER_COUNT; i++)
			draw_player(&game.player[i]);

		// Swap buffers
		glfwSwapBuffers();


		// Check if the ESC key was pressed or the window was closed
		running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);

		last_time = time;
	}

	gluDeleteQuadric(quadratic);

	enet_host_destroy(host);
	enet_deinitialize();

	// Close OpenGL window and terminate GLFW
	glfwTerminate();

	exit(EXIT_SUCCESS);
}