#include "protocol.h"

#include "connection.h"

Connection::Connection():

	socket(), lastId() { }

Connection::~Connection()

	{ close(); }

Protocol& Connection::getProtocol() const

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

const Address& Connection::getRemoteAddress() const

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

Server* Connection::getServer() const

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

void Connection::open(Socket *socket) {

	Lock lock(mutex);

	close();

	if (!socket) return;

	this->socket = socket;

	onOpen();

}

ErrorCode Connection::open(Protocol &protocol, const Address &remoteAddress)

	{ return protocol.connect(*this, remoteAddress); }

void Connection::close(ErrorCode errorCode) {

	Socket *socketCopy;

	{

		Lock lock(mutex);

		if (!socket)

			return;

		if (!errorCode && (!readQueue.empty() || !writeQueue.empty()))

			errorCode = ERR_CONNECTION_UNFINISHED_TASKS;

		onClose(errorCode);

		readQueue.clear();

		writeQueue.clear();

		socketCopy = socket;

		socket = nullptr;

	}

	socketCopy->close();

}

Connection::ReqId Connection::writeReq(const void *data, size_t size, void *userData) {

	if (!data || !size) return 0;

	Lock lock(mutex);

	if (!socket) return 0;

	writeQueue.emplace_back(++lastId, userData, data, size);

	return lastId;

}

Connection::ReqId Connection::readReq(void *data, size_t size, void *userData) {

	if (!data || !size) return 0;

	Lock lock(mutex);

	if (!socket) return 0;

	readQueue.emplace_back(++lastId, userData, data, size);

	return lastId;

}

void Connection::onOpen() { }

void Connection::onClose(ErrorCode) { }

void Connection::onReadReady(const ReadReq&) { }

void Connection::onWriteReady(const WriteReq&) { }