#include "utils.h"

#include "protocol.h"

#include "server.h"

#include "connection.h"

Socket::Socket(

	Protocol &protocol,

	const Connection::Handle &connection,

	const Server::Handle &server,

	const Address &address

):

	protocol(protocol), connection(connection), server(server), address(address),

	flags(CREATED), prev(), next(), chPrev(), chNext()

{

	prev = protocol.last;

	(prev ? prev->next : protocol.first) = this;

	setChanged(true);

}

Socket::~Socket() {

	setChanged(false);

	(prev ? prev->next : protocol.first) = next;

	(next ? next->prev : protocol.last) = prev;

	prev = next = nullptr;

}

void Socket::setChanged(bool changed) {

	if ((bool)(flags & CHANGED) == changed) return;

	if (changed) {

		flags |= CHANGED;

		chPrev = protocol.chLast;

		(chPrev ? chPrev->chNext : protocol.chFirst) = this;

		protocol.onSocketChanged(this);

	} else {

		flags &= ~CHANGED;

		(chPrev ? chPrev->chNext : protocol.chFirst) = chNext;

		(chNext ? chNext->chPrev : protocol.chLast) = chPrev;

		chPrev = chNext = nullptr;

	}

}

void Socket::setWantRead(bool want) {

	Protocol::Lock lock(protocol.mutex);

	if ((bool)(flags & WANTREAD) == want) return;

	flags = want ? flags | WANTREAD : flags & ~WANTREAD;

	setChanged(true);

}

void Socket::setWantWrite(bool want) {

	Protocol::Lock lock(protocol.mutex);

	if ((bool)(flags & WANTWRITE) == want) return;

	flags = want ? flags | WANTWRITE : flags & ~WANTWRITE;

	setChanged(true);

}

void Socket::finalize() {

	Protocol::Lock lock(protocol.mutex);

	if (flags & REMOVED) return;

	flags |= REMOVED;

	setChanged(true);

}

Protocol::Protocol():

	first(), last(), chFirst(), chLast(),

	started(), switching(), stopping(), stopRequested(), stopTimeUs() { }

Protocol::~Protocol() {

	Lock lockStartStop(mutexStartStop);

	Lock lock(mutex);

	assert(!started);

	clean();

}

ErrorCode Protocol::connectionOpen(const Connection::Handle &connection, Socket *socket)

	{ return connection && socket ? connection->open(socket) : ERR_INVALID_ARGS; }

ErrorCode Protocol::serverStart(const Server::Handle &server, Socket *socket)

	{ return server && socket ? server->start(socket) : ERR_INVALID_ARGS; }

int Protocol::stopServer(Server &server) {

	Lock lock(mutex);

	int count = 0;

	if (started)

		for(Socket *s = socketFirst(); s; s = socketNext(s))

			if (!(socketFlags(s) & Socket::REMOVED) && s->server == &server && s->connection)

				{ s->connection->close(ERR_CONNECTION_LOST); ++count; }

	return count;

}

int Protocol::stopServerReq(Server &server) {

	Lock lock(mutex);

	int count = 0;

	if (started)

		for(Socket *s = socketFirst(); s; s = socketNext(s))

			if (!(socketFlags(s) & Socket::REMOVED) && s->server == &server && s->connection)

				{ s->connection->closeReq(); ++count; }

	return count;

}

void Protocol::clean() {

	assert(!socketFirst());

	while(socketFirst()) delete socketFirst();

	started = false;

	stopping = false;

	stopRequested = false;

	stopTimeUs = 0;

}

ErrorCode Protocol::start() {

	Lock lockStartStop(mutexStartStop);

	Lock lock(mutex);

	stop();

	if (switching) return ERR_PROTOCOL_IS_SWITCHING;

	switching = true;

	ErrorCode errorCode = onStart();

	if (errorCode) clean(); else started = true;

	switching = false;

	return errorCode;

}

void Protocol::stop(ErrorCode errorCode) {

	Lock lockStartStop(mutexStartStop);

	Lock lock(mutex);

	if (!started || switching) return;

	switching = true;

	stopping = true;

	int unfinishedConnections = 0;

	for(Socket *s = socketFirst(); s; s = socketNext(s)) {

		if (!(socketFlags(s) & Socket::REMOVED)) {

			if (!s->server && s->connection) {

				s->connection->close(ERR_CONNECTION_LOST);

				++unfinishedConnections;

			} else

			if (s->server && !s->connection) {

				s->server->stop(ERR_SERVER_LISTENING_LOST);

				++unfinishedConnections;

			}

		}

	}

	if (!errorCode && unfinishedConnections) errorCode = ERR_PROTOCOL_UNFINISHED_CONNECTIONS;

	onStop(errorCode);

	clean();

	switching = false;

	stopWaitCondition.notify_all();

}

void Protocol::stopReq() {

	Lock lock(mutex);

	if (!started || stopRequested) return;

	stopRequested = true;

	for(Socket *s = socketFirst(); s; s = socketNext(s)) {

		if (!(socketFlags(s) & Socket::REMOVED)) {

			if (!s->server && s->connection)

				s->connection->closeReq();

			else

			if (s->server && !s->connection)

				s->server->stopReq();

		}

	}

}

void Protocol::stopWait(unsigned long long timeoutUs, bool withRequest) {

	std::unique_lock<mutex> uniqlock(mutex);</mutex>

	if (!started) return;

	if (withRequest) stopReq();

	unsigned long long timeUs = monotonicTimeUs() + timeoutUs;

	if (stopTimeUs > timeUs)

		{ stopTimeUs = timeUs; stopWaitCondition.notify_all(); }

	while(started) {

		unsigned long long timeUs = monotonicTimeUs();

		if (timeUs >= stopTimeUs)

			{ stop(); break; }

		stopWaitCondition.wait_for(uniqlock, std::chrono::microseconds(stopTimeUs - timeUs));

	}

}

ErrorCode Protocol::connect(const Connection::Handle &connection, const Address &address) {

	if (!connection) return ERR_INVALID_ARGS;	

	Lock lock(mutex);

	if (!isFullActive()) return ERR_PROTOCOL_NOT_INITIALIZED;

	return onConnect(connection, address);

}

ErrorCode Protocol::listen(const Server::Handle &server, const Address &address) {

	if (!server) return ERR_INVALID_ARGS;	

	Lock lock(mutex);

	if (!isFullActive()) return ERR_PROTOCOL_NOT_INITIALIZED;

	return onListen(server, address);

}

ErrorCode Protocol::resolve(Address&)

	{ return ERR_ADDRESS_INCORRECT; }

ErrorCode Protocol::onStart()

	{ return ERR_NONE; }

void Protocol::onStop(ErrorCode)

	{ }

void Protocol::onSocketChanged(Socket*) 

	{ }

ErrorCode Protocol::onConnect(const Connection::Handle&, const Address&)

	{ return ERR_CONNECTION_FAILED; }

ErrorCode Protocol::onListen(const Server::Handle&, const Address&)

	{ return ERR_SERVER_LISTENING_FAILED; }