#include "game.h"
#include "card.h"
#include "hand.h"
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#include <unistd.h>
#include <assert.h>
#include <curses.h>
#include <sys/types.h>
#include "ui.h"
#include "global.h"
#include "net.h"

static void init_mainstack(card *stack, const uint32_t size)
{
	assert(stack != NULL);

	// assign card values to main stack
	for(uint32_t i=0, val=MIN_CARD; i<size; i++, val++)
		stack[i] = val;

	// shuffle stack
	for(uint32_t i=0; i<3*size; i++)
	{
		uint32_t x = rand() % size;
		uint32_t y = rand() % size;
		card tmp = stack[x];
		stack[x] = stack[y];
		stack[y] = tmp;
	}
}

static void main_loop_client()
{
	bool running = true;
	gamestate state = STATE_CLIENT_WAIT_CARDS;

	while(running)
	{
		/*
		switch(state)
		{
			case STATE_CLIENT_WAIT_CARDS:
				if(round == 1)
					receive_and_place_table_stacks();
				wait_for_cards_from_server();
				state = STATE_CLIENT_SELECT_OPEN_CARD;
				break;

			case STATE_CLIENT_SELECT_OPEN_CARD:
				select_open_card();
				send_open_card_to_server();
				state = STATE_CLIENT_WAIT_FOR_OPEN_CARDS;
				break;

			case STATE_CLIENT_WAIT_FOR_OPEN_CARDS:
				receive_sorted_list_of_open_cards();
				state = STATE_CLIENT_PLAY_CARDS;
				break;

			case STATE_CLIENT_PLAY_CARDS:
				foreach(open_card)
				{
					play_lowest_open_card
					{
						determine_stack_for_open_card
						{
							if (stack_has_to_be_picked)
							{
								if (we_have_to_pick)
								{
									pick_stack();
									send_stack_to_server();
								}
								else // another client has to pick
								{
									receive_stack();
								}

								clear_stack(stack_id);
							}
						}
						place_card()
						{
							if(count_stack_cards == 6)
								clear_stack(stack_id);
						}
					}

				}
				if (we_have_hand_cards)
				{
					state = STATE_CLIENT_SELECT_OPEN_CARD;
				}
				else
				{
					receive_next_server_action();
					if (server_action == DEAL_CARDS)
					{
						state = STATE_CLIENT_WAIT_CARDS;
					}
					else if (server_action == GAME_FINISHED)
						state = STATE_CLIENT_GAME_FINISHED;
				}
				break;

			default:
				assert(false); // should never happen
		}
		*/
	}

}

static void main_loop_server()
{
	bool running = true;
	gamestate state = STATE_SERVER_DEAL_CARDS;

	while(running)
	{
		/*
		switch(state)
		{
			case STATE_SERVER_DEAL_CARDS:
				if(round == 1)
					send_and_place_table_stacks();
				deal_cards_to_clients();
				state = STATE_SERVER_WAIT_OPEN_CARDS;
				break;

			case STATE_SERVER_WAIT_FOR_OPEN_CARDS:
				receive_open_cards_from_clients();
				sort_open_card_list(); // in ascending order 
				send_open_card_list_to_clients();
				state = STATE_SERVER_PLAY_CARDS;
				break;

			case STATE_SERVER_PLAY_CARDS:
				foreach(open_card)
				{
					play_lowest_open_card
					{
						determine_stack_for_open_card
						{
							if (stack_has_to_be_picked) {
								receive_stack_from_client();
								send_received_stack_to_other_clients();
								clear_stack(stack_id);
							}
						}
						place_card()
						{
							if(count_stack_cards == 6)
								clear_stack(stack_id);
						}
					}

				}
				if (clients_have_hand_cards)
				{
					state = STATE_SERVER_WAIT_FOR_OPEN_CARDS;
				}
				else
				{
					if (main_stack_has_enough_cards_for_clients)
					{
						send_action_to_client(DEAL_CARDS);
						state = STATE_SERVER_DEAL_CARDS;
					}
					else
					{
						send_action_to_client(GAME_FINISHED);
						state = STATE_SERVER_GAME_FINISHED;
					}
				}
				break;

			default:
				assert(false); // should never happen
		}
		*/
	}

}

void start_game(const bool servermode, const char* addr, const char* port)
{
	assert(addr != NULL && port != NULL);

	bool server_process = false;
	int cards = MAX_CARD - MIN_CARD + 1;
	card mainstack[cards];
	data_store* data = datamodel();

	srand(time(0));

	init_mainstack(mainstack, cards);

	// Example data set for table cards window
	const card_stack_t _cs1 = { { 1, 2, 3, 4, 101 } };
	const card_stack_t _cs2 = { { 6, 7, 53, 0, 0 } };
	const card_stack_t _cs3 = { { 11, 55, 0, 0, 0 } };
	const card_stack_t _cs4 = { { 17, 29, 36, 42, 0 } };
	//data->table_stacks = { { _cs1, _cs2, _cs3, _cs4 } };
	data->table_stacks.stacks[0] = _cs1;
	data->table_stacks.stacks[1] = _cs2;
	data->table_stacks.stacks[2] = _cs3;
	data->table_stacks.stacks[3] = _cs4;
	//const table_stacks_t ts = { { _cs1, _cs2, _cs3, _cs4 } };

	// The stack points window uses ts, too, so there is no separate data set

	// Example data set for current state window
	pnoc_t pnoc[10] = {
		{0, "$you", 10},
		{1, "1234567890", 23},
		{2, "baz", 38},
		{3, "foo_bar", 14},
		{4, "lolcat", 60},
		{5, "blablub123", 15},
		{6, "abcdefg", 103},
		{7, "hello", 98},
		{8, "hornoxe", 33},
		{9, "1337nick", 74}
	};
	pnoc_sort(pnoc, 10);
	const uint8_t num_players = 10;
	const uint32_t score = 10;

	// Example data set for hand cards window
	const hand_t h =  { {22, 0, 12, 85, 27, 69, 78, 0, 77, 0} };
	data->hand = h;
	hand_sort(&data->hand);

	if(servermode)
	{
		pid_t child = fork();
		server_process = (child > 0);
	}

	if(server_process) // Start server and connect to localhost
	{
		int ssock;
		uint8_t num_opponents = 1;

		ssock = server_start(port);
		server_get_players(ssock, num_opponents);

		main_loop_server();
	}
	else // Connect to server
	{
		int sock;

		sleep(1); // TODO make sure server process is listening
		sock = client_connect_server(addr, port);
		client_hello(sock, "nickname_client");
		net_recv(sock, msg_type_start_game);
		net_recv(sock, msg_type_deal_cards);

		ui_init();

		// Display all windows
		ui_display_wnd_table_cards(&data->table_stacks, false, 0);
		ui_display_wnd_stack_points(&data->table_stacks, false, 0);
		ui_display_wnd_current_state(pnoc, num_players, 2, score);
		ui_display_wnd_hand_cards(&data->hand, false, 0);

		main_loop_client();

		ui_fini();
	}
}