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

module Crafter.Review:OpenCode_impl;
import :OpenCode;
import :Json;
import :Text;
import :Platform;
import :Process;
import :Schema;
import std;

namespace fs = std::filesystem;

namespace Crafter::Review::OpenCode {
    namespace {
        // A JSON string literal: the descriptions and enum values go into the
        // TypeScript as one.
        std::string Literal(std::string_view text) {
            return DumpSpaced(Json(std::string(text)));
        }

        template <std::size_t N>
        std::string Enum(const std::array<std::string_view, N>& values) {
            std::vector<std::string> parts;
            for (const std::string_view v : values) parts.push_back(Literal(v));
            return std::format("z.enum([{}])", Dyn::Join(parts, ", "));
        }

        std::string Described(const Json& schema, std::string_view property) {
            return Literal(schema.at("properties").at(property).at("description").get<std::string>());
        }

        // The literal at `at`, its letters matched as re.IGNORECASE folds
        // them and everything else as it is.
        bool LiteralAt(const std::u32string& t, std::size_t at, std::string_view literal) {
            if (at + literal.size() > t.size()) return false;
            for (std::size_t i = 0; i < literal.size(); ++i) {
                const char c = literal[i];
                const bool letter = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
                if (letter ? Dyn::IgnoreCaseLetter(t[at + i]) != static_cast<char>(c | 0x20) : t[at + i] != static_cast<char32_t>(static_cast<std::uint8_t>(c))) return false;
            }
            return true;
        }

        bool Contains(const std::u32string& t, std::string_view literal) {
            for (std::size_t at = 0; at + literal.size() <= t.size(); ++at) {
                if (LiteralAt(t, at, literal)) return true;
            }
            return false;
        }

        // \b<digits>\b
        bool Number(const std::u32string& t, std::string_view digits) {
            for (std::size_t at = 0; at + digits.size() <= t.size(); ++at) {
                if (LiteralAt(t, at, digits) && (at == 0 || !Dyn::IsWord(t[at - 1])) && (at + digits.size() == t.size() || !Dyn::IsWord(t[at + digits.size()]))) return true;
            }
            return false;
        }

        // r'\b429\b|rate[ -]limit|temporarily rate-limited|engine_overloaded', re.I
        bool LimitText(const std::u32string& t) {
            return Number(t, "429") || Contains(t, "rate limit") || Contains(t, "rate-limit") || Contains(t, "temporarily rate-limited") || Contains(t, "engine_overloaded");
        }

        // r'\b402\b|insufficient credits|requires more credits|credit balance', re.I
        bool CreditText(const std::u32string& t) {
            return Number(t, "402") || Contains(t, "insufficient credits") || Contains(t, "requires more credits") || Contains(t, "credit balance");
        }

        // r'\b401\b|\b403\b|invalid.*(api key|token)|unauthori[sz]ed|No auth credentials', re.I
        bool AuthText(const std::u32string& t) {
            if (Number(t, "401") || Number(t, "403") || Contains(t, "unauthorised") || Contains(t, "unauthorized") || Contains(t, "no auth credentials")) return true;
            for (std::size_t at = 0; at + 7 <= t.size(); ++at) {
                if (!LiteralAt(t, at, "invalid")) continue;
                // `.*` runs to the end of the line.
                for (std::size_t j = at + 7; j < t.size(); ++j) {
                    if (LiteralAt(t, j, "api key") || LiteralAt(t, j, "token")) return true;
                    if (t[j] == U'\n') break;
                }
            }
            return false;
        }

        // `x.get(k, 0) or 0`
        Json Count(const Json& value) {
            return Dyn::Truthy(value) ? value : Json(0);
        }

        // The value as a float, 0 when it is falsy.
        double Num(const Json& value) {
            if (!Dyn::Truthy(value)) return 0.0;
            if (value.is_number()) return value.get<double>();
            if (value.is_boolean()) return 1.0;
            if (value.is_string()) {
                if (const std::optional<double> parsed = Dyn::ParseFloat(value.get_ref<const std::string&>())) return *parsed;
                throw Dyn::Error("ValueError", Dyn::FloatError(value.get_ref<const std::string&>()));
            }
            throw Dyn::Error("TypeError", std::format("float() argument must be a string or a real number, not '{}'", Dyn::TypeName(value)));
        }

