#include <WinSock2.h>
#include <iostream>
#include <cstring>
#include <MSWSock.h>

#define BUFFER_SIZE 1024
#define THREAD_COUNT 2
#define START_POST_ACCEPTEX 2
#define PORT 8989

struct ServerParams {
	SOCKET listenSocket;
	HANDLE comletionPort;
};

enum IO_TYPE {
	IO_ACCEPT,
	IO_SEND,
	IO_RECV,
	IO_CONNECT,
	IO_DISCONNECT
};

typedef struct OverlappedPerIO {
	OVERLAPPED overlapped; // 这个结构会传到内核里去
	SOCKET socket;
	WSABUF wsaBuff; // 内核需要这个结构去读写buff
	IO_TYPE type;
	char buffer[BUFFER_SIZE];
}*LPOverlappedPerIO;

void PostAcceptEx(SOCKET listenSocket) {
	SOCKET sock = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (sock == INVALID_SOCKET) {
		return;
	}
	OverlappedPerIO* overlp = new OverlappedPerIO;
	if (overlp == nullptr) {
		closesocket(sock);
		return;
	}
	ZeroMemory(overlp, sizeof(OverlappedPerIO));
	overlp->socket = sock;
	overlp->wsaBuff.buf = overlp->buffer;
	overlp->wsaBuff.len = BUFFER_SIZE;
	overlp->type = IO_ACCEPT;

	DWORD dwByteRecv = 0;
	while (false == AcceptEx(listenSocket, sock, overlp->wsaBuff.buf, 0,
		sizeof(SOCKADDR_IN) + 16, sizeof(SOCKADDR_IN) + 16, &dwByteRecv,
		(LPOVERLAPPED)&overlp->overlapped)) {
		if (WSAGetLastError() == WSA_IO_PENDING)
			break;
	}
	// 最后这个参数也就是overlap的首地址，被传入内核后会传回应用层，根据这个返回强转一下类型就能得到完整的overlap返回
}

DWORD WINAPI workerThread(LPVOID lpParam) {
	ServerParams* pms = (ServerParams*)lpParam;
	HANDLE completionPort = pms->comletionPort;
	SOCKET listenSocket = pms->listenSocket;

	DWORD bytesTrans;
	ULONG_PTR completionKey;
	LPOverlappedPerIO overlap;
	while (true) {
		BOOL result = GetQueuedCompletionStatus(
			completionPort, 
			&bytesTrans, 
			&completionKey, 
			(LPOVERLAPPED*)&overlap,
			INFINITE
		);
		if (!result) {
			if (GetLastError() == WAIT_TIMEOUT || GetLastError() == ERROR_NETNAME_DELETED) {
				std::cout << "socket disconnection" << overlap->socket << std::endl;
				closesocket(overlap->socket);
				delete overlap;
				continue;
			}
			std::cout << "GetQueuedCompletionStatus failed" << std::endl;
			return 0;
		}
		switch (overlap->type) {
		case IO_ACCEPT: {
			PostAcceptEx(listenSocket);
			std::cout << "happend IO_ACCEPT: " << bytesTrans << std::endl;
			setsockopt(overlap->socket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)&(listenSocket), sizeof(SOCKET));
			ZeroMemory(overlap->buffer, BUFFER_SIZE);
			overlap->type = IO_RECV;
			overlap->wsaBuff.buf = overlap->buffer;
			overlap->wsaBuff.len = BUFFER_SIZE;
			CreateIoCompletionPort((HANDLE)overlap->socket, completionPort, NULL, 0);

			DWORD dwRecv = 0, dwFlag = 0;
			int ret = WSARecv(overlap->socket, &overlap->wsaBuff, 1, &dwRecv, &dwFlag, &(overlap->overlapped), 0);
			if (ret == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
				std::cout << "WSARecv failed: " << WSAGetLastError() << std::endl;
			}
		}
		break;
		case IO_RECV: {
			std::cout << "happend IO_RECV: " << bytesTrans << std::endl;
			if (bytesTrans == 0) {
				std::cout << "socket disconnection" << overlap->socket << std::endl;
				closesocket(overlap->socket);
				delete overlap;
				continue;
			}
			std::cout << "recv data : " << overlap->buffer << std::endl;
			ZeroMemory(&overlap->overlapped, sizeof(OVERLAPPED));
			overlap->type = IO_SEND;
			overlap->wsaBuff.buf = "hello from server";
			overlap->wsaBuff.len = strlen("hello from server");
			DWORD dwSend = 0;
			int ret = WSASend(overlap->socket, &overlap->wsaBuff, 1, &dwSend, 0, &(overlap->overlapped), 0);
			if (ret == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
				std::cout << "WSARecv failed: " << WSAGetLastError() << std::endl;
			}
		}
		break;
		case IO_SEND:
		{
			std::cout << "happend IO_SEND: " << bytesTrans << std::endl;
			if (bytesTrans == 0) {
				std::cout << "socket disconnection" << overlap->socket << std::endl;
				closesocket(overlap->socket);
				delete overlap;
				continue;
			}

		}
		}
	}
}


// 初始化 回滚式代码
int InitServer(ServerParams &pms)
{		
	// socket
	// bind
	// listen
	// bind iocp
	WSADATA wsaData;
	int ret;
	ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
	if (ret == 0) {
		// 成功
		// 这里可以使用socket接口也可以使用WSASocket，但是WSASocket可以设置成重叠io
		pms.listenSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
		if (pms.listenSocket != INVALID_SOCKET) {
			// 绑定地址和端口
			sockaddr_in address;
			address.sin_family = AF_INET;
			address.sin_addr.s_addr = INADDR_ANY;
			address.sin_port = htons(PORT);
			ret = bind(pms.listenSocket, (const sockaddr*)&address, sizeof(address));
			if (ret == 0) {
				ret = listen(pms.listenSocket, SOMAXCONN);
				if (ret == 0) {
					pms.comletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
					if (pms.comletionPort != NULL) { // 创建成功
						if(NULL != CreateIoCompletionPort((HANDLE)pms.listenSocket,pms.comletionPort,NULL,0)) // 绑定成功
							return 0;
						CloseHandle(pms.comletionPort);
					}
				}
			}
		}
		closesocket(pms.listenSocket);
	}
	WSACleanup();
	if (ret == 0) ret = -1;
	return ret;
}

int main() {
	ServerParams pms;
	int ret;
	ret = InitServer(pms);
	if (ret != 0) {
		std::cout << "initserver error" << std::endl;
		return 1;
	}
	for (int i = 0; i < THREAD_COUNT; i++) {
		CreateThread(NULL, 0, workerThread, &pms, 0, NULL);
	}
	for (int i = 0; i < START_POST_ACCEPTEX; i++) {
		// 同时可以处理多个连接accept
		PostAcceptEx(pms.listenSocket);
	}
	getchar();
	closesocket(pms.listenSocket);
	CloseHandle(pms.comletionPort);
	WSACleanup();
	return 0;
}