#ifndef SERVER_H

#define SERVER_H

#include "connection.h"

class Server: public Root {

	enum State: int {

		STATE_NONE,

		STATE_OPENING,

		STATE_INITIALIZING,

		STATE_RESOLVING,

		STATE_OPEN,

		STATE_CLOSE_REQ,

		STATE_CLOSING_CONNECTIONS,

		STATE_CLOSING,

		STATE_CLOSED,

		STATE_FINISHED

	};

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 *prev, *next;

	Server *queueNext;

	Connection *connFirst, *connLast;

	int sockId;

	State stateLocal;

	void wantState(State state, bool error);

public:

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

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

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

public:

	Server();

	~Server();

	bool open(Protocol &protocol, void *address, size_t addressSize);

	void closeReq();

	void close(bool error);

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

protected:

	virtual void onOpeningError();

	virtual void onOpen();

	virtual Connection* onConnect(const void *address, size_t addressSize);

	virtual void onDisconnect(Connection *connection, bool error);

	virtual void onCloseReqested();

	virtual void onClose(bool error);

};

#endif