        // The text a JSON object key is written as.
        std::string KeyText(const Json& key) {
            if (key.is_string()) return key.get<std::string>();
            return DumpCompact(key);
        }
    }

    Json Routing() {
        return {{"zdr", true}, {"data_collection", "deny"}, {"quantizations", {"fp8", "fp16", "bf16", "fp32"}}, {"sort", "price"}};
    }

    std::string DefaultBin() {
        const std::optional<std::string> configured = Platform::GetEnv("REVIEW_GATES_OPENCODE_BIN");
        return configured && !configured->empty() ? *configured : std::string("opencode");
    }

    std::pair<std::string, std::string> ModelId(std::string_view model) {
        const std::size_t slash = model.find('/');
        if (slash != std::string_view::npos && model.substr(0, slash) == "openrouter") return {std::string(model.substr(0, slash)), std::string(model.substr(slash + 1))};
        return {"openrouter", std::string(model)};
    }

    std::string ToolSource() {
        const Json finding = Schema::Finding();
        const Json note = Schema::Note();
        const Json coverage = Schema::Coverage();
        std::string out = "import { tool } from \"@opencode-ai/plugin\"\nimport * as fs from \"node:fs\"\nconst z = tool.schema\nconst Finding = z.object({\n";
        out += std::format("  finding: z.string().describe({}),\n", Described(finding, "finding"));
        out += std::format("  evidence: z.string().describe({}),\n", Described(finding, "evidence"));
        out += "  proposedAction: z.string(),\n";
        out += std::format("  items: z.array(z.string()).describe({}),\n", Described(finding, "items"));
        out += std::format("  dischargedBy: z.string().optional().describe({}),\n", Described(finding, "dischargedBy"));
        out += std::format("  contests: z.object({{ id: z.string(), why: z.string().describe({}) }}).strict().optional(),\n", Described(finding.at("properties").at("contests"), "why"));
        out += "}).strict()\nconst Note = z.object({\n";
        out += std::format("  kind: {},\n", Enum(Schema::NoteKinds));
        out += "  note: z.string(), evidence: z.string(),\n";
        out += std::format("  action: z.string().describe({}),\n", Described(note, "action"));
        out += std::format("  id: z.string().optional().describe({}),\n", Described(note, "id"));
        out += "  items: z.array(z.string()).optional(),\n}).strict()\nconst Coverage = z.object({\n";
        out += std::format("  item: z.string().describe({}),\n", Described(coverage, "item"));
        out += std::format("  verdict: {},\n", Enum(Schema::CoverageVerdicts));
        out += std::format("  basis: z.string().describe({}),\n", Described(coverage, "basis"));
        out += "}).strict()\nexport default tool({\n";
        out += "  description: \"Return the structured output your instructions describe: the verdict, findings, notes and coverage of this pass. Call it exactly once, as the last action of "
               "the pass, with the complete result; nothing you write as text counts.\",\n";
        out += "  args: {\n";
        out += std::format("    verdict: {}.describe({}),\n", Enum(Schema::VerdictEnum), Described(Schema::BlockSchema(), "verdict"));
        out += "    findings: z.array(Finding),\n    notes: z.array(Note),\n";
        out += "    coverage: z.array(Coverage).describe(\"block pass: exactly one entry, the unit this pass covers; whole pass: one entry per unit you were asked to cover\"),\n";
        out += std::format("    summary: z.string().optional().describe({}),\n", Described(Schema::WholeSchema(), "summary"));
        out += "  },\n  async execute(args) {\n";
        out += std::format("    const p = process.env.{}\n", SoEnv);
        out += "    if (p) fs.writeFileSync(p, JSON.stringify(args))\n    return \"Structured output provided successfully\"\n  },\n})\n";
        return out;
    }

