/*
Crafter® Build
Copyright (C) 2026 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 version 3.0 as published by the Free Software Foundation;

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
*/
import Crafter.Network;
import Crafter.Thread;
import std;
using namespace Crafter;

int main() {
    ThreadPool::Start();

    constexpr std::uint16_t port = 9181;
    constexpr std::string_view alpn = "f3d/test-stream";

    std::promise<std::string> serverHeard;
    auto serverHeardFuture = serverHeard.get_future();

    QUICServerCredentials serverCreds;
    serverCreds.selfSigned = true;

    ListenerQUIC listener(port, std::string(alpn), serverCreds, [&](ClientQUIC* peer) {
        peer->OnStream([&](QUICStream stream){
            try {
                std::vector<char> got = stream.RecieveSync();
                stream.SendSync(got.data(), static_cast<std::uint32_t>(got.size()), true);
                serverHeard.set_value(std::string(got.begin(), got.end()));
            } catch (...) {
                serverHeard.set_value("");
            }
        });
    });
    listener.ListenAsyncAsync();

    try {
        QUICClientCredentials clientCreds;
        clientCreds.insecureNoServerValidation = true;
        ClientQUIC client("localhost", port, std::string(alpn), clientCreds);

        QUICStream stream = client.OpenStream();
        const char hello[] = "ping";
        stream.SendSync(hello, sizeof(hello) - 1, false);

        std::vector<char> echoed = stream.RecieveUntilCloseSync();
        std::string echoStr(echoed.begin(), echoed.end());

        if (serverHeardFuture.wait_for(std::chrono::seconds(5)) != std::future_status::ready) {
            std::println("server never heard from client");
            return 1;
        }
        std::string heard = serverHeardFuture.get();

        if (heard != "ping" || echoStr != "ping") {
            std::println("server heard '{}' echoed '{}'", heard, echoStr);
            return 1;
        }
        // Skip the static-dtor cleanup — msquic's RegistrationClose blocks
        // until every connection it ever opened is fully torn down. The
        // listener-accepted server-side peer is heap-allocated and leaked
        // by design (the user owns it), so it would otherwise wait for
        // QUIC's idle timeout. The test logic succeeded; just exit.
        std::_Exit(0);
    } catch (std::exception& e) {
        std::println("{}", e.what());
        return 1;
    }
}