#include "ipcconn.h"

#include "logging.h"

#include "socket.h"

#include <string.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdio.h>

typedef struct _flib_ipcconn {

	char playerName[256];

	uint8_t readBuffer[256];

	int readBufferSize;

	flib_acceptor acceptor;

	uint16_t port;

	flib_tcpsocket sock;

	flib_vector demoBuffer;

} _flib_ipcconn;

flib_ipcconn flib_ipcconn_create(bool recordDemo, const char *localPlayerName) {

	flib_ipcconn result = malloc(sizeof(_flib_ipcconn));

	flib_acceptor acceptor = flib_acceptor_create(0);

	if(!result || !acceptor) {

		free(result);

		flib_acceptor_close(&acceptor);

		return NULL;

	}

	result->acceptor = acceptor;

	result->sock = NULL;

	result->readBufferSize = 0;

	result->port = flib_acceptor_listenport(acceptor);

	if(localPlayerName) {

		strncpy(result->playerName, localPlayerName, 255);

	} else {

		strncpy(result->playerName, "Player", 255);

	}

	if(recordDemo) {

		result->demoBuffer = flib_vector_create();

	}

	flib_log_i("Started listening for IPC connections on port %u", result->port);

	return result;

}

uint16_t flib_ipcconn_port(flib_ipcconn ipc) {

	return ipc->port;

}

void flib_ipcconn_destroy(flib_ipcconn *ipcptr) {

	if(!ipcptr || !*ipcptr) {

		return;

	}

	flib_ipcconn ipc = *ipcptr;

	flib_acceptor_close(&ipc->acceptor);

	flib_socket_close(&ipc->sock);

	flib_vector_destroy(&ipc->demoBuffer);

	free(ipc);

	*ipcptr = NULL;

}

IpcConnState flib_ipcconn_state(flib_ipcconn ipc) {

	if(ipc && ipc->sock) {

		return IPC_CONNECTED;

	} else if(ipc && ipc->acceptor) {

		return IPC_LISTENING;

	} else {

		return IPC_NOT_CONNECTED;

	}

}

static void demo_record(flib_ipcconn ipc, const void *data, size_t len) {

	if(ipc->demoBuffer) {

		if(flib_vector_append(ipc->demoBuffer, data, len) < len) {

			// Out of memory, fail demo recording

			flib_vector_destroy(&ipc->demoBuffer);

		}

	}

}

static void demo_record_from_engine(flib_ipcconn ipc, const uint8_t *message) {

	if(!ipc->demoBuffer || message[0]==0) {

		return;

	}

	if(strchr("?CEiQqHb", message[1])) {

		// Those message types are not recorded in a demo.

		return;

	}

	if(message[1] == 's') {

		if(message[0] >= 3) {

			// Chat messages get a special once-over to make them look as if they were received, not sent.

			// Get the actual chat message as c string

			char chatMsg[256];

			memcpy(chatMsg, message+2, message[0]-3);

			chatMsg[message[0]-3] = 0;

			char converted[257];

			bool memessage = message[0] >= 7 && !memcmp(message+2, "/me ", 4);

			const char *template = memessage ? "s\x02* %s %s  " : "s\x01%s: %s  ";

			int size = snprintf(converted+1, 256, template, ipc->playerName, chatMsg);

			converted[0] = size>255 ? 255 : size;

			demo_record(ipc, converted, converted[0]+1);

		}

	} else {

		demo_record(ipc, message, message[0]+1);

	}

}

int flib_ipcconn_recv_message(flib_ipcconn ipc, void *data) {

	flib_ipcconn_tick(ipc);

	if(ipc->sock) {

		int size = flib_socket_nbrecv(ipc->sock, ipc->readBuffer+ipc->readBufferSize, sizeof(ipc->readBuffer)-ipc->readBufferSize);

		if(size>=0) {

			ipc->readBufferSize += size;

		} else {

			flib_socket_close(&ipc->sock);

		}

	}

		demo_record_from_engine(ipc, ipc->readBuffer);

		return msgsize;

	} else if(!ipc->sock && ipc->readBufferSize>0) {

		ipc->readBufferSize = 0;

		return -1;

	} else {

		return -1;

	}

}

int flib_ipcconn_send_raw(flib_ipcconn ipc, void *data, size_t len) {

	flib_ipcconn_tick(ipc);

	if(!ipc->sock) {

		flib_log_w("flib_ipcconn_send_message: Not connected.");

		return -1;

	}

	if(flib_socket_send(ipc->sock, data, len) == len) {

		demo_record(ipc, data, len);

		return 0;

	} else {

		flib_log_w("Failed or incomplete ICP write: engine connection lost.");

		flib_socket_close(&ipc->sock);

		return -1;

	}

}

int flib_ipcconn_send_message(flib_ipcconn ipc, void *data, size_t len) {

	if(len>255) {

		flib_log_e("Attempt to send too much data to the engine in a single message.");

		return -1;

	}

	uint8_t sendbuf[256];

	sendbuf[0] = len;

	memcpy(sendbuf+1, data, len);

	return flib_ipcconn_send_raw(ipc, sendbuf, len+1);

}

int flib_ipcconn_send_messagestr(flib_ipcconn ipc, char *data) {

	return flib_ipcconn_send_message(ipc, data, strlen(data));

}

void flib_ipcconn_tick(flib_ipcconn ipc) {

	if(!ipc->sock && ipc->acceptor) {

		ipc->sock = flib_socket_accept(ipc->acceptor, true);

		if(ipc->sock) {

			flib_acceptor_close(&ipc->acceptor);

		}

	}

}

static void replace_gamemode(flib_buffer buf, char gamemode) {

	size_t msgStart = 0;

	char *data = (char*)buf.data;

	while(msgStart+2 < buf.size) {

		if(!memcmp(data+msgStart, "\x02T", 2)) {

			data[msgStart+2] = gamemode;

		}

		msgStart += (uint8_t)data[msgStart]+1;

	}

}

flib_constbuffer flib_ipcconn_getdemo(flib_ipcconn ipc) {

	if(!ipc->demoBuffer) {

		flib_constbuffer result = {NULL, 0};

		return result;

	}

	replace_gamemode(flib_vector_as_buffer(ipc->demoBuffer), 'D');

	return flib_vector_as_constbuffer(ipc->demoBuffer);

}

flib_constbuffer flib_ipcconn_getsave(flib_ipcconn ipc) {

	if(!ipc->demoBuffer) {

		flib_constbuffer result = {NULL, 0};

		return result;

	}

	replace_gamemode(flib_vector_as_buffer(ipc->demoBuffer), 'S');

	return flib_vector_as_constbuffer(ipc->demoBuffer);

}