    fs::path PrepareHome(const fs::path& scratch, const fs::path& repo, std::span<const std::string> models, const Json& routing) {
        const fs::path home = scratch / "opencode";
        const fs::path configDir = home / "xdg" / "opencode";
        Platform::MakeDirs(configDir / "tools", 0700);
        for (const std::string_view d : {"cache", "state", "data", "view"}) Platform::MakeDirs(home / d, 0700);
        const fs::path view = home / "view";
        std::vector<std::string> names;
        for (const fs::directory_entry& entry : fs::directory_iterator(repo)) names.push_back(entry.path().filename().string());
        std::ranges::sort(names);
        for (const std::string& name : names) {
            const fs::path link = view / name;
            if (std::ranges::contains(ViewSkip, name) || fs::is_symlink(fs::symlink_status(link))) continue;
            fs::create_symlink(repo / name, link);
        }
        Json provider = Json::object();
        for (const std::string& m : models) {
            const auto [prov, id] = ModelId(m);
            if (!provider.contains(prov)) provider[prov] = {{"models", Json::object()}};
            provider[prov]["models"][id] = {{"options", {{"provider", routing}}}};
        }
        const Json config = {{"$schema", "https://opencode.ai/config.json"}, {"autoupdate", false}, {"share", "disabled"}, {"provider", provider}};
        std::ofstream(configDir / "opencode.json", std::ios::binary | std::ios::trunc) << DumpFile(config);
        std::ofstream(configDir / "tools" / std::format("{}.ts", Tool), std::ios::binary | std::ios::trunc) << ToolSource();
        return home;
    }

    std::map<std::string, std::string> BaseEnv(const fs::path& home, std::string_view key, const std::optional<std::map<std::string, std::string>>& base) {
        std::map<std::string, std::string> env;
        for (const auto& [name, value] : base ? *base : Platform::Environment()) {
            if (name.starts_with("ANTHROPIC_") || name.starts_with("CLAUDE_") || name.starts_with("OPENCODE_") || name.starts_with("XDG_") || name == "OPENROUTER_API_KEY") continue;
            env[name] = value;
        }
        env["XDG_CONFIG_HOME"] = (home / "xdg").string();
        env["XDG_CACHE_HOME"] = (home / "cache").string();
        env["XDG_STATE_HOME"] = (home / "state").string();
        env["XDG_DATA_HOME"] = (home / "data").string();
        env["OPENROUTER_API_KEY"] = std::string(key);
        env["OPENCODE_DISABLE_AUTOUPDATE"] = "1";
        return env;
    }

    Json Permissions(std::span<const std::string> allowList) {
        Json bash = {{"*", "deny"}};
        Json perm = {{"*", "deny"}, {std::string(Tool), "allow"}, {"read", "deny"}, {"glob", "deny"}, {"grep", "deny"}, {"list", "allow"}, {"external_directory", "allow"}, {"bash", nullptr}};
        for (const std::string& a : allowList) {
            // re.match(r'^Bash\((.+):\*\)$', a): `.` stops at a line break,
            // `$` also matches before a final one.
            const std::string_view body = a.ends_with('\n') ? std::string_view(a).substr(0, a.size() - 1) : std::string_view(a);
            if (body.starts_with("Bash(") && body.ends_with(":*)") && body.size() > 8 && !body.substr(5, body.size() - 8).contains('\n')) {
                bash[std::format("{}*", body.substr(5, body.size() - 8))] = "allow";
            } else if (a == "Read" || a == "Glob" || a == "Grep") {
                perm[Dyn::Lower(a)] = "allow";
            } else if (a.starts_with("Read(")) {
                perm["read"] = "allow";
            }
        }
        perm["bash"] = std::move(bash);
        return perm;
    }

    std::map<std::string, std::string> ChildEnv(const std::map<std::string, std::string>& base, const fs::path& systemPath, const fs::path& soPath, std::span<const std::string> allowList,
                                                const fs::path& dataDir) {
        std::map<std::string, std::string> env = base;
        const Json agent = {{"mode", "primary"}, {"description", "review lens"}, {"prompt", std::format("{{file:{}}}", Dyn::AbsPath(systemPath.string()))}, {"permission", Permissions(allowList)}};
        env["OPENCODE_CONFIG_CONTENT"] = DumpCompact({{"agent", {{std::string(Agent), agent}}}});
        env[std::string(SoEnv)] = soPath.string();
        Platform::MakeDirs(dataDir, 0700);
        env["XDG_DATA_HOME"] = dataDir.string();
        return env;
    }

