"""Git Baseline Book and target loading.

Baseline Books are compact committed summaries (ADR-0006). Targets are the

red/green contract for scorecards (ADR-0008). Both are JSON here so the

harness stays stdlib-only.

"""

from __future__ import annotations

import json

import hashlib

from dataclasses import dataclass

from datetime import datetime, timezone

from pathlib import Path

from typing import Any

from oakbench.rows import number_or_none, output_bytes, row_returncode, token_total, tool_calls

from oakbench.stats import bootstrap_ci, named_statistic

from oakbench.populations import comparison_identity, independent_run_count, population_conflicts

@dataclass(frozen=True)

class BaselineCell:

    lane: str

    profile: str | None

    scenario: str

    operation: str

    subject: str

    metric: str

    statistic: str

    value: float

    ci_low: float | None = None

    ci_high: float | None = None

    n: int | None = None

    noise_floor_pct: float | None = None

    comparison_identity: dict[str, Any] | None = None

    independent_n: int | None = None

    attempted_n: int | None = None

    failure_n: int | None = None

    skipped_n: int | None = None

    @property

    def key(self) -> tuple[str, str | None, str, str, str, str, str]:

        return (self.lane, self.profile, self.scenario, self.operation, self.subject, self.metric, self.statistic)

@dataclass(frozen=True)

class Target:

    target_id: str

    lane: str

    profile: str | None

    scenario: str

    operation: str

    subject: str

    comparator: str

    metric: str

    statistic: str

    goal_type: str

    goal_value: float

    guards: dict[str, Any]

    @property

    def baseline_key(self) -> tuple[str, str | None, str, str, str, str, str]:

        return (self.lane, self.profile, self.scenario, self.operation, self.comparator, self.metric, self.statistic)

def load_baseline_book(path: Path) -> dict[tuple[str, str | None, str, str, str, str, str], BaselineCell]:

    raw = json.loads(path.read_text())

    if raw.get("schema_version") not in (1, 2):

        raise ValueError(f"unsupported baseline book schema_version: {raw.get('schema_version')!r}")

    cells = raw.get("cells")

    if not isinstance(cells, list):

        raise ValueError("baseline book requires list-valued 'cells'")

    parsed = [_parse_cell(cell) for cell in cells]

    result = {}

    for cell in parsed:

        if cell.key in result:

            raise ValueError(f"duplicate baseline cell: {cell.key}")

        result[cell.key] = cell

    return result

def _parse_cell(cell: dict[str, Any]) -> BaselineCell:

    required = ("lane", "scenario", "operation", "subject", "metric", "statistic", "value")

    missing = [key for key in required if key not in cell]

    if missing:

        raise ValueError(f"baseline cell missing keys: {', '.join(missing)}")

    identity = cell.get("comparison_identity")

    if identity is not None and (not isinstance(identity, dict) or identity.get("schema_version") != 1):

        raise ValueError("unsupported baseline comparison_identity")

    return BaselineCell(

        lane=str(cell["lane"]),

        profile=None if cell.get("profile") is None else str(cell.get("profile")),

        scenario=str(cell["scenario"]),

        operation=str(cell["operation"]),

        subject=str(cell["subject"]),

        metric=str(cell["metric"]),

        statistic=str(cell["statistic"]),

        value=float(cell["value"]),

        ci_low=_optional_float(cell.get("ci_low")),

        ci_high=_optional_float(cell.get("ci_high")),

        n=_optional_int(cell.get("n")),

        noise_floor_pct=_optional_float(cell.get("noise_floor_pct")),

        comparison_identity=identity,

        independent_n=_optional_int(cell.get("independent_n")),

        attempted_n=_optional_int(cell.get("attempted_n")),

        failure_n=_optional_int(cell.get("failure_n")),

        skipped_n=_optional_int(cell.get("skipped_n")),

    )

def load_targets(path: Path) -> list[Target]:

    raw = json.loads(path.read_text())

    if raw.get("schema_version") != 1:

        raise ValueError(f"unsupported targets schema_version: {raw.get('schema_version')!r}")

    targets = raw.get("targets")

    if not isinstance(targets, list):

        raise ValueError("targets config requires list-valued 'targets'")

    return [_parse_target(target) for target in targets]

