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

#include <UDP_Protocol.h>
#include <Base_Configurator.h>

using namespace inaf::oasbo::ConnectionProtocols;

UDPProtocol::UDPProtocol() :
		UDPProtocol(std::string("127.0.0.1"), 9003) {
}

UDPProtocol::UDPProtocol(std::string ip, int port) :
		srv_sock(-1), cli_sock(-1), ip(ip), port(port) {
	memset(&cliaddr, 0, sizeof(cliaddr));
	memset(&srvaddr, 0, sizeof(srvaddr));
	// Filling server information
	srvaddr.sin_family = AF_INET; // IPv4
	srvaddr.sin_addr.s_addr = inet_addr(ip.c_str());
	srvaddr.sin_port = htons(this->port);
	struct timeval timeout;
	timeout.tv_sec = 5;
	timeout.tv_usec = 0;
	setsockopt(srv_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
}

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

int UDPProtocol::sendToServer(PacketLib::BasePacket &pack) {
	int val = ::sendto(cli_sock, pack.getBinaryPointer(),
			pack.getHeaderSize() + pack.getPayloadSize() + pack.getTailSize(),
			MSG_CONFIRM, (struct sockaddr*) &srvaddr, sizeof(srvaddr));
	return val;
}

int UDPProtocol::receiveAtLeastHeaderSizeBytes(uint8_t *buff, int headerSize,
		int packetSize) {
	int bytercv = 0;
	socklen_t len = sizeof(cliaddr);
	while (bytercv < headerSize) {
		int rcv = recvfrom(srv_sock, &buff[bytercv], packetSize + 1, // +1 to recognized if there are more bytes than expected
		MSG_WAITFORONE, (struct sockaddr*) &cliaddr, &len);
		bytercv += rcv;
		if (rcv < 0) {
			return -1;
		}
	}
	return bytercv;
}

int UDPProtocol::receiveFromClient(PacketLib::BasePacket &pack) {
	bool headerFlag = false;
	int headerSize = pack.getHeaderSize();
	int packSize = pack.getPacketStructureByteSize();
	int tailSize = pack.getTailSize();
	uint payloadSize = 0;
	uint totPacketSize = 0;
	ssize_t to_be_received = 0;
	uint8_t *buff = new uint8_t[(packSize + headerSize) * headerSize]; // to avoid overflow
	int tot_byte_rcv = 0;
	while (true) {
		while (!headerFlag) { // until the header has not received
			int rcv = receiveAtLeastHeaderSizeBytes(buff, headerSize, packSize); // receive at least headerSize byte, maximum packSize for each udp rcv.
			if (rcv == -1) {
				delete buff;
				return -1;
			}
			tot_byte_rcv += rcv;
			pack.copyToBinaryPointer(buff, headerSize); //copy the header into packet to be able to read it.
			if (!pack.isRecognizedHeader()) { // reset buffer and exit
				resetPacket(pack, headerSize);
				delete buff;
				return -1;
			}
			headerFlag = true;
			payloadSize = pack.getPayloadSize();
			totPacketSize = headerSize + payloadSize + tailSize;
			to_be_received = totPacketSize - tot_byte_rcv; // Calculate how much is still left to read
		}

		if (to_be_received == 0) { // whole packet has been received.
			pack.copyToBinaryPointer(&buff[headerSize],
					tot_byte_rcv - headerSize, headerSize); // copy the buffer into packet except already copied header
			delete buff;
			return tot_byte_rcv;
		}
		if (to_be_received < 0) {	// error,received more bytes then expected.
			resetPacket(pack, tot_byte_rcv);
			delete buff;
			return -1;
		}
		uint8_t *tmp_buff = new uint8_t[packSize + headerSize]; // maximum receivable in receiveAtLeastHeaderSizeBytes
		int rcv = receiveAtLeastHeaderSizeBytes(tmp_buff, headerSize, packSize);
		if (rcv == -1) {
			delete buff;
			delete tmp_buff;
			resetPacket(pack, tot_byte_rcv);
			return -1;
		}
		std::vector<uint8_t> vec;
		std::copy(tmp_buff, tmp_buff + headerSize, std::back_inserter(vec));
		if (pack.isRecognizedHeader(vec)) { //another header received, save it and discard previous data.
			std::memset(buff, 0, tot_byte_rcv);
			std::memcpy(buff, tmp_buff, rcv);
			headerFlag = true;
			pack.copyToBinaryPointer(buff, headerSize);
			payloadSize = pack.getPayloadSize();
			totPacketSize = headerSize + payloadSize + tailSize;
			to_be_received = totPacketSize - rcv;
			tot_byte_rcv = rcv;
		} else { // append to current buff
			tot_byte_rcv += rcv;
			std::memcpy(&buff[tot_byte_rcv - rcv], tmp_buff, rcv);
			to_be_received -= rcv;
		}
		delete tmp_buff;
	}
}

int UDPProtocol::connectToClient() {
	int sockfd;

	// Creating socket file descriptor
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		std::cerr << "UDP Connection: socket creation failed" << std::endl;
		return -1;
	}

	// Set timeout to the socket
	struct timeval tv;
	tv.tv_sec = std::numeric_limits<time_t>::max();
	tv.tv_usec = 0;
	setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*) &tv, sizeof tv);

	// Bind the socket with the server address
	if (bind(sockfd, (const struct sockaddr*) &srvaddr, sizeof(srvaddr)) < 0) {
		std::cerr << "UDP Connection: bind failed" << std::endl;
		return -1;
	}

	this->srv_sock = sockfd;
	return sockfd;

}
int UDPProtocol::connectToServer() {
	int sockfd = 0;
	// Creating socket file descriptor
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		std::cerr << "UDP Connection: socket creation failed " << std::endl;
		exit(EXIT_FAILURE);
	}

	std::cout << "UDP Connection: socket creation success " << std::endl;

	this->cli_sock = sockfd;

	return sockfd;
}

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

