#include <cstring></cstring>

#include <fcntl.h></fcntl.h>

#include <unistd.h></unistd.h>

#include <sys types.h=""></sys>

#include <sys socket.h=""></sys>

#include <sys epoll.h=""></sys>

#include <netinet in.h=""></netinet>

#include <netinet tcp.h=""></netinet>

#include "socket.h"

#include "protocol.h"

#define DebugMSG ShowDebugMSG

Socket::Socket():

	state(STATE_NONE),

	stateWanted(STATE_NONE),

	enqueued(false),

	closeWaiters(0),

	finishWaiters(0),

	address(),

	addressSize(),

	protocol(),

	prev(), next(),

	queueNext(),

	sockId(-1),

	stateLocal(),

	events(0xffffffff)

	{ }

Socket::~Socket()

	{ assert(state == STATE_DESTROYED); }

void Socket::destroy() {

	assert(state == STATE_NONE || state == STATE_FINISHED);

	++finishWaiters;

	closeWait();

	state = STATE_DESTROYED;

	--finishWaiters;

	while(finishWaiters > 0)

		std::this_thread::yield();

}

bool Socket::openBegin(Protocol &protocol, void *address, size_t addressSize) {

	if (!address || !addressSize || addressSize > MAX_ADDR_SIZE) return false;

	State s = state;

	do {

		if (s != STATE_NONE && s != STATE_FINISHED)

			return false;

	} while(!state.compare_exchange_weak(s, STATE_OPENING));

	if (s == STATE_FINISHED)

		while(finishWaiters > 0)

			std::this_thread::yield();

	if (state == STATE_DESTROYED)

		return false;

	protocol.stateProtector.lock();

	State ps = protocol.state;

	if (ps < STATE_INITIALIZING || ps >= STATE_CLOSE_REQ) {

		state = STATE_NONE;

		protocol.stateProtector.unlock();

		return false;

	}

	this->protocol = &protocol;

	memcpy(this->address, address, addressSize);

	this->addressSize = addressSize;

	return true;

}

void Socket::openEnd() {

	state = STATE_INITIALIZING;

	enqueue();

	protocol->stateProtector.unlock();

}

void Socket::initSocket(int sockId) {

	int tcp_nodelay = 1;

	setsockopt(sockId, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay, sizeof(int));

	fcntl(sockId, F_SETFL, fcntl(sockId, F_GETFL, 0) | O_NONBLOCK);

}

void Socket::enqueue() {

	if (!enqueued.exchange(true)) {

		protocol->sockQueue.push(*this);

		protocol->wakeup();

	}

}

void Socket::updateEvents(bool wantRead, bool wantWrite) {

	unsigned int e = EPOLLERR | EPOLLRDHUP;

	if (wantRead) e |= EPOLLIN;

	if (wantWrite) e |= EPOLLOUT;

	DebugMSG("events: %08x", e);

	unsigned int pe = events.exchange(e);

	if (pe == e)

		return;

	DebugMSG("apply");

	struct epoll_event event = {};

	event.data.ptr = this;

	event.events = e;

	epoll_ctl(protocol->epollFd, pe == 0xffffffff ? EPOLL_CTL_ADD : EPOLL_CTL_MOD, sockId, &event);

}

void Socket::wantState(State state, bool error) {

	ReadLock lock(stateProtector);

	State s = this->state;

	DebugMSG("%d, %d", s, state);

	if (s <= STATE_OPENING || s >= STATE_CLOSING || s >= state) return;

	DebugMSG("apply");

	State sw = stateWanted;

	do {

		if (sw >= state) return;

	} while(!stateWanted.compare_exchange_weak(sw, state));

	if (error) { DebugMSG("error"); error = false; this->error.compare_exchange_strong(error, true); }

	enqueue();

}

void Socket::closeReq()

	{ wantState(STATE_CLOSE_REQ, false); }

void Socket::close(bool error)

	{ wantState(STATE_CLOSING, error); }

void Socket::closeWait(unsigned long long timeoutUs, bool withReq, bool error) {

	stateProtector.lock();

	State s = state;

	if (s <= STATE_OPENING || s >= STATE_FINISHED)

		{ stateProtector.unlock(); return; }

	if (s == STATE_CLOSED) {

		finishWaiters++;

		stateProtector.unlock();

	} else {

		if (withReq && s < STATE_CLOSE_REQ) closeReq();

		closeWaiters++;

		stateProtector.unlock();

		std::mutex fakeMutex;

		{

			std::unique_lock<std::mutex> fakeLock(fakeMutex);</std::mutex>

			if (timeoutUs && s < STATE_CLOSING) {

				std::chrono::steady_clock::time_point t

					= std::chrono::steady_clock::now()

						+ std::chrono::microseconds(timeoutUs);

				while(s < STATE_CLOSED) {

					if (t <= std::chrono::steady_clock::now()) { close(error); break; }

					closeCondition.wait_until(fakeLock, t);

					s = state;

				}

			}

			if (s < STATE_CLOSING) close(error);

			while(s < STATE_CLOSED) {

				closeCondition.wait(fakeLock);

				s = state;

			}

		}

		finishWaiters++;

		closeWaiters--;

	}

	while(s < STATE_FINISHED) { std::this_thread::yield(); s = state; }

	finishWaiters--;

}

void Socket::onOpeningError() { }

void Socket::onOpen(const void*, size_t) { }

void Socket::onCloseReqested() { }

void Socket::onClose(bool) { }