#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <regex>

#include <TCP_Protocol.h>

using namespace inaf::oasbo::ConnectionProtocols;

TCPProtocol::TCPProtocol() :
		TCPProtocol("127.0.0.1", 9003) {
}
TCPProtocol::TCPProtocol(std::string ip, int prt) :
		srv_sock(-1), cli_sock(-1), ip(ip), port(prt) {
	host = ip + ":" + std::to_string(port);
}

TCPProtocol::~TCPProtocol() {
	closeConnectionToClient();
	closeConnectionToServer();
}

int TCPProtocol::sendToServer(PacketLib::BasePacket &pack) {
	int val = ::send(cli_sock, pack.getBinaryPointer(),
			pack.getHeaderSize() + pack.getPayloadSize() + pack.getTailSize(),
			MSG_CONFIRM);
	return val;
}
int TCPProtocol::receiveFromClient(PacketLib::BasePacket &pack) {
	ssize_t headerSize = pack.getHeaderSize();
	uint8_t *buff = new uint8_t[pack.getPacketStructureByteSize()];
	ssize_t rec = ::recv(this->srv_sock, &buff[0], headerSize, MSG_WAITALL);
	if (rec == 0) { // connessione chiusa
		closeConnectionToClient();
		delete buff;
		return 0;
	}
	if (rec != headerSize) {
		delete buff;
		return -1;
	}
	pack.copyToBinaryPointer(buff, headerSize);
	if (!pack.isRecognizedHeader()) {
		resetPacket(pack, headerSize);
		delete buff;
		return -1;
	}

	int to_be_rcv = pack.getPayloadSize() + pack.getTailSize();
	rec += ::recv(this->srv_sock, &buff[headerSize], to_be_rcv, MSG_WAITALL);
	if (rec != to_be_rcv + headerSize) {
		resetPacket(pack, headerSize);
		delete buff;
		return -1;
	}
	pack.copyToBinaryPointer(&buff[headerSize],
			pack.getPayloadSize() + pack.getTailSize(), headerSize);
	delete buff;
	return rec;
}

int TCPProtocol::connectToClient() {
	return m_connectToCli(ip, port);
}
int TCPProtocol::connectToServer() {
	return m_connectToSrv(ip, port);
}

int TCPProtocol::closeConnectionToClient() {
	if (srv_sock != -1) {
		::close(srv_sock);
		srv_sock = -1;
	}
	return 1;
}
int TCPProtocol::closeConnectionToServer() {
	if (cli_sock != -1) {
		::close(cli_sock);
		cli_sock = -1;
	}
	return 1;
}

bool TCPProtocol::isConnectedToClient() const {
	return srv_sock > 0;
}
bool TCPProtocol::isConnectedToServer() const {
	return cli_sock > 0;
}

int TCPProtocol::m_connectToCli(std::string ip, int port) {
	std::cout << "Listening on: " << ip << ":" << port << std::endl;
	// Creating socket file descriptor
	if (srv_sock == -1) {
		if ((srv_sock = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
			std::cerr << "socket failed" << std::endl;
			;
			return -1;
		}
	}
	struct sockaddr_in servaddr;
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = ::inet_addr(ip.c_str());
	servaddr.sin_port = htons(port);
	if (bind(srv_sock, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0) {
		std::cerr << "TCP CONNECTION: Bind failed" << std::endl;
		;
		srv_sock = -1;
		return -1;
	}
	std::cout << "TCP CONNECTION: Waiting for connection" << std::endl;

	if (listen(srv_sock, 1) < 0) {
		std::cerr << "TCP CONNECTION:  Listen error" << std::endl;
		;
		srv_sock = -1;
		return -1;
	}
	int newSocket;
	int addrlen = sizeof(servaddr);
	if ((newSocket = accept(srv_sock, (struct sockaddr*) &servaddr,
			(socklen_t*) &addrlen)) < 0) {
		std::cerr << "TCP CONNECTION:  accept error" << std::endl;
		;
		srv_sock = -1;
		return -1;
	}
	::close(srv_sock);
	std::cout << "TCP CONNECTION:  Connected" << std::endl;
	srv_sock = newSocket;
	return srv_sock;
}
int TCPProtocol::m_connectToSrv(std::string ip, int port) {
	int sock = 0;
	struct sockaddr_in cli_addr;
	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		std::cerr << "TCP CONNECTION: Socket creation error" << std::endl;
		;
		this->cli_sock = -1;
		return -1;
	}

	cli_addr.sin_family = AF_INET;
	cli_addr.sin_port = htons(port);

	// Convert IPv4 and IPv6 addresses from text to binary form
	if (inet_pton(AF_INET, ip.c_str(), &cli_addr.sin_addr) <= 0) {
		std::cerr << "TCP CONNECTION: Invalid address/ Address not supported"
				<< std::endl;
		;
		this->cli_sock = -1;
		return -1;
	}

	if (connect(sock, (struct sockaddr*) &cli_addr, sizeof(cli_addr)) < 0) {
		std::cerr << "TCP CONNECTION: Connection Failed " << std::endl;
		;
		this->cli_sock = -1;
		return -1;
	}
	std::cout << "Connected" << std::endl;
	this->cli_sock = sock;
	return cli_sock;

}

void TCPProtocol::resetPacket(PacketLib::BasePacket &pack, int bytes) {
	uint8_t *buff = new uint8_t[bytes];
	std::memset(buff, 0, bytes);
	int toBeReset = std::min(
			static_cast<int>(pack.getPacketStructureByteSize()), bytes);
	pack.copyToBinaryPointer(buff, toBeReset);
	delete buff;
}