from __future__ import annotations

import json
from pathlib import Path

from scripts import gcp_resume_state


def _scenario(path: Path, scenario_id: str = "SGT-001") -> Path:
    path.write_text(
        json.dumps({"id": scenario_id, "text": "test prompt"}) + "\n",
        encoding="utf-8",
    )
    return path


def _trial(path: Path, *, success: bool | None = True, answer: str = "done") -> Path:
    payload = {"answer": answer, "history": []}
    if success is not None:
        payload["success"] = success
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload) + "\n", encoding="utf-8")
    return path


def _latency(
    path: Path, scenario_file: Path, trial_index: int, output_path: Path
) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("a", encoding="utf-8") as fh:
        fh.write(
            json.dumps(
                {
                    "scenario_file": scenario_file.as_posix(),
                    "trial_index": trial_index,
                    "latency_seconds": 1.25,
                    "output_path": output_path.as_posix(),
                }
            )
            + "\n"
        )


def _classify(
    tmp_path: Path,
    scenario_file: Path,
    output_path: Path,
    *,
    require_latency: bool = True,
) -> dict:
    return gcp_resume_state.classify_trial(
        run_dir=tmp_path,
        scenario_file=scenario_file,
        trial_index=1,
        output_path=output_path,
        latency_file=tmp_path / "latencies.jsonl",
        require_latency=require_latency,
    )