def _parse_target(target: dict[str, Any]) -> Target:

    required = ("id", "lane", "scenario", "operation", "subject", "comparator", "metric", "goal")

    missing = [key for key in required if key not in target]

    if missing:

        raise ValueError(f"target missing keys: {', '.join(missing)}")

    goal = target["goal"]

    if not isinstance(goal, dict):

        raise ValueError(f"target {target.get('id')!r} goal must be an object")

    if "type" not in goal:

        raise ValueError(f"target {target.get('id')!r} goal requires a 'type' field")

    goal_type = str(goal["type"])

    if goal_type != "ratio_at_most":

        raise ValueError(f"target {target.get('id')!r} unsupported goal type {goal_type!r}")

    if number_or_none(goal.get("value")) is None:

        raise ValueError(f"target {target.get('id')!r} goal requires a numeric 'value' field")

    guards = target.get("guards", {})

    if not isinstance(guards, dict):

        raise ValueError(f"target {target.get('id')!r} guards must be an object")

    return Target(

        target_id=str(target["id"]),

        lane=str(target["lane"]),

        profile=None if target.get("profile") is None else str(target.get("profile")),

        scenario=str(target["scenario"]),

        operation=str(target["operation"]),

        subject=str(target["subject"]),

        comparator=str(target["comparator"]),

        metric=str(target["metric"]),

        statistic=str(target.get("statistic", "median")),

        goal_type=goal_type,

        goal_value=float(goal["value"]),

        guards=guards,

    )

def _optional_float(value: Any) -> float | None:

    if value is None:

        return None

    return float(value)

def _optional_int(value: Any) -> int | None:

    if value is None:

        return None

    if isinstance(value, bool):

        raise ValueError("boolean is not an integer")

    return int(value)

DEFAULT_BASELINE_METRICS = ("elapsed_ms", "tokens", "tool_calls", "output_bytes")

DEFAULT_BASELINE_STATISTICS = ("median", "mean")

SUBOP_SUFFIXES = (".add", ".commit")

def iter_jsonl(paths: list[Path]) -> list[dict[str, Any]]:

    rows: list[dict[str, Any]] = []

    for path in paths:

        with path.open() as fh:

            for raw_line in fh:

                line = raw_line.strip()

                if line:

                    rows.append(json.loads(line))

    return rows

def metric_value(row: dict[str, Any], metric: str) -> float | None:

    if metric == "elapsed_ms":

        return number_or_none(row.get("elapsed_ms"))

    if metric == "tokens":

        return token_total(row)

    if metric == "tool_calls":

        return tool_calls(row)

    if metric == "output_bytes":

        return output_bytes(row)

    return number_or_none(row.get(metric))

def cells_from_rows(

    rows: list[dict[str, Any]],

    *,

    lane: str,

    metrics: tuple[str, ...] = DEFAULT_BASELINE_METRICS,

    statistics_names: tuple[str, ...] = DEFAULT_BASELINE_STATISTICS,

    subjects: set[str] | None = None,

    include_subops: bool = False,

    bootstrap_samples: int = 2000,

    confidence: float = 0.95,

    seed: int = 20260609,

    noise_floor_pct: float | None = None,

) -> list[BaselineCell]:

    grouped: dict[tuple[str | None, str, str, str, str], list[float]] = {}

    observations = {}

    outcomes = {}

    for row in rows:

        if str(row.get("subject_kind") or "") != "git":

            continue

        subject = str(row.get("subject") or "")

        if subjects is not None and subject not in subjects:

            continue

        operation = str(row.get("operation") or "")

        if not include_subops and operation.endswith(SUBOP_SUFFIXES):

            continue

        profile = None if row.get("profile") is None else str(row.get("profile"))

        scenario = str(row.get("scenario") or "")

        outcomes.setdefault((profile, scenario, operation, subject), []).append(row)

        if row_returncode(row) != 0:

            continue

        for metric in metrics:

            value = metric_value(row, metric)

            if value is None:

                continue

            key = (profile, scenario, operation, subject, metric)

            grouped.setdefault(key, []).append(float(value))

            observations.setdefault(key, []).append(row)

    cells: list[BaselineCell] = []

    for (profile, scenario, operation, subject, metric), values in sorted(grouped.items()):

        observed = observations[(profile, scenario, operation, subject, metric)]

        all_rows = outcomes[(profile, scenario, operation, subject)]

        conflicts = population_conflicts([row for row in all_rows if row_returncode(row) == 0])

        if conflicts:

            raise ValueError(f"incompatible baseline population {scenario}/{operation}: {', '.join(conflicts)}")

        for statistic_name in statistics_names:

            stat = named_statistic(statistic_name)

            ci_low, ci_high = bootstrap_ci(

                values,

                statistic=statistic_name,

                samples=bootstrap_samples,

                confidence=confidence,

                seed=seed,

            )

            cells.append(

                BaselineCell(

                    lane=lane,

                    profile=profile,

                    scenario=scenario,

                    operation=operation,

                    subject=subject,

                    metric=metric,

                    statistic=statistic_name,

                    value=float(stat(values)),

                    ci_low=ci_low,

                    ci_high=ci_high,

                    n=len(values),

                    noise_floor_pct=noise_floor_pct,

                    comparison_identity=comparison_identity(observed[0]),

                    independent_n=independent_run_count(observed),

                    attempted_n=len(all_rows),

                    failure_n=sum(row_returncode(row) not in (0, 77) for row in all_rows),

                    skipped_n=sum(row_returncode(row) == 77 for row in all_rows),

                )

            )

    return cells

