#ifndef SOCKET_H

#define SOCKET_H

#include <cassert></cassert>

#include <atomic></atomic>

#include <condition_variable></condition_variable>

#include "utils.h"

#define MAX_ADDR_SIZE 256

enum State: int {

	STATE_NONE,

	STATE_OPENING,

	STATE_INITIALIZING,

	STATE_RESOLVING,

	STATE_CONNECTING,

	STATE_OPEN,

	STATE_CLOSE_REQ,

	STATE_CLOSING_CONNECTIONS,

	STATE_CLOSING,

	STATE_CLOSED,

	STATE_FINISHED,

	STATE_DESTROYED

};

class Protocol;

class Connection;

class Server;

class Socket {

private:

	friend class Protocol;

	friend class Connection;

	friend class Server;

	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;

	Socket *prev, *next;

	Socket *queueNext;

	int sockId;

	State stateLocal;

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

	struct OpenLock {

		Socket &socket;

		const bool success;

		OpenLock(Socket &socket, Protocol &protocol, void *address, size_t addressSize):

			socket(socket), success(socket.openBegin(protocol, address, addressSize)) { }

		~OpenLock()

			{ if (success) socket.openEnd(); }

	};

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

	void openEnd();

	void initSocket(int sockId);

	void enqueue();

	void updateEvents(bool wantRead, bool wantWrite);

	void wantState(State state, bool error);

	void destroy();

public:

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

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

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

public:

	Socket();

	virtual ~Socket();

	void closeReq();

	void close(bool error);

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

private:

	virtual void handleState() = 0;

	virtual void handleEvents(unsigned int events) = 0;

protected:

	virtual void onOpeningError();

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

	virtual void onCloseReqested();

	virtual void onClose(bool error);

};

#endif