// End-to-end: the hook template in every mode over the self-test hook, the tracer writing a
// real JSONL file, and tracecmp.py judging it (exit 0 clean / 1 divergence / 2 invalid).
#include <cstdio>
#include <cstring>
#include <fstream>
#include <sstream>
#include <string>
#include <thread>
#include <vector>

#include "check.h"
#include "harness.h"
#include "shim/trace/hook.h"
#include "shim/trace/selftest.h"
#include "shim/trace/tracer.h"

using namespace shim::trace;
using namespace shim::selftest;

static std::string slurp(const std::string& p) {
    std::ifstream f(p, std::ios::binary);
    std::stringstream ss;
    ss << f.rdbuf();
    return ss.str();
}

static std::vector<std::string> lines(const std::string& s) {
    std::vector<std::string> out;
    std::size_t start = 0;
    while (start < s.size()) {
        std::size_t nl = s.find('\n', start);
        if (nl == std::string::npos) nl = s.size();
        out.push_back(s.substr(start, nl - start));
        start = nl + 1;
    }
    return out;
}

static bool has(const std::string& hay, const char* needle) { return hay.find(needle) != std::string::npos; }

using HFill = Hook<FillHook>;
using HWrong = Hook<FillWrongHook>;
using HThrows = Hook<FillThrowsHook>;

static void wire() {
    HFill::original = &Fill;
    HWrong::original = &Fill;
    HThrows::original = &Fill;
}

static std::uint32_t reference(std::uint32_t n, std::uint32_t seed) {
    std::vector<std::uint8_t> b(n);
    return Fill(b.data(), n, seed);
}

// ---- without a tracer: modes still route correctly, nothing is written ----------------------------

static void modes_without_tracer() {
    wire();
    std::uint8_t buf[16];
    const std::uint32_t want = reference(16, 1);
    HFill::mode = Mode::Off;
    CHECK_EQ(HFill::detour()(buf, 16, 1), want);
    HFill::mode = Mode::Replace;
    CHECK_EQ(HFill::detour()(buf, 16, 1), want);   // ours agrees with the original
    HWrong::mode = Mode::Replace;
    std::uint8_t wb[16];
    CHECK_EQ(HWrong::detour()(wb, 16, 1), want);
    CHECK_EQ(static_cast<int>(wb[15]), (static_cast<int>(buf[15]) + 1) & 0xff);  // replace ran ours (the wrong one)
    HFill::mode = Mode::Trace;
    CHECK_EQ(HFill::detour()(buf, 16, 1), want);   // tracer closed: record dropped, result intact
    HFill::mode = Mode::Compare;
    CHECK_EQ(HFill::detour()(buf, 16, 1), want);
    CHECK_EQ(Tracer::instance().records_written(), 0u);
}

// ---- clean log: trace + compare (identical ours) + replace ------------------------------------------

static void clean_log(const std::string& path) {
    Config cfg;
    cfg.path = path;
    cfg.inline_max = 32;
    cfg.apply("hook.Shim::SelfTest::Fill", "trace");
    Tracer& tr = Tracer::instance();
    tr.configure(cfg);
    HFill::register_policy(tr);
    HWrong::register_policy(tr);
    CHECK(tr.open("shim_trace_test", std::string(64, 'a').c_str()));
    HFill::configure(tr);
    CHECK(HFill::mode == Mode::Trace);

    std::uint8_t buf[64];
    CHECK_EQ(HFill::detour()(buf, 16, 7), reference(16, 7));       // trace, inline region
    CHECK_EQ(HFill::detour()(buf, 64, 8), reference(64, 8));       // trace, hashed region (64 > inline_max 32)
    HFill::mode = Mode::Compare;
    CHECK_EQ(HFill::detour()(buf, 16, 9), reference(16, 9));       // compare, clean
    CHECK_EQ(HFill::detour()(buf, 64, 10), reference(64, 10));
    CHECK_EQ(HFill::detour()(buf, 0, 11), reference(0, 11));       // empty region
    HFill::mode = Mode::Replace;
    CHECK_EQ(HFill::detour()(buf, 16, 12), reference(16, 12));     // replace: nothing emitted

    // call ids are process-global and increase across threads; depth stays 0 per thread
    std::thread t([&] {
        std::uint8_t tb[8];
        HFill::mode = Mode::Trace;
        HFill::detour()(tb, 8, 13);
    });
    t.join();
    tr.close();
    CHECK_EQ(tr.records_written(), 6u);

    const std::string text = slurp(path);
    const auto ls = lines(text);
    CHECK_EQ(ls.size(), static_cast<std::size_t>(7));
    CHECK(has(ls[0], "{\"meta\":{\"format\":1,\"build\":\"shim_trace_test\",\"exe_sha256\":\"aaaa"));
    CHECK(has(ls[0], "\"inline_max\":32,\"hooks\":{\"Shim::SelfTest::Fill\":{\"ftol\":0,\"ftol_kind\":\"abs\",\"ptr\":\"ignore\"},\"Shim::SelfTest::FillWrong\":{"));
    CHECK(has(ls[1], "\"hook\":\"Shim::SelfTest::Fill\",\"mode\":\"trace\",\"call_id\":"));
    CHECK(has(ls[1], "\"depth\":0,\"args\":[{\"t\":\"ptr\",\"v\":\"0x"));
    CHECK(has(ls[1], "\"n\":\"buf\"},{\"t\":\"u32\",\"v\":16,\"n\":\"n\"},{\"t\":\"u32\",\"v\":7,\"n\":\"seed\"}],\"ret\":{\"t\":\"u32\",\"v\":"));
    CHECK(has(ls[1], "\"side\":{\"buf\":{\"before\":{\"t\":\"bytes\",\"n\":16,\"sha256\":\""));
    CHECK(has(ls[1], "\"hex\":\""));
    CHECK(has(ls[2], "\"n\":64,\"sha256\":\""));
    CHECK(has(ls[2], "\"head\":\""));
    CHECK(!has(ls[2], "\"hex\":\""));
    CHECK(has(ls[3], "\"mode\":\"compare\""));
    CHECK(has(ls[3], "\"ours\":{\"ret\":{\"t\":\"u32\",\"v\":"));
    CHECK(has(ls[3], "\"diverged\":false,\"diff\":[]}"));
    CHECK(has(ls[5], "\"n\":0,\"sha256\":\"e3b0c442"));
    CHECK(!has(text, "\"mode\":\"replace\""));
    // the thread's record: different thread id, depth 0, a later call_id than the main thread's
    CHECK(has(ls[6], "\"mode\":\"trace\""));
    CHECK(has(ls[6], "\"v\":13,\"n\":\"seed\"}"));
    // ASCII only, LF only
    for (char c : text) CHECK(static_cast<unsigned char>(c) < 0x80 && c != '\r');

    const int rc = tracetest::run_tracecmp(path);
    if (rc != tracetest::kSkipped) CHECK_EQ(rc, 0);
}

