"""End-to-end harness behaviour: dataset loading, run loop, reporting, failures."""

from __future__ import annotations

import json

from tooluse1.cases_build import build
from tooluse1.harness import load_cases, run_cases, slugify
from tooluse1.report import build_report, leaderboard_row, render_markdown
from tooluse1.runners import FencedRunner, NullRunner, OracleRunner, Prompt, Runner


class ExplodingRunner(Runner):
    name = "exploding"

    def complete(self, prompt: Prompt) -> str:
        raise RuntimeError("connection reset")


def test_dataset_matches_builder():
    cases = load_cases()
    assert [case.id for case in cases] == [case.id for case in build()]
    assert len(cases) == len(build())


def test_filters():
    assert all(case.lang == "en" for case in load_cases(langs=["en"]))
    assert all(case.category == "negative" for case in load_cases(categories=["negative"]))
    assert len(load_cases(limit=5)) == 5


def test_oracle_runner_is_perfect_on_a_subset():
    cases = load_cases(limit=24)
    results = run_cases(cases, OracleRunner(), protocols=("json",))
    summary = build_report(results, model_id="oracle")["summary"]
    assert summary["overall"]["score"] == 1.0


def test_parse_stress_runners_are_perfect():
    cases = load_cases(limit=24)
    for runner in (FencedRunner(),):
        results = run_cases(cases, runner, protocols=("json", "xml", "plain"))
        assert build_report(results, model_id=runner.name)["summary"]["overall"]["score"] == 1.0


def test_null_runner_abstains_on_everything():
    results = run_cases(load_cases(limit=40), NullRunner(), protocols=("json",))
    summary = build_report(results, model_id="null")["summary"]["overall"]
    assert summary["correct_call_when_expected"] == 0.0
    assert summary["spurious_call_rate"] == 0.0


def test_runner_errors_become_failed_cases():
    results = run_cases(load_cases(limit=10), ExplodingRunner(), protocols=("json",))
    assert results
    assert all(not result.passed for result in results)
    assert all("runner error" in result.detail for result in results)


def test_run_records_protocol_and_language_dimensions():
    results = run_cases(load_cases(limit=12), OracleRunner(), protocols=("json", "xml"))
    summary = build_report(results, model_id="oracle")["summary"]
    assert set(summary["by_protocol"]) == {"json", "xml"}
    assert summary["n_cases"] == 24


def test_skip_set_is_honoured():
    cases = load_cases(limit=6)
    skip = {(case.id, "json") for case in cases}
    results = run_cases(cases, OracleRunner(), protocols=("json",), skip=skip)
    assert results == []


def test_report_markdown_mentions_metrics():
    results = run_cases(load_cases(limit=18), OracleRunner(), protocols=("json",))
    report = build_report(results, model_id="HardcoreAI/Nova-1.1-0.8B", protocol="json")
    markdown = render_markdown(report["summary"], report)
    assert "HardcoreAI/Nova-1.1-0.8B" in markdown
    assert "Spurious-call rate" in markdown
    assert "By category" in markdown


def test_leaderboard_row_shape():
    results = run_cases(load_cases(limit=18), OracleRunner(), protocols=("json",))
    report = build_report(results, model_id="oracle", protocol="json")
    row = leaderboard_row(report, "oracle", link="https://example.invalid", protocol="json")
    assert row["score"] == 1.0
    assert row["n_cases"] == 18
    assert len(row["score_ci95"]) == 2


def test_slugify_is_filesystem_safe():
    assert slugify("HardcoreAI/Nova-1.1-0.8B") == "HardcoreAI__Nova-1.1-0.8B"


def test_scripted_runner_overrides_specific_cases():
    from tooluse1.runners import ScriptedRunner

    cases = load_cases(limit=3)
    overrides = {cases[0].id: '{"name": "calculator", "arguments": {"expression": "1+1"}}'}
    results = run_cases(cases, ScriptedRunner(overrides), protocols=("json",))
    assert len(results) == 3
    assert results[0].called and results[0].output == overrides[cases[0].id]
    assert not results[1].called


def test_unknown_backend_is_rejected():
    import pytest

    from tooluse1.runners import build_runner

    with pytest.raises(ValueError):
        build_runner("does-not-exist", model="x")


class BatchRecordingRunner(OracleRunner):
    """Records the batch shape it was asked for, and can poison one batch."""

    name = "recording"

    def __init__(self, poison_at: int | None = None):
        self.batches: list[int] = []
        self._poison_at = poison_at
        self.calls = 0

    def complete_many(self, prompts):
        self.calls += 1
        self.batches.append(len(prompts))
        if self._poison_at is not None and self.calls == self._poison_at:
            raise RuntimeError("simulated CUDA OOM on a batch")
        return [super(BatchRecordingRunner, self).complete(prompt) for prompt in prompts]


def test_batching_splits_into_batch_sized_chunks():
    cases = load_cases(limit=10)
    runner = BatchRecordingRunner()
    results = run_cases(cases, runner, protocols=("json",), batch_size=4)
    assert runner.batches == [4, 4, 2]
    assert len(results) == 10
    assert all(result.passed for result in results)


def test_batched_and_unbatched_agree():
    cases = load_cases(limit=12)
    batched = run_cases(cases, OracleRunner(), protocols=("json", "xml"), batch_size=5)
    single = run_cases(cases, OracleRunner(), protocols=("json", "xml"), batch_size=1)
    assert [(r.case_id, r.protocol, r.passed) for r in batched] == [(r.case_id, r.protocol, r.passed) for r in single]


def test_poisoned_batch_falls_back_to_single_calls():
    cases = load_cases(limit=8)
    runner = BatchRecordingRunner(poison_at=1)
    results = run_cases(cases, runner, protocols=("json",), batch_size=4)
    assert len(results) == 8
    assert all(result.passed for result in results), "per-item fallback must recover the batch"
    assert runner.batches[0] == 4


def test_batch_size_is_capped_by_remaining_cases():
    cases = load_cases(limit=3)
    runner = BatchRecordingRunner()
    run_cases(cases, runner, protocols=("json",), batch_size=16)
    assert runner.batches == [3]