bool UDPProtocol::isConnectedToClient() const {
	return srv_sock != -1;
}
bool UDPProtocol::isConnectedToServer() const {
	return cli_sock != -1;
}

void UDPProtocol::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;
}
void UDPProtocol::split_ip_port(const std::string &ip_port,
		std::string &ip_address, std::string &port) {
	// Regex pattern to match IP address and port in the format "xxx.xxx.xxx.xxx:xxxx"
	std::regex pattern("^(\\d{1,3}\\.){3}\\d{1,3}:(\\d{1,5})$");

	// Check if the input string matches the expected format
	if (!std::regex_match(ip_port, pattern)) {
		std::cerr << "Error: invalid IP address and port format: " << ip_port
				<< std::endl;
		exit(EXIT_FAILURE);
	}

	// Split the input string into IP address and port
	int colon_pos = ip_port.find(":");
	ip_address = ip_port.substr(0, colon_pos);
	port = ip_port.substr(colon_pos + 1);
}

using U_B = UDPProtocol::Builder;
U_B::Builder() {
	this->reset();
}
U_B::Builder(std::string ip, int port) {
	this->protocol = new UDPProtocol(ip, port);

}
U_B::~Builder() {
	delete protocol;
}

void U_B::reset() {
	this->protocol = new UDPProtocol();
}

U_B* U_B::configFrom(Configurators::BaseConfigurator *conf) {
	std::string target = std::string("UDPProtocol");
	conf->readConfigFromSource(target);
	std::map<std::string, std::string> params = conf->getConfig();

	std::string key = target+"_"+ip_key;
	if (params.count(key) > 0)
		protocol->ip = params[key];

	key = target+"_"+port_key;
	if (params.count(key) > 0)
		protocol->port = std::stoi(params[key]);
	return this;
}

U_B* U_B::setIp(std::string ip) {
	protocol->ip = ip;
	return this;
}

U_B* U_B::setPort(int port) {
	protocol->port = port;
	return this;
}

UDPProtocol* U_B::getProtocol() {
	UDPProtocol *result = this->protocol;
	this->reset();
	return result;
}