#ifndef PROTOCOL_H

#define PROTOCOL_H

#include <mutex></mutex>

#include "common.h"

#include "address.h"

#include "connection.h"

#include "server.h"

enum : ErrorCode  {

	ERR_PROTOCOL_COMMON = ERR_SERVER,

	ERR_PROTOCOL_NOT_INITIALIZED,

};

class Protocol;

class Socket {

public:

	enum : unsigned int {

		CHANGED   = 1 << 0,

		CREATED   = 1 << 1,

		REMOVED   = 1 << 2,

		WANTREAD  = 1 << 3,

		WANTWRITE = 1 << 4, };

	Protocol &protocol;

	const Connection::Handle connection;

	const Server::Handle server;

	const Address &address;

private:

	friend class Protocol;

	// these vars protected by protocol.mutex

	unsigned int flags;

	Socket *prev, *next;

	Socket *chPrev, *chNext;

	// protocol.mutex must be already locked

	void setChanged(bool changed);

protected:

	// protocol.mutex must be already locked

	Socket(const Socket&) = delete;

	Socket(

		Protocol &protocol,

		const Connection::Handle &connection,

		const Server::Handle &server,

		const Address &address );

	~Socket();

public:

	// thread-saef methods

	void setWantRead(bool want);

	void setWantWrite(bool want);

	void finalize();

};

class Protocol: public Shared {

public:

	typedef THandle<protocol> Handle;</protocol>

	typedef std::recursive_mutex Mutex;

	typedef std::lock_guard<mutex> Lock;</mutex>

private:

	friend class Socket;

	Socket *first, *last;

	Socket *chFirst, *chLast;

	inline void socketCheck(Socket *socket, bool mustBeChanged = false) {

		assert(socket);

		assert(&socket->protocol == this);

		assert(!mustBeChanged || (socket->flags & Socket::CHANGED));

	}

protected:

	Mutex mutex;

	bool allowNewConnections;

	// any class derived from Protocol may access to Socket private members via these methods

	// mutex must be locked before call

	inline Socket* socketFirst()

		{ return first; }

	inline Socket* socketNext(Socket *socket)

		{ socketCheck(socket); return socket->next; }

	inline Socket* socketChFirst()

		{ return chFirst; }

	inline Socket* socketChNext(Socket *socket)

		{ socketCheck(socket, true); return socket->chNext; }

	inline unsigned int socketFlags(Socket *socket)

		{ socketCheck(socket); return socket->flags; }

	inline Socket* socketRemove(Socket *socket)

		{ socketCheck(socket); Socket *next = socket->next; delete socket; return next; }

	inline Socket* socketRemoveChanged(Socket *socket)

		{ socketCheck(socket, true); Socket *chNext = socket->chNext; delete socket; return chNext; }

	inline Socket* socketSetUnchanged(Socket *socket)

		{ socketCheck(socket, true); Socket *chNext = socket->chNext; socket->setChanged(false); return chNext; }

	// thread-safe methods

	void connectionOpen(const Connection::Handle &connection, Socket *socket);

	virtual void wakeup();

public:

	// thread-safe methods

	Protocol();

	virtual ~Protocol();

	virtual ErrorCode resolve(Address &address);

	virtual ErrorCode connect(const Connection::Handle &connection, const Address &address);

	virtual ErrorCode listen(const Server::Handle &server, const Address &address);

	void closeAll();

};

#endif