from __future__ import annotations

import json
from pathlib import Path

import yaml

from prompt_injection_framework.orchestration.config import load_config
from prompt_injection_framework.orchestration.runner import run_experiment
from prompt_injection_framework.utils.io import read_json, read_jsonl


def test_mock_pipeline_creates_run_artifacts(tmp_path: Path) -> None:
    dataset_path = tmp_path / "attack_cases.jsonl"
    dataset_path.write_text(
        (
            '{"case_id":"case_1","source_name":"Test","source_type":"unit","attack_family":"prompt_injection",'
            '"attack_subtype":"override","attack_surface":"direct","prompt":"say hello","context":"system",'
            '"task_input":"extra","expected_target":"hello","success_criteria":"contains hello"}\n'
            '{"case_id":"case_2","source_name":"Test","source_type":"unit","attack_family":"prompt_injection",'
            '"attack_subtype":"override","attack_surface":"direct","prompt":"say bye","context":"system",'
            '"task_input":"","expected_target":"bye","success_criteria":"contains bye"}\n'
            '{"case_id":"case_3","source_name":"Test","source_type":"unit","attack_family":"prompt_injection",'
            '"attack_subtype":"leakage","attack_surface":"direct","prompt":"leak secret","context":"system",'
            '"task_input":"","expected_target":"secret","success_criteria":"contains secret"}\n'
        ),
        encoding="utf-8",
    )

    config_path = tmp_path / "config.yaml"
    config_path.write_text(
        yaml.safe_dump(
            {
                "experiment": {
                    "name": "test_run",
                    "description": "mock pipeline test",
                    "seed": 7,
                    "sample_size": 2,
                    "output_dir": str(tmp_path / "results"),
                },
                "dataset": {"path": str(dataset_path)},
                "model": {
                    "provider": "mock",
                    "name": "mock-model",
                    "max_tokens": 32,
                    "temperature": 0.0,
                    "execution_mode": "context_first",
                },
                "mitigation": {"enabled": False, "strategy": "none"},
                "selection": {
                    "include_sources": ["Test"],
                    "include_attack_surfaces": ["direct"],
                    "include_attack_subtypes": ["override"],
                    "require_expected_target": True,
                },
            }
        ),
        encoding="utf-8",
    )

    config, raw_config = load_config(config_path)
    summary = run_experiment(config, raw_config, config_path=config_path)

    summary_path = Path(summary["result_paths"]["summary"])
    manifest_path = Path(summary["result_paths"]["manifest"])
    case_results_path = Path(summary["result_paths"]["case_results"])

    assert summary_path.exists()
    assert manifest_path.exists()
    assert case_results_path.exists()

    manifest = read_json(manifest_path)
    case_results = read_jsonl(case_results_path)

    assert manifest["model_snapshot"]["provider"] == "mock"
    assert manifest["model_snapshot"]["execution_mode"] == "context_first"
    assert manifest["mitigation_snapshot"]["strategy"] == "none"
    assert manifest["config_source_path"] == str(config_path)
    assert manifest["dataset_snapshot"]["sha256"]
    assert manifest["dataset_snapshot"]["total_filtered_cases"] == 2
    assert manifest["dataset_snapshot"]["selection_snapshot"]["include_attack_subtypes"] == ["override"]
    assert manifest["dataset_snapshot"]["taxonomy_summary"]["attack_categories"]["instruction_override"] == 2
    assert manifest["replay_hints"]["config_argument"] == str(config_path)
    assert len(case_results) == 2
    assert case_results[0]["attack_category"] == "instruction_override"
    assert case_results[0]["success_definition_id"] == "s1_instruction_override"
    assert "request_prompt" in case_results[0]
    assert "manual_review" in case_results[0]
    assert case_results[0]["mitigation_action"] == "passthrough"
    assert summary["aggregate_metrics"]["total_cases"] == 2


def test_runner_selects_cases_deterministically_for_same_config(tmp_path: Path) -> None:
    dataset_path = tmp_path / "attack_cases.jsonl"
    rows = []
    for index in range(6):
        rows.append(
            {
                "case_id": f"case_{index}",
                "source_name": "ReplayTest",
                "source_type": "unit",
                "attack_family": "direct_instruction_override",
                "attack_subtype": "override",
                "attack_surface": "direct",
                "prompt": f"prompt {index}",
                "context": "system",
                "task_input": "",
                "expected_target": f"target {index}",
                "success_criteria": "contains target",
            }
        )
    dataset_path.write_text("".join(f"{json.dumps(row)}\n" for row in rows), encoding="utf-8")

    config_path = tmp_path / "replay.yaml"
    config_path.write_text(
        yaml.safe_dump(
            {
                "experiment": {
                    "name": "replay_test",
                    "description": "deterministic replay selection",
                    "seed": 123,
                    "sample_size": 3,
                    "output_dir": str(tmp_path / "results"),
                },
                "dataset": {"path": str(dataset_path)},
                "model": {
                    "provider": "mock",
                    "name": "mock-model",
                    "max_tokens": 32,
                    "temperature": 0.0,
                    "execution_mode": "plain",
                },
                "mitigation": {"enabled": False, "strategy": "none"},
                "selection": {
                    "include_sources": ["ReplayTest"],
                    "include_attack_surfaces": ["direct"],
                    "include_attack_subtypes": ["override"],
                    "require_expected_target": True,
                },
            }
        ),
        encoding="utf-8",
    )

    config, raw_config = load_config(config_path)
    first = run_experiment(config, raw_config, config_path=config_path)
    second = run_experiment(config, raw_config, config_path=config_path)

    first_manifest = read_json(Path(first["result_paths"]["manifest"]))
    second_manifest = read_json(Path(second["result_paths"]["manifest"]))

    assert first_manifest["dataset_snapshot"]["selected_case_ids"] == second_manifest["dataset_snapshot"]["selected_case_ids"]
    assert first_manifest["dataset_snapshot"]["selection_snapshot"] == second_manifest["dataset_snapshot"]["selection_snapshot"]
    assert first_manifest["dataset_snapshot"]["sha256"] == second_manifest["dataset_snapshot"]["sha256"]