/*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2006-2008 Igor Ulyanov <iulyanov@gmail.com>

 * Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com>

 * Copyright (c) 2012 Simeon Maxein <smaxein@googlemail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 */

#include "netprotocol.h"

#include "../util/logging.h"

#include "../util/util.h"

#include "../model/roomlist.h"

#include "../md5/md5.h"

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <ctype.h>

static void defaultCallback_onMessage(void *context, int msgtype, const char *msg) {

	flib_log_i("Net: [%i] %s", msgtype, msg);

}

static void defaultCallback_void(void *context) {}

static void defaultCallback_bool(void *context, bool isChief) {}

static void defaultCallback_str(void *context, const char *str) {}

static void defaultCallback_int_str(void *context, int i, const char *str) {}

static void defaultCallback_str_str(void *context, const char *str1, const char *str2) {}

static void defaultCallback_str_bool(void *context, const char *str, bool b) {}

static void defaultCallback_onRoomAdd(void *context, const flib_roomlist_room *room) {}

static void defaultCallback_onRoomUpdate(void *context, const char *oldName, const flib_roomlist_room *room) {}

static void defaultCallback_onChat(void *context, const char *nick, const char *msg) {

	flib_log_i("%s: %s", nick, msg);

}

// Change the name by suffixing it with a number. If it already ends in a number, increase that number by 1.

static void defaultCallback_onNickTaken(void *context, const char *requestedNick) {

	flib_netconn *conn = context;

	size_t namelen = strlen(requestedNick);

	int digits = 0;

	while(digits<namelen && isdigit(requestedNick[namelen-1-digits])) {

		digits++;

	}

	long suffix = 0;

	if(digits>0) {

		suffix = atol(requestedNick+namelen-digits)+1;

	}

	char *newPlayerName = flib_asprintf("%.*s%li", namelen-digits, requestedNick, suffix);

	if(newPlayerName) {

		flib_netconn_send_nick(conn, newPlayerName);

	} else {

		flib_netconn_send_quit(conn, "Nick already taken.");

	}

	free(newPlayerName);

}

// Default behavior: Quit

static void defaultCallback_onPasswordRequest(void *context, const char *requestedNick) {

	flib_netconn_send_quit((flib_netconn*)context, "Authentication failed");

}

static void defaultCallback_onTeamAdd(void *context, flib_team *team) {}

static void clearCallbacks(flib_netconn *conn) {

	flib_netconn_onMessage(conn, NULL, NULL);

	flib_netconn_onConnected(conn, NULL, NULL);

	flib_netconn_onDisconnected(conn, NULL, NULL);

	flib_netconn_onRoomAdd(conn, NULL, NULL);

	flib_netconn_onRoomDelete(conn, NULL, NULL);

	flib_netconn_onRoomUpdate(conn, NULL, NULL);

	flib_netconn_onChat(conn, NULL, NULL);

	flib_netconn_onLobbyJoin(conn, NULL, NULL);

	flib_netconn_onLobbyLeave(conn, NULL, NULL);

	flib_netconn_onRoomJoin(conn, NULL, NULL);

	flib_netconn_onRoomLeave(conn, NULL, NULL);

	flib_netconn_onNickTaken(conn, NULL, NULL);

	flib_netconn_onPasswordRequest(conn, NULL, NULL);

	flib_netconn_onRoomChiefStatus(conn, NULL, NULL);

}

flib_netconn *flib_netconn_create(const char *playerName, flib_cfg_meta *metacfg, const char *host, uint16_t port) {

	flib_netconn *result = NULL;

	if(!playerName || !metacfg || !host) {

		flib_log_e("null parameter in flib_netconn_create");

	} else {

		flib_netconn *newConn = flib_calloc(1, sizeof(flib_netconn));

		if(newConn) {

			newConn->netconnState = NETCONN_STATE_CONNECTING;

			newConn->isAdmin = false;

			newConn->isChief = false;

			newConn->metaCfg = flib_cfg_meta_retain(metacfg);

			newConn->roomList = flib_roomlist_create();

			newConn->running = false;

			newConn->destroyRequested = false;

			clearCallbacks(newConn);

			newConn->netBase = flib_netbase_create(host, port);

			newConn->playerName = flib_strdupnull(playerName);

			if(newConn->netBase && newConn->playerName && newConn->roomList) {

				result = newConn;

				newConn = NULL;

			}

		}

		flib_netconn_destroy(newConn);

	}

	return result;

}

void flib_netconn_destroy(flib_netconn *conn) {

	if(conn) {

		if(conn->running) {

			/*

			 * The function was called from a callback, so the tick function is still running

			 * and we delay the actual destruction. We ensure no further callbacks will be

			 * sent to prevent surprises.

			 */

			clearCallbacks(conn);

			conn->destroyRequested = true;

		} else {

			flib_netbase_destroy(conn->netBase);

			flib_cfg_meta_release(conn->metaCfg);

			flib_roomlist_destroy(conn->roomList);

			free(conn->playerName);

			free(conn);

		}

	}

}

const flib_roomlist *flib_netconn_get_roomlist(flib_netconn *conn) {

	const flib_roomlist *result = NULL;

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_get_roomlist");

	} else {

		result = conn->roomList;

	}

	return result;

}

bool flib_netconn_is_chief(flib_netconn *conn) {

	bool result = false;

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_is_chief");

	} else if(conn->netconnState == NETCONN_STATE_ROOM || conn->netconnState == NETCONN_STATE_INGAME) {

		result = conn->isChief;

	}

	return result;

}

/*

 * Callback registration functions

 */

