/*
Crafter®.Network
Copyright (C) 2025 Catcrafts®
Catcrafts.net

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/

module;

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <sys/uio.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <netdb.h>
#include <strings.h>

module Crafter.Network:ClientTCP_impl;
import :ClientTCP;
import Crafter.Thread;
import std;

using namespace Crafter;

ClientTCP::ClientTCP(int socketid) : socketid(socketid)
{

}

ClientTCP::ClientTCP(const char* hostName, std::uint16_t port)
{
	hostent *host;
	sockaddr_in serv_addr;

	host=gethostbyname(hostName);
	if((socketid = socket(AF_INET, SOCK_STREAM, 0)) == -1){
        std::cerr << "Could not open socket" << std::endl;
	}

	serv_addr.sin_family = AF_INET;
	serv_addr.sin_port = htons(port);
	serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
	bzero(&(serv_addr.sin_zero),8);

	if(connect(socketid,(sockaddr*)&serv_addr, sizeof(sockaddr)) == -1){
        std::cerr << "Could not connect to server" << std::endl;
	}
}

ClientTCP::ClientTCP(std::string hostName, std::uint16_t port): ClientTCP(hostName.c_str(), port) 
{

}

ClientTCP::~ClientTCP()
{
	close(socketid);
}

void ClientTCP::Send(const void* buffer, std::uint32_t size) const {
    send(socketid, reinterpret_cast<const char*>(buffer), size, 0);
}

std::vector<char> ClientTCP::RecieveSync(std::uint32_t bufferSize) const {
    std::vector<char> totalBuffer(bufferSize);
    int read = recv(socketid, totalBuffer.data(), bufferSize, 0);
    if(read < bufferSize){
        totalBuffer.resize(read);
    }
    return totalBuffer;
}
int ClientTCP::RecieveSync(std::uint32_t bufferSize, void* buffer) const {
    return recv(socketid, reinterpret_cast<char*>(buffer), bufferSize, 0);
}

std::vector<char> ClientTCP::RecieveSync() const {
    int count;
    ioctl(socketid, FIONREAD, &count);
    std::vector<char> buffer(count);
    recv(socketid, buffer.data(), count, 0);
    return buffer;
}

std::vector<char> ClientTCP::RecieveUntilCloseSync() const {
    int count;
    ioctl(socketid, FIONREAD, &count);
    std::vector<char> buffer(count);
    recv(socketid, buffer.data(), count, 0);
    while(true) {
        ioctl(socketid, FIONREAD, &count);
        unsigned int oldSize = buffer.size();
        buffer.resize(buffer.size()+count);
        if(recv(socketid, buffer.data()+oldSize, count, 0) == -1) {
            break;
        }
    }
    return buffer;
}

std::vector<char> ClientTCP::RecieveUntilFullSync(std::uint32_t bufferSize) const {
    std::vector<char> buffer(bufferSize);
    int read = 0;
    while(read < bufferSize) {
        int newRead = recv(socketid, buffer.data()+read, bufferSize-read, 0);
        if(newRead == -1) {
            break;
        } else{
            read+=newRead;
        }
    }
    buffer.resize(read);
    return buffer;
}

void ClientTCP::RecieveAsync(std::uint32_t bufferSize, std::function<void(std::vector<char>)> recieveCallback) const {
    ThreadPool::Enqueue([recieveCallback, this, bufferSize](){
        recieveCallback(this->RecieveSync(bufferSize));
    });
}

void ClientTCP::RecieveAsync(std::uint32_t bufferSize, std::function<void(int)> recieveCallback, char* buffer) const {
    ThreadPool::Enqueue([recieveCallback, this, bufferSize, buffer](){
        recieveCallback(this->RecieveSync(bufferSize, buffer));
    });
}

void ClientTCP::RecieveUntilFullAsync(std::uint32_t bufferSize, std::function<void(std::vector<char>)> recieveCallback) const {
    ThreadPool::Enqueue([recieveCallback, this, bufferSize](){
        recieveCallback(this->RecieveUntilFullSync(bufferSize));
    });
}

void ClientTCP::RecieveAsync(std::function<void(std::vector<char>)> recieveCallback) const {
    ThreadPool::Enqueue([this, recieveCallback](){
        recieveCallback(this->RecieveSync());
    });
}

void ClientTCP::RecieveUntilCloseAsync(std::function<void(std::vector<char>)> recieveCallback) const {
    ThreadPool::Enqueue([this, recieveCallback](){
        recieveCallback(this->RecieveUntilCloseSync());
    });
}