//SPDX-License-Identifier: LGPL-3.0-only
//SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®

// A failed resolve or connect throws SocketErrorException, a std::system_error
// whose code() carries what it failed with: the errno for a connect, under
// std::generic_category(); the getaddrinfo result for a name, under
// ResolverCategory(), whose text is gai_strerror's. `phase` says which step
// failed. Before, both were a bare std::runtime_error, so a caller that
// reports the cause in its own words — "[Errno 111] Connection refused" in
// front of a language model reading the output — had to parse the message
// back apart. The message itself stays what it always was, and the exception
// is still a std::runtime_error, so existing handlers keep working.

#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <cerrno>
#include <cstdlib>
#include <cstring>

import Crafter.Network;
import std;
using namespace Crafter;
using namespace std::chrono_literals;

namespace {

int failures = 0;

void Check(bool ok, std::string_view what) {
    std::println("{}  {}", ok ? "PASS" : "FAIL", what);
    if (!ok) ++failures;
}

// A port on 127.0.0.1 nothing listens on: bound by the kernel, then released.
std::uint16_t ClosedPort() {
    const int fd = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in address {};
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    bind(fd, reinterpret_cast<sockaddr*>(&address), sizeof(address));
    socklen_t length = sizeof(address);
    getsockname(fd, reinterpret_cast<sockaddr*>(&address), &length);
    close(fd);
    return ntohs(address.sin_port);
}

} // namespace

int main() {
    {
        bool thrown = false;
        try {
            ClientTCP client("127.0.0.1", ClosedPort(), 2s);
        } catch (const SocketErrorException& e) {
            thrown = true;
            Check(e.phase == SocketPhase::Connect, "a refused connect failed in the connect phase");
            Check(e.code().category() == std::generic_category(), "its code is an errno");
            Check(e.code().value() == ECONNREFUSED, std::format("it carries ECONNREFUSED (got {})", e.code().value()));
            Check(e.code() == std::errc::connection_refused, "and compares with std::errc::connection_refused");
            Check(e.code().message() == std::strerror(ECONNREFUSED), std::format("its code's text is strerror's (got '{}')", e.code().message()));
            Check(std::string_view(e.what()) == std::string("Could not connect to server: ") + std::strerror(ECONNREFUSED),
                  std::format("its message is the one ClientTCP always threw (got '{}')", e.what()));
        }
        Check(thrown, "a refused connect throws SocketErrorException");
    }

    {
        bool caught = false;
        bool system = false;
        try {
            ClientTCP client("127.0.0.1", ClosedPort(), 2s);
        } catch (const std::system_error& e) {
            system = e.code() == std::errc::connection_refused;
            caught = dynamic_cast<const std::runtime_error*>(&e) != nullptr;
        }
        Check(caught && system, "it is caught as std::system_error, and is still a std::runtime_error");
    }

    {
        // .invalid never resolves (RFC 6761); without a network the resolver
        // fails differently (EAI_AGAIN), but always as a resolver error.
        bool thrown = false;
        try {
            ClientTCP client("no-such-host.invalid", 80, 2s);
        } catch (const SocketErrorException& e) {
            thrown = true;
            Check(e.phase == SocketPhase::Resolve, "a name that does not resolve failed in the resolve phase");
            Check(e.code().category() == ResolverCategory(), "its code is in the resolver category");
            Check(e.code().value() != 0, std::format("it carries the getaddrinfo code (got {})", e.code().value()));
            Check(e.code().message() == gai_strerror(e.code().value()), std::format("the category's text is gai_strerror's (got '{}')", e.code().message()));
            Check(std::string_view(e.what()) == std::string("Could not resolve host 'no-such-host.invalid': ") + gai_strerror(e.code().value()),
                  std::format("its message names the host, the code's text after it (got '{}')", e.what()));
        }
        Check(thrown, "an unresolvable host throws SocketErrorException");
    }

    std::println("{}", failures == 0 ? "all checks passed" : "check(s) failed");
    return failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}