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

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

#include <ctype.h>

	flib_cfg_meta *metaCfg;

	flib_roomlist *roomList;

	bool isAdmin;			// Player is server administrator

	bool isChief;			// Player can modify the current room

	void (*onMessageCb)(void *context, int msgtype, const char *msg);

	void *onMessageCtx;

	void (*onConnectedCb)(void *context);

	void *onConnectedCtx;

	void (*onDisconnectedCb)(void *context, int reason, const char *message);

	void *onDisconnectedCtx;

	void (*onRoomAddCb)(void *context, const flib_roomlist_room *room);

	void *onRoomAddCtx;

	void (*onRoomDeleteCb)(void *context, const char *name);

	void *onRoomDeleteCtx;

	void (*onRoomUpdateCb)(void *context, const char *oldName, const flib_roomlist_room *room);

	void *onRoomUpdateCtx;

	void (*onChatCb)(void *context, const char *nick, const char *msg);

	void *onChatCtx;

	void (*onLobbyJoinCb)(void *context, const char *nick);

	void *onLobbyJoinCtx;

	void (*onLobbyLeaveCb)(void *context, const char *nick, const char *partMessage);

	void *onLobbyLeaveCtx;

	void (*onRoomJoinCb)(void *context, const char *nick);

	void *onRoomJoinCtx;

	void (*onRoomLeaveCb)(void *context, const char *nick, const char *partMessage);

	void *onRoomLeaveCtx;

	void (*onNickTakenCb)(void *context, const char *nick);

	void *onNickTakenCtx;

	void (*onNickAcceptCb)(void *context, const char *nick);

	void *onNickAcceptCtx;

	void (*onPasswordRequestCb)(void *context, const char *nick);

	void *onPasswordRequestCtx;

	void (*onRoomChiefStatusCb)(void *context, bool isChief);

	void *onRoomChiefStatusCtx;

	void (*onReadyStateCb)(void *context, const char *nick, bool ready);

	void *onReadyStateCtx;

	void (*onEnterRoomCb)(void *context, bool chief);

	void *onEnterRoomCtx;

	void (*onLeaveRoomCb)(void *context, int reason, const char *message);

	void *onLeaveRoomCtx;

	void (*onTeamAddCb)(void *context, flib_team *team);

	void *onTeamAddCtx;

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_onNickAccept(conn, NULL, NULL);

	flib_netconn_onPasswordRequest(conn, NULL, NULL);

	flib_netconn_onRoomChiefStatus(conn, NULL, NULL);

	flib_netconn_onReadyStateCb(conn, NULL, NULL);

	flib_netconn_onEnterRoomCb(conn, NULL, NULL);

	flib_netconn_onTeamAddCb(conn, NULL, NULL);

}

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

	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);

			flib_cfg_meta_release(conn->metaCfg);

			flib_roomlist_destroy(conn->roomList);

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;

}

int flib_netconn_send_quit(flib_netconn *conn, const char *quitmsg) {

	int result = -1;

		flib_log_e("null parameter in flib_netconn_send_quit");

	} else {

		result = flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", "QUIT", quitmsg ? quitmsg : "User quit");

	}

	return result;

}

int flib_netconn_send_chat(flib_netconn *conn, const char *chat) {

	int result = -1;

	if(!conn || !chat) {

		flib_log_e("null parameter in flib_netconn_send_chat");

	} else {

		result = flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", "CHAT", chat);

	}

	return result;

}

int flib_netconn_send_nick(flib_netconn *conn, const char *nick) {

	int result = -1;

	if(!conn || !nick) {

		flib_log_e("null parameter in flib_netconn_send_nick");

	} else {

		char *tmpName = flib_strdupnull(nick);

		if(tmpName) {

			if(!flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", "NICK", nick)) {

				free(conn->playerName);

				conn->playerName = tmpName;

				tmpName = NULL;

				result = 0;

			}

		}

		free(tmpName);

	}

	return result;

}

int flib_netconn_send_password(flib_netconn *conn, const char *latin1Passwd) {

	int result = -1;

	if(!conn || !latin1Passwd) {

		flib_log_e("null parameter in flib_netconn_send_password");

		md5_state_t md5state;

		uint8_t md5bytes[16];

		char md5hex[33];

		md5_init(&md5state);

		md5_append(&md5state, (unsigned char*)latin1Passwd, strlen(latin1Passwd));

		md5_finish(&md5state, md5bytes);

		for(int i=0;i<sizeof(md5bytes); i++) {

			// Needs to be lowercase - server checks case sensitive

			snprintf(md5hex+i*2, 3, "%02x", (unsigned)md5bytes[i]);

		}

		result = flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", "PASSWORD", md5hex);

	}

	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) {

		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_onNickAccept(flib_netconn *conn, void (*callback)(void *context, const char *nick), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onNickAccept");

	} else {

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

		conn->onNickAcceptCtx = 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");

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

		conn->onRoomChiefStatusCtx = context;

	}

}

void flib_netconn_onReadyStateCb(flib_netconn *conn, void (*callback)(void *context, const char *nick, bool ready), void* context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onReadyStateCb");

	} else {

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

		conn->onReadyStateCtx = context;

	}

}

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

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onEnterRoomCb");

	} else {

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

		conn->onEnterRoomCtx = context;

	}

}

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

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onLeaveRoomCb");

	} else {

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

		conn->onLeaveRoomCtx = context;

	}

}

void flib_netconn_onTeamAddCb(flib_netconn *conn, void (*callback)(void *context, flib_team *team), void *context) {

	if(!conn) {

		flib_log_e("null parameter in flib_netconn_onTeamAddCb");

	} else {

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

		conn->onTeamAddCtx = context;

		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);

		}