def book_json(cells: list[BaselineCell]) -> dict[str, Any]:

    return {

        "schema_version": 2,

        "cells": [

            {

                "lane": cell.lane,

                "profile": cell.profile,

                "scenario": cell.scenario,

                "operation": cell.operation,

                "subject": cell.subject,

                "metric": cell.metric,

                "statistic": cell.statistic,

                "value": cell.value,

                "ci_low": cell.ci_low,

                "ci_high": cell.ci_high,

                "n": cell.n,

                "noise_floor_pct": cell.noise_floor_pct,

                "comparison_identity": cell.comparison_identity,

                "independent_n": cell.independent_n,

                "attempted_n": cell.attempted_n,

                "failure_n": cell.failure_n,

                "skipped_n": cell.skipped_n,

            }

            for cell in cells

        ],

    }

def manifest_json(

    *,

    book_id: str,

    row_paths: list[Path],

    runner_class: str | None,

    runner_id: str | None = None,

    runner_profile: dict[str, Any] | None = None,

    git_version: str | None = None,

    git_binary_sha256: str | None = None,

    raw_storage_keys: list[str] | None = None,

    suite_hash: str | None = None,

) -> dict[str, Any]:

    return {

        "schema_version": 1,

        "book_id": book_id,

        "generated_at_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),

        "suite_hash": suite_hash,

        "runner_id": runner_id,

        "runner_class": runner_class,

        "runner_profile": runner_profile,

        "git_version": git_version,

        "git_binary_sha256": git_binary_sha256,

        "raw_storage_keys": raw_storage_keys or [],

        "raw_inputs": [

            {

                "path": str(path),

                "sha256": sha256_file(path),

                "bytes": path.stat().st_size,

            }

            for path in row_paths

        ],

    }

def book_markdown(book_id: str, cells: list[BaselineCell]) -> str:

    lines = [

        f"# Git Baseline Book: `{book_id}`",

        "",

        "| Subject | Scenario / operation | Metric | Statistic | n | Value | CI |",

        "| --- | --- | --- | --- | ---: | ---: | --- |",

    ]

    for cell in cells:

        ci = ""

        if cell.ci_low is not None and cell.ci_high is not None:

            ci = f"[{cell.ci_low:.3f}, {cell.ci_high:.3f}]"

        lines.append(

            f"| `{cell.subject}` | `{cell.scenario}/{cell.operation}` | `{cell.metric}` | "

            f"`{cell.statistic}` | {cell.n or 0} | {cell.value:.3f} | {ci} |"

        )

    lines.append("")

    return "\n".join(lines)

def sha256_file(path: Path) -> str:

    digest = hashlib.sha256()

    with path.open("rb") as fh:

        for chunk in iter(lambda: fh.read(1024 * 1024), b""):

            digest.update(chunk)

    return digest.hexdigest()