    std::vector<std::string> Cmd(std::string_view bin, std::string_view model, const fs::path& view, std::string_view title, std::string_view variant, std::string_view prompt) {
        std::vector<std::string> argv = {std::string(bin), "run", "--format", "json", "--model", std::string(model), "--agent", std::string(Agent), "--dir", view.string(), "--title", Dyn::Slice(title, 0, 80)};
        if (!variant.empty()) {
            argv.emplace_back("--variant");
            argv.emplace_back(variant);
        }
        argv.emplace_back("--");
        argv.emplace_back(prompt);
        return argv;
    }

    std::pair<bool, std::string> Warm(const std::string& bin, const fs::path& home, const std::map<std::string, std::string>& env, std::string_view model,
                                      const std::function<void(const std::string&)>& log, std::int64_t timeoutS) {
        std::map<std::string, std::string> e = env;
        const fs::path data = home / "data" / "warm";
        e["XDG_DATA_HOME"] = data.string();
        fs::create_directories(data);
        const fs::path view = home / "view";
        const std::vector<std::string> argv = {bin, "run", "--format", "json", "--model", std::string(model), "--dir", view.string(), "--title", "warm-up", "--", "Reply with the single word ok."};
        // Under the supervisor: what the warm-up starts goes with it, a
        // timeout included.
        const Process::Captured run = Process::Run(Process::Supervised(argv), view, std::chrono::seconds(timeoutS), {}, e);
        if (run.timedOut) return {false, std::format("warm-up timed out after {} s", timeoutS)};
        const std::int32_t code = Process::SupervisedReturnCode(run.returnCode);
        const Json parsed = ParseEvents(Dyn::UniversalNewlines(Dyn::DecodeReplace(run.out)));
        const Json& errors = parsed.at("errors");
        const bool ok = code == 0 && parsed.at("turns").get<std::int64_t>() > 0 && errors.empty();
        Json firstErrors = Json::array();
        for (std::size_t i = 0; i < std::min<std::size_t>(2, errors.size()); ++i) firstErrors.push_back(errors.at(i));
        log(std::format("opencode: warm-up {} ({} step(s), cost ${:.4f}, exit {}{})", ok ? "ok" : "FAILED", parsed.at("turns").get<std::int64_t>(), Num(parsed.at("costUsd")), code,
                        errors.empty() ? std::string() : std::format(", errors {}", Dyn::ReprValue(firstErrors))));
        return {ok, Dyn::Slice(Dyn::UniversalNewlines(Dyn::DecodeReplace(run.err)), -800)};
    }