// ---- divergent log: wrong ours (region differs), throwing ours (err) --------------------------------

static void bad_log(const std::string& path) {
    Config cfg;
    cfg.path = path;
    cfg.default_mode = Mode::Compare;
    Tracer& tr = Tracer::instance();
    tr.configure(cfg);
    CHECK(tr.open("shim_trace_test", ""));
    HWrong::configure(tr);
    HThrows::configure(tr);
    HFill::configure(tr);
    CHECK(HWrong::mode == Mode::Compare);

    std::uint8_t buf[16];
    CHECK_EQ(HWrong::detour()(buf, 16, 21), reference(16, 21));    // caller still gets the original's result
    CHECK_EQ(static_cast<int>(buf[15]), static_cast<int>(buf[15]));  // and the original's memory (ours wrote scratch)
    std::uint8_t ref[16];
    Fill(ref, 16, 21);
    CHECK(std::memcmp(buf, ref, 16) == 0);
    CHECK_EQ(HThrows::detour()(buf, 16, 22), reference(16, 22));   // a throwing ours is contained
    CHECK_EQ(HFill::detour()(buf, 16, 23), reference(16, 23));     // and a clean call after it is still clean
    tr.close();

    const auto ls = lines(slurp(path));
    CHECK_EQ(ls.size(), static_cast<std::size_t>(4));
    CHECK(has(ls[1], "\"hook\":\"Shim::SelfTest::FillWrong\",\"mode\":\"compare\""));
    CHECK(has(ls[1], "\"diverged\":true,\"diff\":[{\"path\":\"side.buf.after\",\"why\":\"hash\",\"orig\":{\"t\":\"bytes\",\"n\":16"));
    CHECK(has(ls[1], "\"first_diff_offset\":15}]}"));
    CHECK(has(ls[2], "\"hook\":\"Shim::SelfTest::FillThrows\",\"mode\":\"compare\""));
    CHECK(!has(ls[2], ",\"ours\":{\"ret\""));  // err record: no ours block (the diff's "ours" key is the err text)
    CHECK(has(ls[2], "\"diverged\":true,\"diff\":[{\"path\":\"call\",\"why\":\"err\",\"orig\":null,\"ours\":\"ours: selftest: deliberate throw\"}],\"err\":\"ours: selftest: deliberate throw\"}"));
    CHECK(has(ls[3], "\"diverged\":false,\"diff\":[]}"));

    const int rc = tracetest::run_tracecmp(path);
    if (rc != tracetest::kSkipped) CHECK_EQ(rc, 1);
    // --hook filter on the clean hook only -> clean
    const int rc2 = tracetest::run_tracecmp(path, "--hook Shim::SelfTest::Fill");
    if (rc2 != tracetest::kSkipped) CHECK_EQ(rc2, 0);
}

// ---- an unusable log (truncated last line) is exit 2 --------------------------------------------------

static void truncated_log(const std::string& src, const std::string& dst) {
    std::string text = slurp(src);
    text.resize(text.size() - 10);
    std::FILE* f = std::fopen(dst.c_str(), "wb");
    if (f) {
        std::fwrite(text.data(), 1, text.size(), f);
        std::fclose(f);
    }
    const int rc = tracetest::run_tracecmp(dst);
    if (rc != tracetest::kSkipped) CHECK_EQ(rc, 2);
    const int rc2 = tracetest::run_tracecmp(dst, "--skip-invalid");
    if (rc2 != tracetest::kSkipped) CHECK_EQ(rc2, 0);
}

int main(int argc, char** argv) {
    const std::string dir = argc > 1 ? argv[1] : ".";
    modes_without_tracer();
    clean_log(dir + "/hook_clean.jsonl");
    bad_log(dir + "/hook_bad.jsonl");
    truncated_log(dir + "/hook_clean.jsonl", dir + "/hook_truncated.jsonl");
    // the packaged self-test entry point used by the shim at startup
    Config cfg;
    cfg.path = dir + "/selftest.jsonl";
    Tracer::instance().configure(cfg);
    CHECK(Tracer::instance().open("x", ""));
    CHECK_EQ(run_once(Mode::Compare), reference(64, 0x5eed));
    Tracer::instance().close();
    const int rc = tracetest::run_tracecmp(dir + "/selftest.jsonl");
    if (rc != tracetest::kSkipped) CHECK_EQ(rc, 0);
    return tracetest::finish("shim_trace_hook");
}