#include "vehicle.h"

#include "station.h"

#include "settings.h"

// This file handles all the server-commands

void NetworkPopulateCompanyInfo(void);

// Is the network enabled?

// **********

// Sending functions

// **********

{

	//

	// Packet: SERVER_CLIENT_INFO

	// Function: Sends info about a client

	// Data:

	//    uint16:  The index of the client (always unique on a server. 1 = server)

			NetworkSend_string(p, _network_player_info[player->index].players);

		NetworkSend_Packet(p, cs);

	}

}

{

	//

	// Packet: SERVER_ERROR

	// Function: The client made an error

	// Data:

	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)

	//

	char str1[100], str2[100];

	char client_name[NETWORK_NAME_LENGTH];

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

	NetworkSend_uint8(p, error);

	NetworkSend_Packet(p, cs);

	cs->quited = true;

	// Make sure the data get's there before we close the connection

	NetworkSend_Packets(cs);

	// The client made a mistake, so drop his connection now!

}

{

	//

	// Packet: SERVER_NEED_PASSWORD

	// Function: Indication to the client that the server needs a password

	// Data:

	//    uint8:  Type of password

	// Function: The client is joined and ready to receive his map

	// Data:

	//    uint16:  Own ClientID

	//

	Packet *p;

	// Invalid packet when status is AUTH or higher

	if (cs->status >= STATUS_AUTH)

		return;

	cs->status = STATUS_AUTH;

	// Function: The client can not receive the map at the moment because

	//             someone else is already receiving the map

	// Data:

	//    uint8:  Clients awaiting map

	//

	int waiting = 0;

	Packet *p;

	// Count how many players are waiting in the queue

	FOR_ALL_CLIENTS(new_cs) {

		if (new_cs->status == STATUS_MAP_WAIT)

			waiting++;

				// Set the status to DONE_MAP, no we will wait for the client

				//  to send it is ready (maybe that happens like never ;))

				cs->status = STATUS_DONE_MAP;

				fclose(file_pointer);

				{

					bool new_map_client = false;

					// Check if there is a client waiting for receiving the map

					//  and start sending him the map

					FOR_ALL_CLIENTS(new_cs) {

						if (new_cs->status == STATUS_MAP_WAIT) {

							// Check if we already have a new client to send the map to

			// Not everything is sent, decrease the sent_packets

			if (sent_packets > 1) sent_packets /= 2;

		}

	}

}

{

	//

	// Packet: SERVER_JOIN

	// Function: A client is joined (all active clients receive this after a

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

	//     PACKET_SERVER_CLIENT_INFO

#ifdef NETWORK_SEND_DOUBLE_SEED

	NetworkSend_uint32(p, _sync_seed_2);

#endif

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_COMMAND

	// Function: Sends a DoCommand to the client

	// Data:

	//    uint8:  PlayerID (0..MAX_PLAYERS-1)

	NetworkSend_uint8(p, cp->callback);

	NetworkSend_uint32(p, cp->frame);

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_CHAT

	// Function: Sends a chat-packet to the client

	// Data:

	//    uint8:  ActionID (see network_data.h, NetworkAction)

	NetworkSend_uint16(p, client_index);

	NetworkSend_string(p, msg);

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_ERROR_QUIT

	// Function: One of the clients made an error and is quiting the game

	//      This packet informs the other clients of that.

	// Data:

	NetworkSend_uint16(p, client_index);

	NetworkSend_uint8(p, errorno);

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_ERROR_QUIT

	// Function: A client left the game, and this packets informs the other clients

	//      of that.

	// Data:

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEWGAME);

	NetworkSend_Packet(p, cs);

}

// **********

// Receiving functions

// **********

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO)

{

	SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)(cs);

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_JOIN)

{

	char name[NETWORK_NAME_LENGTH];

	char unique_id[NETWORK_NAME_LENGTH];

	NetworkClientInfo *ci;

	char test_name[NETWORK_NAME_LENGTH];

	SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);

	return;

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP)

