#include "socket.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) {

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

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

			flib_vector_destroy(&ipc->demoBuffer);

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

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

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

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

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

			ipc->readBufferSize += size;

			flib_socket_close(&ipc->sock);

	int msgsize = ipc->readBuffer[0];

	if(ipc->readBufferSize > msgsize) {

		demo_record_from_engine(ipc, ipc->readBuffer);

		memcpy(data, ipc->readBuffer+1, msgsize);

		memmove(ipc->readBuffer, ipc->readBuffer+msgsize+1, ipc->readBufferSize-(msgsize+1));

		ipc->readBufferSize -= (msgsize+1);

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

		flib_log_w("Last message from engine data stream is incomplete (received %u of %u bytes)", ipc->readBufferSize-1, msgsize);

		ipc->readBufferSize = 0;

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

	flib_ipcconn_tick(ipc);

	if(!ipc->sock) {

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

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

flib_constbuffer flib_ipcconn_getdemo(flib_ipcconn ipc) {

	if(!ipc->demoBuffer) {

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

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

	return flib_vector_as_constbuffer(ipc->demoBuffer);