#include "config.hpp"
#include "network.hpp"
#include "program.hpp"
#include "runner.hpp"
#include <filesystem>
#include <iostream>
#include <queue>
#include <spawn.h>
#include <string_view>
#include <toml++/toml.h>
#include <vector>
#include <wait.h>

#include "host.hpp"
#include "zmq_addon.hpp"

static constexpr uint32_t JOB_ID_LEN = 32;
static constexpr uint32_t MIN_MESSAGE_LEN = JOB_ID_LEN + sizeof(uint32_t) * 2;

sk::runner_backend detect_backend() {
    const char *const argv[] = {"docker", "stats", "--no-stream", nullptr};
    pid_t pid;
    if (posix_spawnp(&pid, argv[0], nullptr, nullptr, const_cast<char *const *>(argv), nullptr) != 0) {
        return sk::runner_backend::BubbleWrap;
    }
    int status = 0;
    waitpid(pid, &status, 0);
    std::cout << status << std::endl;
    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
        std::cerr << "Using Docker" << std::endl;
        return sk::runner_backend::Docker;
    }
    return sk::runner_backend::BubbleWrap;
}

int main() {
    std::vector<sk::host> listsHosts = sk::config::loadHostsFromToml("../conf.toml");
    std::priority_queue<sk::host> hosts(listsHosts.begin(), listsHosts.end());

    std::queue<sk::program> programQueue;

    if (hosts.empty()) {
        std::cerr << "Pas de host" << std::endl;
        exit(1);
    }

    sk::runner runner(detect_backend());

    zmq::context_t context(1);
    zmq::socket_t receiver(context, zmq::socket_type::pull);
    receiver.connect("tcp://localhost:5557");
    zmq::socket_t sender(context, zmq::socket_type::push);
    sender.connect("tcp://localhost:5558");

    while (true) {
        zmq::message_t request;
        receiver.recv(request);
        if (request.size() < MIN_MESSAGE_LEN) {
            std::cerr << "Invalid request" << std::endl;
            break;
        }

        std::string_view jobId(static_cast<char *>(request.data()), JOB_ID_LEN);
        uint32_t imageLen = sk::read_uint32(static_cast<char *>(request.data()) + JOB_ID_LEN);
        uint32_t codeLen = sk::read_uint32(static_cast<char *>(request.data()) + JOB_ID_LEN + sizeof(uint32_t));

        if (request.size() < MIN_MESSAGE_LEN + imageLen + codeLen) {
            std::cerr << "Invalid request" << std::endl;
            break;
        }
        std::string imageString(static_cast<char *>(request.data()) + MIN_MESSAGE_LEN, imageLen);
        std::string requestString(static_cast<char *>(request.data()) + MIN_MESSAGE_LEN + imageLen, codeLen);

        std::cout << "Executing " << codeLen << " bytes code.\n";
        sk::program program{requestString, imageString};
        sk::run_result result = runner.run_blocking(program);

        std::cout << "Result: " << result.out << std::endl;

        // Send the job id and result.out to sink
        zmq::message_t reply(JOB_ID_LEN + result.out.size());
        memcpy(reply.data(), jobId.data(), JOB_ID_LEN);
        memcpy(static_cast<char *>(reply.data()) + JOB_ID_LEN, result.out.data(), result.out.size());
        sender.send(reply, zmq::send_flags::none);
    }
    return 0;
}