{

	// The client was never joined.. so this is impossible, right?

	//  Ignore the packet, give the client a warning, and close his connection

	if (cs->status < STATUS_AUTH || cs->quited) {

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

		return;

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_MAP_OK)

{

	// Client has the map, now start syncing

	if (cs->status == STATUS_DONE_MAP && !cs->quited) {

		char client_name[NETWORK_NAME_LENGTH];

		char str[100];

		GetString(str, STR_NETWORK_CLIENT_JOINED);

		NetworkGetClientName(client_name, sizeof(client_name), cs);

		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, client_name, str);

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND)

{

	// The client has done a command and wants us to handle it

	int i;

	byte callback;

	NetworkClientInfo *ci;

	char *dparam_char;

	CommandPacket *cp = malloc(sizeof(CommandPacket));

	// The client was never joined.. so this is impossible, right?

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_ERROR)

{

	// This packets means a client noticed an error and is reporting this

	//  to us. Display the error and report it to the other clients

	byte errorno = NetworkRecv_uint8(p);

	char str1[100], str2[100];

	char client_name[NETWORK_NAME_LENGTH];

	// The client was never joined.. thank the client for the packet, but ignore it

	if (cs->status < STATUS_DONE_MAP || cs->quited) {

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_QUIT)

{

	// The client wants to leave. Display this and report it to the other

	//  clients.

	char str1[100], str2[100];

	char client_name[NETWORK_NAME_LENGTH];

	// The client was never joined.. thank the client for the packet, but ignore it

	if (cs->status < STATUS_DONE_MAP || cs->quited) {

		cs->quited = true;

}

void NetworkServer_HandleChat(NetworkAction action, DestType desttype, int dest, const char *msg, byte from_index)

{

	NetworkClientInfo *ci, *ci_own, *ci_to;

	switch (desttype) {

	case DESTTYPE_CLIENT:

		if (dest == 1) {

			ci = NetworkFindClientInfoFromIndex(from_index);

			NetworkUpdateClientInfo(ci->client_index);

		}

	}

}

// The layout for the receive-functions by the server

// This array matches PacketType. At an incoming

//  packet it is matches against this array

//  and that way the right function to handle that

//  packet is found.

extern const SettingDesc patch_settings[];

// This is a TEMPORARY solution to get the patch-settings

//  to the client. When the patch-settings are saved in the savegame

//  this should be removed!!

{

	const SettingDesc *item;

	Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

	NetworkSend_uint8(p, MAP_PACKET_PATCH);

	// Now send all the patch-settings in a pretty order..

void NetworkPopulateCompanyInfo(void)

{

	char password[NETWORK_PASSWORD_LENGTH];

	Player *p;

	Vehicle *v;

	Station *s;

	NetworkClientInfo *ci;

	int i;

	uint16 months_empty;

	FOR_ALL_PLAYERS(p) {

		if (!p->is_active) {

	}

}

// Send a packet to all clients with updated info about this client_index

void NetworkUpdateClientInfo(uint16 client_index)

{

	NetworkClientInfo *ci;

	ci = NetworkFindClientInfoFromIndex(client_index);

	if (ci == NULL)

		return;

    Two things happen:

      1) If a company is not protected, it is closed after 1 year (for example)

      2) If a company is protected, protection is disabled after 3 years (for example)

           (and item 1. happens a year later) */

static void NetworkAutoCleanCompanies()

{

	NetworkClientInfo *ci;

	Player *p;

	bool clients_in_company[MAX_PLAYERS];

	if (!_network_autoclean_companies)

		return;

}

// This function changes new_name to a name that is unique (by adding #1 ...)

//  and it returns true if that succeeded.

bool NetworkFindName(char new_name[NETWORK_NAME_LENGTH])

{

	NetworkClientInfo *ci;

	bool found_name = false;

	byte number = 0;

	char original_name[NETWORK_NAME_LENGTH];

	// We use NETWORK_NAME_LENGTH in here, because new_name is really a pointer

	}

	return found_name;

}

// Reads a packet from the stream

{

	Packet *p;

	NetworkRecvStatus res;

	while((p = NetworkRecv_Packet(cs, &res)) != NULL) {

		byte type = NetworkRecv_uint8(p);

		if (type < PACKET_END && _network_server_packet[type] != NULL)

	}

	return true;

}

// Handle the local command-queue

	if (cs->command_queue != NULL) {

		CommandPacket *cp;

		CommandPacket *cp_prev;

		cp = cs->command_queue;

		cp_prev = NULL;

// This is called every tick if this is a _network_server

void NetworkServer_Tick(void)

{

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

	static uint32 last_sync_frame = 0;

#endif

	bool send_frame = false;

	// Update max-frame-counter

	if (_frame_counter > _frame_counter_max) {

		_frame_counter_max = _frame_counter + _network_frame_freq;

		send_frame = true;

			int lag = NetworkCalculateLag(cs) / DAY_TICKS;

			if (lag > 0) {

				if (lag > 3) {

					// Client did still not report in after 4 game-day, drop him

					//  (that is, the 3 of above, + 1 before any lag is counted)

					IConsolePrintF(_iconsole_color_error,"Client #%d is dropped because the client did not respond for more then 4 game-days", cs->index);

					continue;

				}

				// Report once per time we detect the lag

				if (cs->lag_test == 0) {

					IConsolePrintF(_iconsole_color_warning,"[%d] Client #%d is slow, try increasing *net_frame_freq to a higher value!", _frame_counter, cs->index);

#endif

	/* See if we need to advertise */

	NetworkUDPAdvertise();

}

{

	NetworkAutoCleanCompanies();

}

#endif /* ENABLE_NETWORK */