#include "TcpClient.hpp"

TcpClient::TcpClient(ConfigService* config, LoggerService* logger) : TcpBase(logger) {

    if(!(config->getConfig<ClientConfig>("TcpClient", "main", &configuration_))) {
        logger_->log("TcpClient", LogFlag::Error, "Failed to get configuration");
        return;
    }

    if(init() == ErrorCode::Success) {
        logger_->log("TcpClient", LogFlag::Info, "TcpClient initialized.");
    } else {
        logger_->log("TcpClient", LogFlag::Error, "TcpClient failed to initialize.");
    }

}

TcpClient::~TcpClient() {
    // close port
}

ErrorCode TcpClient::init() {
    logger_->log("TcpClient", LogFlag::Debug, "Initializing TcpClient...");

    // keeping everything in here for now
    int socketFd; // file descriptor for the client socket (socket proper is a function)
    int sendBytes;
    int receiveBytes;
    char buffer[1024];

    struct hostent* host; // houses host network info
    struct sockaddr_in serverAddress; // ip address of the server socket 

    // parse the hostname string into uint8s
    host = gethostbyname(configuration_.hostname.c_str());
    if(host == NULL) {
        logger_->log("TcpClient", LogFlag::Debug, "Unable to parse hostname.");
        close(socketFd); // TODO: probably on a destructor
        return ErrorCode::Error;
    }

    // create tcp socket
    socketFd = socket(AF_INET, SOCK_STREAM, 0);
    if(socketFd < 0) {
        logger_->log("TcpClient", LogFlag::Debug, "Unable to open client socket.");
        close(socketFd);
        return ErrorCode::Error;
    }

    // describe the server address from the hostname and port
    memset(&serverAddress.sin_zero, 0, sizeof(serverAddress.sin_zero));
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(configuration_.port);
    serverAddress.sin_addr = *((struct in_addr*)host->h_addr);

    // connect to server
    if(connect(socketFd, (struct sockaddr*)&serverAddress, sizeof(struct sockaddr)) < 0) {
        logger_->log("TcpClient", LogFlag::Debug, "Unable to connect to server.");
        close(socketFd);
        return ErrorCode::Error;
    }
    
    std::string message = "placeholder";
    while(!message.empty()) {
        logger_->log("TcpClient", LogFlag::Debug, "Enter message...");
        std::getline(std::cin, message);

        // send data buffer to server
        sendBytes = tcpSend(socketFd, message.c_str(), message.size());

        if(sendBytes < 0) {
            logger_->log("TcpClient", LogFlag::Error, "Unable to send to server.");
            close(socketFd);
            return ErrorCode::Error;
        }
        logger_->log("TcpClient", LogFlag::Debug, "Sent {} bytes to the server.", sendBytes);


        // listen for receive from the server
        memset(buffer, 0x00, sizeof(buffer));
        receiveBytes = tcpRead(socketFd, buffer, sizeof(buffer)); // TODO: this currently blocks forever, add timeout

        // we expect a response based on the server design, something went wrong otherwise
        if(receiveBytes < 0) {
            logger_->log("TcpClient", LogFlag::Error, "Unable to receive from server.");
            return ErrorCode::Error;
        } else if(receiveBytes == 0) {
            logger_->log("TcpClient", LogFlag::Error, "Server closed the connection during receive.");
            close(socketFd);
            return ErrorCode::Error;
        }

        logger_->log("TcpClient", LogFlag::Debug, "Received {} bytes back from the server", receiveBytes);
    }

    close(socketFd);

    return ErrorCode::Success;
}