def test_completed_success_is_terminal_with_latency(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = _trial(tmp_path / "2026-05-03_Y_multi_01_run01.json", success=True)
    _latency(tmp_path / "latencies.jsonl", scenario_file, 1, output)

    result = _classify(tmp_path, scenario_file, output)

    assert result["state"] == "complete_success"
    assert result["complete"] is True
    assert result["success"] is True


def test_completed_failure_is_terminal_and_skippable(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = _trial(tmp_path / "2026-05-03_Y_multi_01_run01.json", success=False)
    _latency(tmp_path / "latencies.jsonl", scenario_file, 1, output)

    result = _classify(tmp_path, scenario_file, output)

    assert result["state"] == "complete_failure"
    assert result["complete"] is True
    assert result["success"] is False


def test_missing_latency_keeps_valid_json_incomplete_by_default(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = _trial(tmp_path / "2026-05-03_Y_multi_01_run01.json", success=True)

    result = _classify(tmp_path, scenario_file, output)

    assert result["state"] == "incomplete"
    assert "missing_latency" in result["reason"]


def test_invalid_json_is_incomplete(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = tmp_path / "2026-05-03_Y_multi_01_run01.json"
    output.write_text("{not-json", encoding="utf-8")

    result = _classify(tmp_path, scenario_file, output, require_latency=False)

    assert result["state"] == "incomplete"
    assert "invalid_json" in result["reason"]


def test_legacy_stdout_next_to_terminal_json_is_not_dangling(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = _trial(tmp_path / "legacy_multi_01_run01.json", success=True)
    output.with_suffix(output.suffix + ".stdout").write_text(
        "legacy log\n", encoding="utf-8"
    )
    _latency(tmp_path / "latencies.jsonl", scenario_file, 1, output)
    newer_name = tmp_path / "2026-05-04_Y_multi_01_run01.json"

    result = _classify(tmp_path, scenario_file, newer_name)

    assert result["state"] == "complete_success"
    assert result["output_path"] == output.as_posix()


def test_conflicting_duplicate_latency_rows_are_incomplete(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = _trial(tmp_path / "2026-05-03_Y_multi_01_run01.json", success=True)
    rows = [
        {
            "scenario_file": scenario_file.as_posix(),
            "trial_index": 1,
            "latency_seconds": 1.0,
            "output_path": output.as_posix(),
        },
        {
            "scenario_file": scenario_file.as_posix(),
            "trial_index": 1,
            "latency_seconds": 2.0,
            "output_path": output.as_posix(),
        },
    ]
    (tmp_path / "latencies.jsonl").write_text(
        "".join(json.dumps(row) + "\n" for row in rows),
        encoding="utf-8",
    )

    result = _classify(tmp_path, scenario_file, output)

    assert result["state"] == "incomplete"
    assert "duplicate_conflicting_latency" in result["reason"]


def test_finalize_trial_writes_atomic_output_latency_and_manifest(
    tmp_path: Path,
) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    temp_output = _trial(tmp_path / "run" / "trial.json.tmp", success=None)
    output = tmp_path / "run" / "trial.json"
    latency_file = tmp_path / "run" / "latencies.jsonl"
    manifest_file = tmp_path / "run" / "resume_manifest.jsonl"

    result = gcp_resume_state.finalize_trial(
        scenario_file=scenario_file,
        trial_index=1,
        temp_output=temp_output,
        output_path=output,
        latency_file=latency_file,
        manifest_file=manifest_file,
        run_name="resume-smoke",
        batch_id="batch-1",
        start_epoch=10.0,
        end_epoch=12.5,
        return_code=0,
    )

    assert result["state"] == "complete_success"
    assert output.exists()
    assert not temp_output.exists()
    payload = json.loads(output.read_text(encoding="utf-8"))
    assert payload["scenario"]["id"] == "SGT-001"
    assert payload["success"] is True
    latency_rows = [json.loads(line) for line in latency_file.read_text().splitlines()]
    assert latency_rows == [
        {
            "latency_seconds": 2.5,
            "output_path": output.as_posix(),
            "scenario_file": scenario_file.as_posix(),
            "trial_index": 1,
        }
    ]
    manifest_rows = [
        json.loads(line)
        for line in manifest_file.read_text(encoding="utf-8").splitlines()
    ]
    assert manifest_rows[-1]["state"] == "complete_success"
    assert manifest_rows[-1]["batch_id"] == "batch-1"
    assert "runtime_versions" in manifest_rows[-1]


def test_finalize_trial_marks_divergent_rerun(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")
    output = tmp_path / "run" / "trial.json"
    latency_file = tmp_path / "run" / "latencies.jsonl"
    manifest_file = tmp_path / "run" / "resume_manifest.jsonl"
    first_temp = _trial(tmp_path / "run" / "trial-first.json.tmp", answer="first")
    second_temp = _trial(tmp_path / "run" / "trial-second.json.tmp", answer="second")

    gcp_resume_state.finalize_trial(
        scenario_file=scenario_file,
        trial_index=1,
        temp_output=first_temp,
        output_path=output,
        latency_file=latency_file,
        manifest_file=manifest_file,
        run_name="resume-smoke",
        batch_id="batch-1",
        start_epoch=10.0,
        end_epoch=12.5,
        return_code=0,
    )

    gcp_resume_state.finalize_trial(
        scenario_file=scenario_file,
        trial_index=1,
        temp_output=second_temp,
        output_path=output,
        latency_file=latency_file,
        manifest_file=manifest_file,
        run_name="resume-smoke",
        batch_id="batch-1",
        start_epoch=20.0,
        end_epoch=23.0,
        return_code=0,
    )

    manifest_rows = [
        json.loads(line)
        for line in manifest_file.read_text(encoding="utf-8").splitlines()
    ]
    rerun = manifest_rows[-1]
    assert rerun["divergent"] is True
    assert rerun["original_output_sha256"] != rerun["final_output_sha256"]


def test_validate_run_artifacts_flags_missing_outputs(tmp_path: Path) -> None:
    scenario_file = _scenario(tmp_path / "multi_01.json")

    result = gcp_resume_state.validate_run_artifacts(
        run_dir=tmp_path / "run",
        scenario_glob=scenario_file.as_posix(),
        trials=1,
        run_name="batch_Y",
        require_latency=True,
    )

    assert result["valid"] is False
    assert result["expected"] == 1
    assert result["complete"] == 0
    assert result["reason"] == "incomplete_trajectory_artifacts"
    assert result["missing"][0]["reason"] == "missing_json"


def test_validate_run_artifacts_counts_terminal_failures_as_complete(
    tmp_path: Path,
) -> None:
    scenarios_dir = tmp_path / "scenarios"
    scenarios_dir.mkdir()
    scenario_file = _scenario(scenarios_dir / "multi_01.json")
    run_dir = tmp_path / "run"
    run_name = "batch_Y"
    success_output = _trial(
        run_dir / f"{run_name}_multi_01_run01.json",
        success=True,
    )
    failure_output = _trial(
        run_dir / f"{run_name}_multi_01_run02.json",
        success=False,
    )
    _latency(run_dir / "latencies.jsonl", scenario_file, 1, success_output)
    _latency(run_dir / "latencies.jsonl", scenario_file, 2, failure_output)

    result = gcp_resume_state.validate_run_artifacts(
        run_dir=run_dir,
        scenario_glob=scenario_file.as_posix(),
        trials=2,
        run_name=run_name,
        require_latency=True,
    )

    assert result["valid"] is True
    assert result["expected"] == 2
    assert result["complete"] == 2
    assert result["success"] == 1
    assert result["failure"] == 1
    assert result["missing"] == []


def test_validate_run_artifacts_accepts_space_separated_scenario_list(
    tmp_path: Path,
) -> None:
    scenarios_dir = tmp_path / "scenarios"
    scenarios_dir.mkdir()
    first_scenario = _scenario(scenarios_dir / "multi_01.json", "SGT-001")
    second_scenario = _scenario(scenarios_dir / "wo_04.json", "SGT-018")
    run_dir = tmp_path / "run"
    run_name = "batch_Y"

    first_output = _trial(
        run_dir / f"{run_name}_multi_01_run01.json",
        success=True,
    )
    second_output = _trial(
        run_dir / f"{run_name}_wo_04_run01.json",
        success=True,
    )
    _latency(run_dir / "latencies.jsonl", first_scenario, 1, first_output)
    _latency(run_dir / "latencies.jsonl", second_scenario, 1, second_output)

    result = gcp_resume_state.validate_run_artifacts(
        run_dir=run_dir,
        scenario_glob=f"{first_scenario.as_posix()} {second_scenario.as_posix()}",
        trials=1,
        run_name=run_name,
        require_latency=True,
    )

    assert result["valid"] is True
    assert result["expected"] == 2
    assert result["complete"] == 2
    assert result["missing"] == []