    Json ParseEvents(std::string_view text, const std::optional<fs::path>& soPath) {
        Json usage = {{"input", 0}, {"cacheCreation", 0}, {"cacheRead", 0}, {"output", 0}, {"thinking", 0}};
        std::int64_t turns = 0;
        double cost = 0.0;
        Json toolCalls = Json::object();
        std::int64_t toolErrors = 0;
        Json errors = Json::array();
        Json structured;
        Json sessionId;
        Json first;
        Json stop;
        for (const std::string& raw : Dyn::SplitLines(text)) {
            const std::string line = Dyn::Strip(raw);
            if (!line.starts_with('{') || Dyn::JsonDecodeError(line)) continue;
            Json o;
            try {
                o = ParseLoose(line);
            } catch (const std::exception&) {
                // NaN or Infinity, which nlohmann refuses (AGENTS.md): the line
                // is skipped.
                continue;
            }
            const Json& type = Dyn::Get(o, "type");
            const Json& rawPart = Dyn::Get(o, "part");
            const Json& part = rawPart.is_object() ? rawPart : Dyn::EmptyDict();
            if (!Dyn::Truthy(sessionId)) sessionId = Dyn::Get(o, "sessionID");
            if (type == "step_finish") {
                const Json& tokens = Dyn::Or(Dyn::Get(part, "tokens"), Dyn::EmptyDict());
                const Json& cache = Dyn::Or(Dyn::Get(tokens, "cache"), Dyn::EmptyDict());
                ++turns;
                usage["input"] = Dyn::Add(usage.at("input"), Count(Dyn::Get(tokens, "input")));
                usage["output"] = Dyn::Add(usage.at("output"), Count(Dyn::Get(tokens, "output")));
                usage["thinking"] = Dyn::Add(usage.at("thinking"), Count(Dyn::Get(tokens, "reasoning")));
                usage["cacheRead"] = Dyn::Add(usage.at("cacheRead"), Count(Dyn::Get(cache, "read")));
                usage["cacheCreation"] = Dyn::Add(usage.at("cacheCreation"), Count(Dyn::Get(cache, "write")));
                cost += Num(Dyn::Get(part, "cost"));
                stop = Dyn::Get(part, "reason");
                if (first.is_null()) {
                    first = {{"input_tokens", Count(Dyn::Get(tokens, "input"))},
                             {"cache_creation_input_tokens", Count(Dyn::Get(cache, "write"))},
                             {"cache_read_input_tokens", Count(Dyn::Get(cache, "read"))},
                             {"output_tokens", Count(Dyn::Get(tokens, "output"))}};
                }
            } else if (Dyn::Get(part, "type") == "tool") {
                const Json& name = Dyn::Get(part, "tool");
                const Json& state = Dyn::Or(Dyn::Get(part, "state"), Dyn::EmptyDict());
                const std::string key = KeyText(name);
                toolCalls[key] = Dyn::Add(Dyn::Has(toolCalls, key) ? toolCalls.at(key) : Json(0), Json(1));
                if (Dyn::Get(state, "status") == "error") ++toolErrors;
                if (name.is_string() && name.get_ref<const std::string&>() == Tool && Dyn::Get(state, "status") == "completed" && Dyn::Get(state, "input").is_object()) structured = state.at("input");
            } else if (type == "error") {
                const Json& error = Dyn::Get(o, "error");
                errors.push_back(Dyn::Slice(DumpSpaced(Dyn::Truthy(error) ? error : o), 0, 300));
            }
        }
        if (structured.is_null() && soPath && !soPath->empty() && fs::exists(*soPath)) {
            try {
                structured = Dyn::LoadJsonFile(*soPath);
            } catch (const std::exception&) {
                structured = nullptr;
            }
        }
        // Reasoning tokens are output tokens OpenCode counts apart; the claude
        // harness counts them inside output.
        usage["output"] = Dyn::Add(usage.at("output"), usage.at("thinking"));
        const bool result = structured.is_object() && Dyn::Get(structured, "findings").is_array();
        return {
            {"usage", usage},
            {"turns", turns},
            {"costUsd", cost != 0 ? Json(cost) : Json()},
            {"toolCalls", toolCalls},
            {"toolErrors", toolErrors},
            {"errors", errors},
            {"structured", result ? structured : Json()},
            {"sessionId", sessionId},
            {"firstTurn", first},
            {"stop", stop},
        };
    }

    std::pair<std::string, std::string> Classify(const Json& parsed, std::int64_t exitCode, std::string_view stderrText, bool timedOut) {
        if (timedOut || exitCode == 124) return {"timeout", "process exceeded its time budget"};
        const Json& errors = Dyn::At(parsed, "errors");
        std::vector<std::string> texts;
        for (const Json& e : errors) texts.push_back(Dyn::Str(e));
        const std::string text = std::format("{} {}", Dyn::Join(texts, " "), Dyn::Slice(stderrText, -2000));
        if (!Dyn::At(parsed, "structured").is_null()) return {"ok", ""};
        const std::u32string t = Dyn::Decode(text);
        const std::string reason = Dyn::Slice(Dyn::Strip(text), 0, 200);
        if (CreditText(t)) return {"credits", reason};
        if (AuthText(t)) return {"auth", reason};
        if (LimitText(t)) return {"limit", reason};
        if (!errors.empty()) return {"error", std::format("opencode error: {}", Dyn::Slice(Dyn::Str(errors.at(0)), 0, 200))};
        if (Dyn::At(parsed, "turns") == 0) return {"error", std::format("no step finished (exit {}): {}", exitCode, Dyn::Slice(Dyn::Strip(stderrText), -200))};
        return {"error", std::format("no {} call in the process ({} steps, stop {})", Tool, Dyn::Str(parsed.at("turns")), Dyn::Str(Dyn::Get(parsed, "stop")))};
    }
}