// bench.platform — implementation.
//
// `module bench.platform;` with no `export`: an implementation unit. The
// interface declares; the bodies live here, so nothing below reaches an
// importer's BMI. Everything the suite does to the OS still passes through this
// one module, and the `#if defined(...)` blocks the partitions cannot own — the
// architecture probe, and MSVC's getenv deprecation — stay confined to this
// file rather than spreading into runner or the engines.
//
// A module implementation unit implicitly imports its primary interface, so the
// `platform_impl::` names the :posix / :windows partitions export are visible.
module bench.platform;

import std;

namespace bench::platform {

ScopedEnv::ScopedEnv(std::string key, const std::string& value) : key_(std::move(key)) {
        // MSVC's CRT deprecates getenv in favour of _dupenv_s. Reading it is
        // safe here (single-threaded setup, value copied immediately) and the
        // portable spelling keeps this out of the platform partitions.
#if defined(_MSC_VER)
#pragma warning(suppress : 4996)
#endif
        if (const char* prev = std::getenv(key_.c_str())) {
            had_previous_ = true;
            previous_     = prev;
        }
        set_env(key_, value);
    }
    ScopedEnv::~ScopedEnv() {
        if (had_previous_) set_env(key_, previous_);
        else               unset_env(key_);
    }

bool RunResult::ok() const { return exit_code == 0; }

bool RunResult::started() const { return !launch_failed; }

RunResult run(const std::vector<std::string>& argv,
                     const std::filesystem::path&    cwd,
                     const std::filesystem::path&    log,
                     double                          timeout_s) {
    double wall = 0.0;
    bool   hung = false;
    std::string why;
    bool failed_to_launch = false;
    const int rc = run_process(argv, cwd, log, &wall, timeout_s, &hung, &why,
                               &failed_to_launch);
    return RunResult{wall, rc, hung, std::move(why), failed_to_launch};
}

bool log_mentions(const std::filesystem::path& p,
                         std::initializer_list<std::string_view> markers) {
    std::ifstream in(p, std::ios::binary);
    if (!in) return false;
    std::string line;
    while (std::getline(in, line))
        for (const auto m : markers)
            if (line.find(m) != std::string::npos) return true;
    return false;
}

std::string log_grep(const std::filesystem::path& p,
                            std::initializer_list<std::string_view> markers,
                            std::size_t max) {
    std::ifstream in(p, std::ios::binary);
    if (!in) return {};
    std::string out, line;
    std::size_t kept = 0;
    // ⚠️ THE MESSAGE IS OFTEN ON THE NEXT LINE. cmake writes
    //     CMake Error at xpkg_source_library.cmake:231 (message):
    //       bench: <pkg>'s manifest has no `sources` list
    // and a grep that returns only matching lines keeps the location and throws
    // away WHAT WENT WRONG. That happened three separate times today, each time
    // costing a round trip to CI for a sentence that was already in the file.
    // `after` carries the following lines of a hit through.
    std::size_t after = 0;
    while (kept < max && std::getline(in, line)) {
        if (!line.empty() && line.back() == '\r') line.pop_back();
        bool hit = false;
        for (const auto m : markers)
            if (line.find(m) != std::string::npos) { hit = true; break; }
        if (!hit) {
            if (after == 0 || line.empty()) continue;
            --after;                       // trailing context of the previous hit
        } else {
            after = 2;
        }
        // Long lines here are usually a whole compiler command line; the cause
        // is at the front of them.
        if (line.size() > 400) { line.resize(400); line += " …"; }
        out += "    "; out += line; out += '\n';
        ++kept;
    }
    return out;
}

std::string tail_of(const std::filesystem::path& p, std::size_t lines) {
    std::ifstream in(p, std::ios::binary);
    if (!in) return {};
    std::deque<std::string> keep;
    std::string line;
    while (std::getline(in, line)) {
        if (!line.empty() && line.back() == '\r') line.pop_back();
        keep.push_back(std::move(line));
        if (keep.size() > lines) keep.pop_front();
    }
    std::string out;
    for (const auto& l : keep) { out += l; out += '\n'; }
    return out;
}

bool have_program(const std::vector<std::string>& version_argv) {
    return run(version_argv).started();
}

std::optional<std::string> run_capture(const std::vector<std::string>& argv,
                                              const std::filesystem::path& cwd,
                                              RunResult* result) {
    std::error_code ec;
    auto tmp = std::filesystem::temp_directory_path(ec);
    if (ec) return std::nullopt;
    tmp /= std::format("bench-capture-{}.txt",
                       std::chrono::steady_clock::now().time_since_epoch().count());

    const auto r = run(argv, cwd, tmp);
    if (result) *result = r;
    if (!r.started()) { std::filesystem::remove(tmp, ec); return std::nullopt; }

    std::ifstream in(tmp, std::ios::binary);
    std::string text;
    if (in) text.assign((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
    in.close();
    std::filesystem::remove(tmp, ec);
    return text;
}

HostFacts host_facts() {
    HostFacts f;
    f.os             = std::string(OS_NAME);
    f.cpu_model      = platform_impl::cpu_model();
    f.logical_cores  = platform_impl::cpu_logical();
    f.physical_cores = platform_impl::cpu_physical();
    f.heterogeneous  = platform_impl::heterogeneous_cpu();
    f.ram_bytes      = platform_impl::ram_bytes();
    // Architecture, unlike the OS, is not a partition concern: both partitions
    // would carry an identical copy of this. It is a property of the build, so
    // it is detected once, here.
#if defined(__aarch64__) || defined(_M_ARM64)
    f.arch = "aarch64";
#elif defined(__x86_64__) || defined(_M_X64)
    f.arch = "x86_64";
#else
    f.arch = "unknown";
#endif
    return f;
}

void remove_tree(const std::filesystem::path& p) {
    std::error_code ec;
    std::filesystem::remove_all(p, ec);   // absent is success, not failure
}

bool touch(const std::filesystem::path& p) {
    std::error_code ec;
    if (!std::filesystem::exists(p, ec)) return false;
    std::filesystem::last_write_time(p, std::filesystem::file_time_type::clock::now(), ec);
    return !ec;
}

std::string iso_now() {
    return std::format("{:%FT%TZ}",
                       std::chrono::floor<std::chrono::seconds>(
                           std::chrono::system_clock::now()));
}

}  // namespace bench::platform