#include "frontlib.h"

#include "logging.h"

#include <SDL.h>

#include <SDL_net.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <time.h>

static int flib_initflags;

static TCPsocket ipcListenSocket;

static int ipcPort;

static uint8_t ipcReadBuffer[256];

static int ipcReadBufferSize;

static TCPsocket ipcConnSocket;

static SDLNet_SocketSet ipcConnSocketSet;

static TCPsocket serverConnSocket;

static SDLNet_SocketSet serverConnSocketSet;

#include <time.h>

void flib_logtime() {

    time_t timer;

    char buffer[25];

    struct tm* tm_info;

    time(&timer);

    tm_info = localtime(&timer);

    strftime(buffer, 25, "%H:%M:%S", tm_info);

    printf("%s", buffer);

}

int flib_init(int flags) {

	flib_initflags = flags;

	ipcListenSocket = NULL;

	ipcConnSocket = NULL;

	serverConnSocket = NULL;

	ipcReadBufferSize = 0;

	if(!(flib_initflags | FRONTLIB_SDL_ALREADY_INITIALIZED)) {

		if(SDL_Init(0)==-1) {

		    flib_log_e("Error in SDL_Init: %s\n", SDL_GetError());

		    return -1;

		}

	}

	if(SDLNet_Init()==-1) {

		flib_log_e("Error in SDLNet_Init: %s\n", SDLNet_GetError());

		if(!(flib_initflags | FRONTLIB_SDL_ALREADY_INITIALIZED)) {

			SDL_Quit();

		}

		return -1;

	}

	ipcConnSocketSet = SDLNet_AllocSocketSet(1);

	serverConnSocketSet = SDLNet_AllocSocketSet(1);

	return 0;

}

/**

 * Free resources associated with the library. Call this function once

 * the library is no longer needed. You can re-initialize the library by calling

 * flib_init again.

 */

void flib_quit() {

	// TODO: Send a "quit" message first?

	SDLNet_FreeSocketSet(ipcConnSocketSet);

	SDLNet_FreeSocketSet(serverConnSocketSet);

	if(ipcListenSocket) {

		SDLNet_TCP_Close(ipcListenSocket);

		ipcListenSocket = NULL;

	}

	if(ipcConnSocket) {

		SDLNet_TCP_Close(ipcConnSocket);

		ipcConnSocket = NULL;

	}

	if(serverConnSocket) {

		SDLNet_TCP_Close(serverConnSocket);

		serverConnSocket = NULL;

	}

	SDLNet_Quit();

	if(!(flib_initflags | FRONTLIB_SDL_ALREADY_INITIALIZED)) {

		SDL_Quit();

	}

}

/**

 * Start listening for a connection from the engine, if we are not listening already.

 * Returns the port we are listening on, which needs to be passed to the engine,

 * or -1 if there is an error.

 *

 * We stop listening once a connection has been established, so if you want to start

 * the engine again and talk to it you need to call this function again after the old

 * connection is closed.

 */

int flib_ipc_listen() {

	if(ipcListenSocket) {

		return ipcPort;

	}

	IPaddress addr;

	addr.host = INADDR_ANY;

	/* SDL_net does not seem to have a way to listen on a random unused port

	   and find out which port that is, so let's try to find one ourselves. */

	// TODO: Is socket binding fail-fast on all platforms?

	srand(time(NULL));

	rand();

	for(int i=0; i<1000; i++) {

		// IANA suggests using ports in the range 49152-65535 for things like this

		ipcPort = 49152+(rand()%(65535-49152));

		SDLNet_Write16(ipcPort, &addr.port);

		flib_log_i("Attempting to listen on port %i...\n", ipcPort);

		ipcListenSocket = SDLNet_TCP_Open(&addr);

		if(!ipcListenSocket) {

			flib_log_w("Unable to listen on port %i: %s\n", ipcPort, SDLNet_GetError());

		} else {

			flib_log_i("ok.\n");

			return ipcPort;

		}

	}

	flib_log_e("Unable to find a usable IPC port.");

	return -1;

}

void flib_accept_ipc() {

	if(!ipcListenSocket) {

		flib_log_e("Attempt to accept IPC connection while not listening.");

		return;

	}

	do {

		TCPsocket sock = SDLNet_TCP_Accept(ipcListenSocket);

		if(!sock) {

			// No incoming connections

			return;

		}

		// Check if it is a local connection

		IPaddress *addr = SDLNet_TCP_GetPeerAddress(sock);

		uint32_t numip = SDLNet_Read32(&addr->host);

		if(numip != (uint32_t)((127UL<<24)+1)) { // 127.0.0.1

			flib_log_w("Rejected IPC connection attempt from %s\n", flib_format_ip(numip));

		} else {

			ipcConnSocket = sock;

			SDLNet_AddSocket(ipcConnSocketSet, (SDLNet_GenericSocket)ipcConnSocket);

			SDLNet_TCP_Close(ipcListenSocket);

			ipcListenSocket = NULL;

		}

	} while(!ipcConnSocket);

	return;

}

/**

 * Receive a single message and copy it into the data buffer.

 * Returns the length of the received message, -1 when nothing is received.

 */

int flib_engine_read_message(void *data) {

	if(!ipcConnSocket && ipcListenSocket) {

		flib_accept_ipc();

	}

	if(ipcConnSocket && SDLNet_CheckSockets(ipcConnSocketSet, 0)>0) {

		int size = SDLNet_TCP_Recv(ipcConnSocket, ipcReadBuffer+ipcReadBufferSize, sizeof(ipcReadBuffer)-ipcReadBufferSize);

		if(size>0) {

			ipcReadBufferSize += size;

		} else {

			SDLNet_DelSocket(ipcConnSocketSet, (SDLNet_GenericSocket)ipcConnSocket);

			SDLNet_TCP_Close(ipcConnSocket);

			ipcConnSocket = NULL;

			// TODO trigger "IPC disconnect" event, possibly delayed until after the messages are processed

		}

	}

	int msgsize = ipcReadBuffer[0];

	if(ipcReadBufferSize > msgsize) {

		memcpy(data, ipcReadBuffer+1, msgsize);

		memmove(ipcReadBuffer, ipcReadBuffer+msgsize+1, ipcReadBufferSize-(msgsize+1));

		ipcReadBufferSize -= (msgsize+1);

		return msgsize;

	} else if(!ipcConnSocket && ipcReadBufferSize>0) {

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

		ipcReadBufferSize = 0;

		return -1;

	} else {

		return -1;

	}

}

void flib_engine_write_message(void *data, size_t len) {

	uint8_t sendbuf[256];

	if(len>255) {

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

		return;

	}

	sendbuf[0] = len;

	memcpy(sendbuf+1, data, len);

	SDLNet_TCP_Send(ipcConnSocket, sendbuf, len+1);

}

int main(int argc, char *argv[]) {

	flib_init(0);

	int port = flib_ipc_listen();

	printf("%i", port);

	fflush(stdout);

	char data[256];

	while(ipcListenSocket||ipcConnSocket) {

		int size = flib_engine_read_message(data);

		if(size>0) {

			if(data[0]=='?') {

				flib_engine_write_message("!", 1);

			}

		}

	}

	return 0;

}