#include "utils.h"

#include "protocol.h"

#include "server.h"

#include "connection.h"

Server::Server():

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

Server::~Server() {

	Lock lock(mutex);

	assert(!started && !socket);

	clean();

}

Protocol& Server::getProtocol() const

	{ assert(socket); return socket->protocol; }

const Address& Server::getLocalAddress() const

	{ assert(socket); return socket->address; }

void Server::clean() {

	started = false;

	socket = nullptr;

	stopRequested = false;

	stopTimeUs = 0;

}

ErrorCode Server::start(Socket *socket) {

	Lock lock(mutex);

	stop();

	if (!socket) return ERR_INVALID_ARGS;

	if (switching) return ERR_SERVER_IS_SWITCHING;

	this->socket = socket;

	switching = true;

	ErrorCode errorCode = onStart();

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

	switching = false;

	return errorCode;

}

void Server::stop(ErrorCode errorCode) {

	Lock lock(mutex);

	if (!started || switching) return;

	switching = true;

	int unfinichedConnections = getProtocol().stopServer(*this);

	if (!errorCode && unfinichedConnections) errorCode = ERR_SERVER_UNFINISHED_CONNECTIONS;

	onStop(errorCode);

	Socket *socketCopy = socket;

	clean();

	switching = false;

	socketCopy->finalize();

}

void Server::stopReq() {

	Lock lock(mutex);

	if (!started || switching || stopRequested) return;

	stopRequested = true;

	getProtocol().stopServerReq(*this);

	onStopRequested();

}

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

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

	if (!started || switching) 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(ERR_CONNECTION_LOST); break; }

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

	}

}

Connection::Handle Server::connect(const Address &remoteAddress)

	{ return onConnect(remoteAddress); }

void Server::disconnect(const Connection::Handle &connection)

	{ onDisconnect(connection); }

ErrorCode Server::onStart()

	{ return ERR_NONE; }

void Server::onStopRequested()

	{ }

void Server::onStop(ErrorCode)

	{ }

Connection::Handle Server::onConnect(const Address&)

	{ return nullptr; }

void Server::onDisconnect(const Connection::Handle&)

	{ }