#ifndef CONNECTION_H

#define CONNECTION_H

#include <cassert></cassert>

#include <atomic></atomic>

#include <condition_variable></condition_variable>

#include "utils.h"

#define MAX_ADDR_SIZE 256

class Protocol;

class Server;

class Root {

public:

	virtual ~Root() { }

};

class Connection: public Root {

public:

	enum State: int {

		STATE_NONE,

		STATE_OPENING,

		STATE_INITIALIZING,

		STATE_RESOLVING,

		STATE_CONNECTING,

		STATE_OPEN,

		STATE_CLOSE_REQ,

		STATE_CLOSING,

		STATE_CLOSED,

		STATE_FINISHED

	};

	struct Task {

		void *data;

		size_t size;

		size_t completion;

		bool watch;

		Task *next;

		inline explicit Task(

			void *data = nullptr,

			size_t size = 0,

			size_t completion = 0,

			bool watch = false,

			Task *next = nullptr

		):

			data(data), size(size), completion(completion), watch(watch), next(next)

			{ assert(!!data == !!size); }

	};

	typedef CounteredQueueMISO<task, &task::next=""> TaskQueue;</task,>

private:

	friend class Protocol;

	std::atomic<state> state;</state>

	std::atomic<state> stateWanted;</state>

	ReadProtector stateProtector;

	std::atomic<bool> enqueued;</bool>

	std::atomic<bool> error;</bool>

	std::atomic<int> closeWaiters;</int>

	std::atomic<int> finishWaiters;</int>

	std::condition_variable closeCondition;

	unsigned char address[MAX_ADDR_SIZE];

	size_t addressSize;

	Protocol *protocol;

	Server *server;

	Connection *prev, *next;

	Connection *srvPrev, *srvNext;

	Connection *queueNext;

	int sockId;

	State stateLocal;

	bool errorLocal;

	std::atomic<unsigned int=""> events;</unsigned>

	TaskQueue readQueue;

	TaskQueue writeQueue;

	void wantState(State state, bool error);

public:

	typedef      QueueMISO<connection, &connection::queuenext=""> Queue;</connection,>

	friend class QueueMISO<connection, &connection::queuenext="">;</connection,>

	friend class ChainFuncs<connection, &connection::queuenext="">;</connection,>

public:

	Connection();

	virtual ~Connection();

	bool open(Protocol &protocol, void *address, size_t addressSize, int sockId = -1, Server *server = nullptr);

	void closeReq();

	void close(bool error);

	void closeWait(unsigned long long timeoutUs = 0, bool withReq = true, bool error = true);

	bool read(Task &task);

	bool write(Task &task);

protected:

	virtual void onOpeningError();

	virtual void onOpen(const void *address, size_t addressSize);

	virtual bool onReadReady(Task &task, bool error);

	virtual bool onWriteReady(Task &task, bool error);

	virtual void onCloseReqested();

	virtual void onClose(bool error);

};

#endif