#include "rpc_server.hpp"
#include <sys/socket.h>
#include <unistd.h>

auto slige_rpc::ClientSocket::Read(
    uint8_t* buffer, size_t length) -> std::variant<size_t, slige_rpc::Ewwow>
{
    ssize_t bytes_read = recv(fd, buffer, length, 0);
    if (bytes_read < 0) {
        return Ewwow { .message = "unable to read" };
    }
    return (size_t)bytes_read;
};

auto slige_rpc::ClientSocket::Write(
    uint8_t* buffer, size_t length) -> std::variant<size_t, slige_rpc::Ewwow>
{
    ssize_t bytes_written = send(fd, buffer, length, 0);
    if (bytes_written < 0) {
        return Ewwow { .message = "unable to write" };
    }
    return (size_t)bytes_written;
};

auto slige_rpc::Socket::Connect()
    -> std::variant<ClientSocket, slige_rpc::Ewwow>
{
    int socket_fd;
    if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        return { Ewwow { .message = "could not get socket" } };
    }
    // TODO:
    // 1) does address (presumably 'socket)
    //    live as long as child socket ('client)?
    //    - immediate answer is no
    // 2) does it need to?
    if (connect(socket_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        return { Ewwow {
            .message = "could not connect, is the server running?" } };
    }
    return { ClientSocket(socket_fd) };
}

auto slige_rpc::ServerSocket::Accept()
    -> std::variant<ClientSocket, slige_rpc::Ewwow>
{
    unsigned int address_size = sizeof(address);
    // TODO:
    // 1) does address (presumably 'server)
    //    live as long as child socket ('socket)?
    //    - immediate answer is no
    // 2) does it need to?
    int client = accept(fd, (struct sockaddr*)&address, &address_size);
    if (client < 0) {
        return Ewwow { .message = "could not accept" };
    }
    return client;
    return { ClientSocket(client) };
}

auto slige_rpc::Socket::Bind() -> std::variant<ServerSocket, slige_rpc::Ewwow>
{
    int socket_fd;
    if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        return { Ewwow { .message = "could not get socket" } };
    }
    // TODO:
    // 1) does address (presumably 'socket)
    //    live as long as child socket ('server)?
    //    - immediate answer is no
    // 2) does it need to?
    if (bind(socket_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        return { Ewwow { .message = "could not bind" } };
    }

    if (listen(socket_fd, 0) < 0) {
        return { Ewwow { .message = "could not listen" } };
    }
    // TODO:
    // 1) does this address get moved, copied or cloned?
    //    it should be represented as a u32,
    //    so copying should be fine - but does it?
    return { ServerSocket(socket_fd, address) };
}