#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,

	ERR_PROTOCOL_INITIALIZATION_FAILED,

	ERR_PROTOCOL_UNFINISHED_CONNECTIONS,

	ERR_PROTOCOL_IS_SWITCHING,

};

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();

	void onConstructionComplete();

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 RecursiveMutex Mutex;

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

private:

	friend class Socket;

	Socket *first, *last;

	Socket *chFirst, *chLast;

	bool started;

	bool switching;

	bool stopRequested;

	unsigned long long stopTimeUs;

	std::condition_variable_any stopWaitCondition;

protected:

	Mutex mutexStartStop; // using only inside start and stop functions

	Mutex mutex;

private:

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

		assert(socket);

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

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

	}

protected:

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

	// mutex must be locked before call

	inline bool isStarted() const

		{ return started; }

	inline bool isStarting() const

		{ return !started && switching; }

	inline bool isStopping() const

		{ return started && switching; }

	inline bool isStopRequested() const

		{ return stopRequested; }

	inline bool isActive() const

		{ return isStarted() && !isStopping(); }

	inline bool isFullActive() const

		{ return isActive() && !isStopRequested(); }

	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 unsigned int socketToRemove(Socket *socket)

		{ socketCheck(socket); return socket->flags & Socket::REMOVED; }

	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; }

	friend class Server;

	friend class Connection;

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

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

	Connection::Handle serverConnect(const Server::Handle &server, const Address &address);

	void serverDisconnect(const Server::Handle &server, const Connection::Handle &connection);

private:

	// mutex must be locked before call

	// used in start and stop

	void clean();

	// functions used by the Server class

	// thread-safe

	friend class Server;

	int stopServer(Server &server);

	int stopServerReq(Server &server);	

public:

	// thread-safe methods

	Protocol();

	virtual ~Protocol();

	ErrorCode start();

	void stop(ErrorCode errorCode = ERR_NONE);

	void stopReq();

	void stopWait(unsigned long long timeoutUs, bool withRequest = true);

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

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

	virtual ErrorCode resolve(Address &address);

protected:

	// mutex must be locked before call

	virtual ErrorCode onStart();

	virtual void onStopRequested();

	virtual void onStop(ErrorCode errorCode);

	virtual void onSocketChanged(Socket *socket);

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

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

};

#endif