void flib_netconn_onMessage(flib_netconn *conn, void (*callback)(void *context, int msgtype, const char *msg), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onMessage");

	} else {

		conn->onMessageCb = callback ? callback : &defaultCallback_onMessage;

		conn->onMessageCtx = context;

	}

}

void flib_netconn_onConnected(flib_netconn *conn, void (*callback)(void *context), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onConnected");

	} else {

		conn->onConnectedCb = callback ? callback : &defaultCallback_void;

		conn->onConnectedCtx = context;

	}

}

void flib_netconn_onDisconnected(flib_netconn *conn, void (*callback)(void *context, int reason, const char *message), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onDisconnected");

	} else {

		conn->onDisconnectedCb = callback ? callback : &defaultCallback_int_str;

		conn->onDisconnectedCtx = context;

	}

}

void flib_netconn_onRoomAdd(flib_netconn *conn, void (*callback)(void *context, const flib_roomlist_room *room), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onRoomAdd");

	} else {

		conn->onRoomAddCb = callback ? callback : &defaultCallback_onRoomAdd;

		conn->onRoomAddCtx = context;

	}

}

void flib_netconn_onRoomDelete(flib_netconn *conn, void (*callback)(void *context, const char *name), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onRoomDelete");

	} else {

		conn->onRoomDeleteCb = callback ? callback : &defaultCallback_str;

		conn->onRoomDeleteCtx = context;

	}

}

void flib_netconn_onRoomUpdate(flib_netconn *conn, void (*callback)(void *context, const char *oldName, const flib_roomlist_room *room), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onRoomUpdate");

	} else {

		conn->onRoomUpdateCb = callback ? callback : &defaultCallback_onRoomUpdate;

		conn->onRoomUpdateCtx = context;

	}

}

void flib_netconn_onChat(flib_netconn *conn, void (*callback)(void *context, const char *nick, const char *msg), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onChat");

	} else {

		conn->onChatCb = callback ? callback : &defaultCallback_onChat;

		conn->onChatCtx = context;

	}

}

void flib_netconn_onLobbyJoin(flib_netconn *conn, void (*callback)(void *context, const char *nick), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onLobbyJoin");

	} else {

		conn->onLobbyJoinCb = callback ? callback : &defaultCallback_str;

		conn->onLobbyJoinCtx = context;

	}

}

void flib_netconn_onLobbyLeave(flib_netconn *conn, void (*callback)(void *context, const char *nick, const char *partMsg), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onLobbyLeave");

	} else {

		conn->onLobbyLeaveCb = callback ? callback : &defaultCallback_str_str;

		conn->onLobbyLeaveCtx = context;

	}

}

void flib_netconn_onRoomJoin(flib_netconn *conn, void (*callback)(void *context, const char *nick), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onRoomJoin");

	} else {

		conn->onRoomJoinCb = callback ? callback : &defaultCallback_str;

		conn->onRoomJoinCtx = context;

	}

}

void flib_netconn_onRoomLeave(flib_netconn *conn, void (*callback)(void *context, const char *nick, const char *partMessage), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onRoomLeave");

	} else {

		conn->onRoomLeaveCb = callback ? callback : &defaultCallback_str_str;

		conn->onRoomLeaveCtx = context;

	}

}

void flib_netconn_onNickTaken(flib_netconn *conn, void (*callback)(void *context, const char *nick), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onNickTaken");

	} else if(!callback) {

		conn->onNickTakenCb = &defaultCallback_onNickTaken;

		conn->onNickTakenCtx = conn;

	} else {

		conn->onNickTakenCb = callback;

		conn->onNickTakenCtx = context;

	}

}

void flib_netconn_onPasswordRequest(flib_netconn *conn, void (*callback)(void *context, const char *nick), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onPasswordRequest");

	} else if(!callback) {

		conn->onPasswordRequestCb = &defaultCallback_onPasswordRequest;

		conn->onPasswordRequestCtx = conn;

	} else {

		conn->onPasswordRequestCb = callback;

		conn->onPasswordRequestCtx = context;

	}

}

void flib_netconn_onRoomChiefStatus(flib_netconn *conn, void (*callback)(void *context, bool chief), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onRoomChiefStatus");

	} else {

		conn->onRoomChiefStatusCb = callback ? callback : &defaultCallback_bool;

		conn->onRoomChiefStatusCtx = context;

	}

}

	if(!conn) {

	} else {

		conn->onReadyStateCb = callback ? callback : &defaultCallback_str_bool;

		conn->onReadyStateCtx = context;

	}

}

	if(!conn) {

	} else {

		conn->onEnterRoomCb = callback ? callback : &defaultCallback_bool;

		conn->onEnterRoomCtx = context;

	}

}

	if(!conn) {

	} else {

		conn->onLeaveRoomCb = callback ? callback : &defaultCallback_int_str;

		conn->onLeaveRoomCtx = context;

	}

}

	if(!conn) {

	} else {

		conn->onTeamAddCb = callback ? callback : &defaultCallback_onTeamAdd;

		conn->onTeamAddCtx = context;

	}

}

static void flib_netconn_wrappedtick(flib_netconn *conn) {

	flib_netmsg *netmsg;

	flib_netbase *net = conn->netBase;

	bool exit = false;

	while(!exit && !conn->destroyRequested && (netmsg=flib_netbase_recv_message(conn->netBase))) {

		if(netmsg->partCount==0) {

			flib_log_w("Empty server message");

			continue;

		}

		if(flib_log_isActive(FLIB_LOGLEVEL_DEBUG)) {

			char *buf = flib_join(netmsg->parts, netmsg->partCount, "|");

			if(buf) {

				flib_log_d("[Net In]%s", buf);

			}

			free(buf);

		}