#!/usr/bin/env python3

"""Print a Markdown regression report for Oak benchmark JSONL files."""

from __future__ import annotations

import argparse

import json

import statistics

import sys

from dataclasses import dataclass

from pathlib import Path

from typing import Any, Iterable, Optional

from oakbench.reporting import (

    delta_ms,

    fmt_ms,

    fmt_num,

    fmt_pct,

    fmt_rate,

    lower_is_better_pct,

    median,

    percentile_nearest,

    slower_pct,

)

from oakbench.rows import (

    number_or_none,

    output_bytes as row_output_bytes,

    output_truncated as row_output_truncated,

    row_returncode,

    token_total as row_token_total,

    tool_calls as row_tool_calls,

)

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

SKIP_RETURNCODE = 77

@dataclass(frozen=True)

class Aggregate:

    subject: str

    scenario: str

    operation: str

    sample_count: int

    total_count: int

    failure_count: int

    skip_count: int

    p50_ms: Optional[float]

    p90_ms: Optional[float]

    avg_tokens: Optional[float]

    avg_tool_calls: Optional[float]

    avg_output_bytes: Optional[float]

    truncated_count: int

    avg_information_recall: Optional[float] = None

    pipe_compat_rate: Optional[float] = None

    @property

    def failure_rate(self) -> float:

        # Skip rows (returncode 77) are unmeasured coverage, not failures:

        # they leave both the numerator and the denominator (ADR-0002).

        measured = self.total_count - self.skip_count

        if measured <= 0:

            return 0.0

        return self.failure_count / measured

@dataclass(frozen=True)

class Regression:

    baseline_label: str

    baseline_subject: str

    target_subject: str

    scenario: str

    operation: str

    reasons: tuple[str, ...]

    target: Aggregate

    baseline: Aggregate

    p50_delta_ms: Optional[float]

    p50_slower_pct: Optional[float]

    p90_delta_ms: Optional[float]

    p90_slower_pct: Optional[float]

    failure_delta_pp: float

    severity: float

def parse_args() -> argparse.Namespace:

    parser = argparse.ArgumentParser(description=__doc__)

    parser.add_argument("jsonl", nargs="+", type=Path, help="One or more benchmark JSONL files")

    parser.add_argument("--target-subject", default="oak_local")

    parser.add_argument("--git-subject", default="git")

    parser.add_argument(

        "--oak-baseline",

        help="Default: oak_main when present, otherwise oak_installed",

    )

    parser.add_argument("--oak-threshold-pct", type=float, default=10.0)

    parser.add_argument("--git-threshold-pct", type=float, default=25.0)

    parser.add_argument("--min-delta-ms", type=float, default=5.0)

    parser.add_argument(

        "--failure-rate-threshold-pct",

        type=float,

        default=0.0,

        help="Allowed failure-rate increase in percentage points before flagging",

    )

    parser.add_argument(

        "--tool-calls-threshold-pct",

        type=float,

        default=0.0,

        help=(

            "Flag when target avg tool calls exceed the baseline by more than this percent. "

            "Tool calls are exact in the CLI harness, so the default flags any increase. "

            "Set negative to disable."

        ),

    )

    parser.add_argument(

        "--output-bytes-threshold-pct",

        type=float,

        default=25.0,

        help=(

            "Flag when target avg output bytes exceed the baseline by more than this percent. "

            "Output bytes are exact and drive agent context cost. Set negative to disable."

        ),

    )

    parser.add_argument(

        "--tokens-threshold-pct",

        type=float,

        default=-1.0,

        help=(

            "Flag when target avg tokens exceed the baseline by more than this percent. "

            "Disabled by default because char/4 estimates are advisory; gate on output bytes "

            "and tool calls (exact) instead, or set this once provider-reported rows dominate."

        ),

    )

    parser.add_argument("--include-subops", action="store_true")

    parser.add_argument("--limit", type=int, default=40, help="Maximum flagged regressions to print")

    parser.add_argument("--fail-on-regression", action="store_true")

    return parser.parse_args()

def is_suboperation(operation: str) -> bool:

    return operation.endswith(SUBOP_SUFFIXES)

def iter_rows(paths: Iterable[Path]) -> Iterable[tuple[Path, int, dict[str, Any]]]:

    for path in paths:

        with path.open() as fh:

            for line_number, raw_line in enumerate(fh, start=1):

                line = raw_line.strip()

                if not line:

                    continue

                try:

                    row = json.loads(line)

                except json.JSONDecodeError as exc:

                    raise SystemExit(f"{path}:{line_number}: invalid JSON: {exc}") from exc

                if not isinstance(row, dict):

                    raise SystemExit(f"{path}:{line_number}: expected a JSON object")

                yield path, line_number, row

def choose_oak_baseline(subjects: set[str], explicit: Optional[str]) -> Optional[str]:

    if explicit:

        return explicit if explicit in subjects else None

    if "oak_main" in subjects:

        return "oak_main"

    if "oak_installed" in subjects:

        return "oak_installed"

    return None

def choose_targets(

    subjects: set[str],

    target_subject: str,

    git_subject: str,

    oak_baseline: Optional[str],

) -> list[str]:

    if target_subject in subjects:

        return [target_subject]

    excluded = {git_subject}

    if oak_baseline:

        excluded.add(oak_baseline)

    return sorted(subject for subject in subjects if subject not in excluded)

def subject_order(subject: str, git_subject: str, oak_baseline: Optional[str], targets: list[str]) -> tuple[int, str]:

    if subject == git_subject:

        return (0, subject)

    if oak_baseline and subject == oak_baseline:

        return (1, subject)

    if subject in targets:

        return (2, subject)

    return (3, subject)

def build_aggregates(args: argparse.Namespace) -> tuple[

    dict[tuple[str, str, str], Aggregate],

    dict[str, Any],

]:

    samples: dict[tuple[str, str, str], list[float]] = {}

    token_samples: dict[tuple[str, str, str], list[float]] = {}

    tool_samples: dict[tuple[str, str, str], list[float]] = {}

    output_samples: dict[tuple[str, str, str], list[float]] = {}

    truncations: dict[tuple[str, str, str], int] = {}

    totals: dict[tuple[str, str, str], int] = {}

    failures: dict[tuple[str, str, str], int] = {}

    skips: dict[tuple[str, str, str], int] = {}

    recall_samples: dict[tuple[str, str, str], list[float]] = {}

    pipe_samples: dict[tuple[str, str, str], list[float]] = {}

    meta: dict[str, Any] = {

        "bench_ids": set(),

        "profiles": set(),

        "hosts": set(),

        "subjects": set(),

        "source_hashes": set(),

        "skipped": 0,

        "row_count": 0,

        "paths": [str(path) for path in args.jsonl],

    }

    for _, _, row in iter_rows(args.jsonl):

        meta["row_count"] += 1

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

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

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

        if not subject or not scenario or not operation:

            meta["skipped"] += 1

            continue

        if not args.include_subops and is_suboperation(operation):

            continue

        key = (subject, scenario, operation)

        totals[key] = totals.get(key, 0) + 1

        meta["subjects"].add(subject)

        if row.get("bench_id"):

            meta["bench_ids"].add(str(row["bench_id"]))

        if row.get("profile"):

            meta["profiles"].add(str(row["profile"]))

        host_parts = [row.get("host"), row.get("platform"), row.get("machine")]

        if any(host_parts):

            meta["hosts"].add(" / ".join(str(part) for part in host_parts if part))

        source = row.get("source")

        if isinstance(source, dict) and source.get("oak_hash"):

            meta["source_hashes"].add(str(source["oak_hash"]))

        # Skip rows are recorded coverage gaps (returncode 77 + skipped):

        # they must not count as failures and must not feed any average —

        # a skipped Oak capability is unmeasured, not "0 tokens, 0 tools".

        returncode = row_returncode(row)

        if returncode == SKIP_RETURNCODE or row.get("skipped"):

            skips[key] = skips.get(key, 0) + 1

            continue

        if returncode != 0:

            failures[key] = failures.get(key, 0) + 1

            continue

        # Efficiency averages sample successful rows only: a failed command's

        # token/output cost is real but belongs to the failure metrics, not to

        # the "what does this operation cost when it works" trend line.

        token_total = row_token_total(row)

        if token_total is not None:

            token_samples.setdefault(key, []).append(token_total)

        tool_total = row_tool_calls(row)

        if tool_total is not None:

            tool_samples.setdefault(key, []).append(tool_total)

        output_total = row_output_bytes(row)

        if output_total is not None:

            output_samples.setdefault(key, []).append(output_total)

        if row_output_truncated(row):

            truncations[key] = truncations.get(key, 0) + 1

        # Output sufficiency from inforecall probe rows: recall of the

        # ground-truth changed set and piped-diff structural compatibility.

        recall = row.get("information_recall")

        if isinstance(recall, (int, float)) and not isinstance(recall, bool):

            recall_samples.setdefault(key, []).append(float(recall))

        pipe_compatible = row.get("pipe_compatible_unified")

        if isinstance(pipe_compatible, bool):

            pipe_samples.setdefault(key, []).append(1.0 if pipe_compatible else 0.0)

        try:

            elapsed_ms = float(row["elapsed_ms"])

        except (KeyError, TypeError, ValueError):

            meta["skipped"] += 1

            continue

        samples.setdefault(key, []).append(elapsed_ms)

    aggregates: dict[tuple[str, str, str], Aggregate] = {}

    for key in sorted(totals):

        subject, scenario, operation = key

        values = samples.get(key, [])

        aggregates[key] = Aggregate(

            subject=subject,

            scenario=scenario,

            operation=operation,

            sample_count=len(values),

            total_count=totals[key],

            failure_count=failures.get(key, 0),

            skip_count=skips.get(key, 0),

            p50_ms=median(values),

            p90_ms=percentile_nearest(values, 90.0),

            avg_tokens=statistics.mean(token_samples[key]) if key in token_samples else None,

            avg_tool_calls=statistics.mean(tool_samples[key]) if key in tool_samples else None,

            avg_output_bytes=statistics.mean(output_samples[key]) if key in output_samples else None,

            truncated_count=truncations.get(key, 0),

            avg_information_recall=statistics.mean(recall_samples[key]) if key in recall_samples else None,

            pipe_compat_rate=statistics.mean(pipe_samples[key]) if key in pipe_samples else None,

        )

    return aggregates, meta

def compare_target(

    aggregates: dict[tuple[str, str, str], Aggregate],

    target_subject: str,

    baseline_subject: str,

    baseline_label: str,

    threshold_pct: float,

    min_delta_ms: float,

    failure_threshold_pp: float,

    tool_calls_threshold_pct: float = -1.0,

    output_bytes_threshold_pct: float = -1.0,

    tokens_threshold_pct: float = -1.0,

) -> list[Regression]:

    regressions: list[Regression] = []

    scenario_ops = sorted({(scenario, operation) for _, scenario, operation in aggregates})

    for scenario, operation in scenario_ops:

        target = aggregates.get((target_subject, scenario, operation))

        baseline = aggregates.get((baseline_subject, scenario, operation))

        if target is None or baseline is None:

            continue

        p50_delta = delta_ms(baseline.p50_ms, target.p50_ms)

        p50_pct = slower_pct(baseline.p50_ms, target.p50_ms)

        p90_delta = delta_ms(baseline.p90_ms, target.p90_ms)

        p90_pct = slower_pct(baseline.p90_ms, target.p90_ms)

        failure_delta_pp = (target.failure_rate - baseline.failure_rate) * 100.0

        reasons: list[str] = []

        severities: list[float] = []

        if p50_delta is not None and p50_pct is not None:

            if p50_delta >= min_delta_ms and p50_pct >= threshold_pct:

                reasons.append("p50")

                severities.append(p50_pct / max(threshold_pct, 0.001))

        if p90_delta is not None and p90_pct is not None:

            if p90_delta >= min_delta_ms and p90_pct >= threshold_pct:

                reasons.append("p90")

                severities.append(p90_pct / max(threshold_pct, 0.001))

        if failure_delta_pp > failure_threshold_pp:

            reasons.append("failure-rate")

            severities.append(max(1.0, failure_delta_pp / max(failure_threshold_pp, 0.1)))

        # Agent-efficiency gates. Tool calls and output bytes are exact for the

        # CLI harness; token estimates are advisory unless explicitly enabled.

        efficiency_checks = (

            ("tool-calls", tool_calls_threshold_pct, baseline.avg_tool_calls, target.avg_tool_calls),

            ("output-bytes", output_bytes_threshold_pct, baseline.avg_output_bytes, target.avg_output_bytes),

            ("tokens", tokens_threshold_pct, baseline.avg_tokens, target.avg_tokens),

        )

        for reason, eff_threshold, base_value, target_value in efficiency_checks:

            if eff_threshold < 0:

                continue

            pct = lower_is_better_pct(base_value, target_value)

            if pct is not None and pct > eff_threshold:

                reasons.append(reason)

                severities.append(pct / max(eff_threshold, 1.0))

        # Output-sufficiency gates: exact semantic metrics, always on when

        # both sides measured them. Tokens and time can improve while

        # actionability regresses — fewer bytes that drop changed-file names

        # (recall) or break piped-diff structure (pipe-compat) is a

        # regression, not a win.

        if (

            target.avg_information_recall is not None

            and baseline.avg_information_recall is not None

            and target.avg_information_recall < baseline.avg_information_recall - 1e-6

        ):

            reasons.append("information-recall")

            severities.append(2.0)

        if (

            target.pipe_compat_rate is not None

            and baseline.pipe_compat_rate is not None

            and target.pipe_compat_rate < baseline.pipe_compat_rate - 1e-6

        ):

            reasons.append("pipe-compat")

            severities.append(2.0)

        if reasons:

            regressions.append(

                Regression(

                    baseline_label=baseline_label,

                    baseline_subject=baseline_subject,

                    target_subject=target_subject,

                    scenario=scenario,

                    operation=operation,

                    reasons=tuple(reasons),

                    target=target,

                    baseline=baseline,

                    p50_delta_ms=p50_delta,

                    p50_slower_pct=p50_pct,

                    p90_delta_ms=p90_delta,

                    p90_slower_pct=p90_pct,

                    failure_delta_pp=failure_delta_pp,

                    severity=max(severities) if severities else 0.0,

                )

            )

    return regressions

def markdown_report(args: argparse.Namespace) -> tuple[str, bool]:

    aggregates, meta = build_aggregates(args)

    subjects = set(meta["subjects"])

    oak_baseline = choose_oak_baseline(subjects, args.oak_baseline)

    targets = choose_targets(subjects, args.target_subject, args.git_subject, oak_baseline)

    regressions: list[Regression] = []

    for target in targets:

        if args.git_subject in subjects and target != args.git_subject:

            regressions.extend(

                compare_target(

                    aggregates,

                    target,

                    args.git_subject,

                    "Git",

                    args.git_threshold_pct,

                    args.min_delta_ms,

                    args.failure_rate_threshold_pct,

                )

            )

        if oak_baseline and target != oak_baseline:

            # Efficiency gates apply to the Oak-baseline comparison only: the

            # release-blocking question is "did this changeset make Oak worse",

            # not "does Oak emit more text than Git" (tracked separately).

            regressions.extend(

                compare_target(

                    aggregates,

                    target,

                    oak_baseline,

                    "Oak baseline",

                    args.oak_threshold_pct,

                    args.min_delta_ms,

                    args.failure_rate_threshold_pct,

                    tool_calls_threshold_pct=args.tool_calls_threshold_pct,

                    output_bytes_threshold_pct=args.output_bytes_threshold_pct,

                    tokens_threshold_pct=args.tokens_threshold_pct,

                )

            )

    regressions.sort(

        key=lambda item: (

            "failure-rate" not in item.reasons,

            -item.severity,

            -(item.p90_delta_ms or 0.0),

            item.scenario,

            item.operation,

        )

    )

    lines: list[str] = [

        "# Oak Benchmark Regression Report",

        "",

        (

            "Positive comparison percentages mean the target subject is higher than the baseline; "

            "for time that is slower, and for tokens/tool calls that is more expensive."

        ),

        "",

        f"- Inputs: {', '.join(f'`{path}`' for path in meta['paths'])}",

        f"- Rows read: {meta['row_count']}",

        f"- Bench IDs: {format_set(meta['bench_ids'])}",

        f"- Profiles: {format_set(meta['profiles'])}",

        f"- Source hashes: {format_set(meta['source_hashes'])}",

        f"- Hosts: {format_set(meta['hosts'])}",

        f"- Target subjects: {', '.join(f'`{subject}`' for subject in targets) or '`none`'}",

        f"- Git baseline: `{args.git_subject}`" if args.git_subject in subjects else f"- Git baseline: `{args.git_subject}` missing",

        f"- Oak baseline: `{oak_baseline}`" if oak_baseline else "- Oak baseline: missing",

        (

            f"- Thresholds: Oak {args.oak_threshold_pct:.1f}%, Git {args.git_threshold_pct:.1f}%, "

            f"minimum {args.min_delta_ms:.1f} ms, failure delta {args.failure_rate_threshold_pct:.1f} pp"

        ),

        (

            "- Efficiency gates vs Oak baseline (exact metrics): tool calls "

            + (f"+{args.tool_calls_threshold_pct:.1f}%" if args.tool_calls_threshold_pct >= 0 else "off")

            + ", output bytes "

            + (f"+{args.output_bytes_threshold_pct:.1f}%" if args.output_bytes_threshold_pct >= 0 else "off")

            + ", tokens (advisory estimate) "

            + (f"+{args.tokens_threshold_pct:.1f}%" if args.tokens_threshold_pct >= 0 else "off")

        ),

    ]

    if meta["skipped"]:

        lines.append(f"- Skipped malformed rows: {meta['skipped']}")

    lines.extend(["", "## Status", ""])

    if regressions:

        lines.append(f"Regressions flagged: {len(regressions)}")

    else:

        lines.append("No regressions exceeded the configured thresholds.")

    lines.extend(

        [

            "",

            "## Subject Averages",

            "",

            (

                "Token values are provider-reported when present; otherwise they are benchmark-estimated "

                "from normalized transcript characters or direct CLI output."

            ),

            "Output bytes are full stdout/stderr byte counts. Truncated rows indicate admitted text was capped.",

            "",

            "| Subject | Avg ms/op | Avg tokens/op | Avg output bytes/op | Avg tool calls/op | Tokens vs Git | Tokens vs Oak | Tools vs Git | Tools vs Oak |",

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

        ]

    )

    ordered_subjects = sorted(

        subjects,

        key=lambda subject: subject_order(subject, args.git_subject, oak_baseline, targets),

    )

    git_avg_tokens = weighted_subject_average(aggregates, args.git_subject, "avg_tokens")

    git_avg_tools = weighted_subject_average(aggregates, args.git_subject, "avg_tool_calls")

    oak_avg_tokens = weighted_subject_average(aggregates, oak_baseline, "avg_tokens") if oak_baseline else None

    oak_avg_tools = weighted_subject_average(aggregates, oak_baseline, "avg_tool_calls") if oak_baseline else None

    for subject in ordered_subjects:

        avg_time = weighted_subject_average(aggregates, subject, "p50_ms")

        avg_tokens = weighted_subject_average(aggregates, subject, "avg_tokens")

        avg_output = weighted_subject_average(aggregates, subject, "avg_output_bytes")

        avg_tools = weighted_subject_average(aggregates, subject, "avg_tool_calls")

        lines.append(

            "| "

            f"`{subject}` | "

            f"{fmt_ms(avg_time)} | "

            f"{fmt_num(avg_tokens)} | "

            f"{fmt_num(avg_output, 0)} | "

            f"{fmt_num(avg_tools, 2)} | "

            f"{fmt_pct(lower_is_better_pct(git_avg_tokens, avg_tokens)) if subject != args.git_subject else ''} | "

            f"{fmt_pct(lower_is_better_pct(oak_avg_tokens, avg_tokens)) if subject != oak_baseline and subject != args.git_subject else ''} | "

            f"{fmt_pct(lower_is_better_pct(git_avg_tools, avg_tools)) if subject != args.git_subject else ''} | "

            f"{fmt_pct(lower_is_better_pct(oak_avg_tools, avg_tools)) if subject != oak_baseline and subject != args.git_subject else ''} |"

        )

    if regressions:

        lines.extend(

            [

                "",

                "## Flagged Regressions",

                "",

            "| Baseline | Subject | Scenario / operation | Reason | p50 ms | Baseline p50 | p50 slower | p90 ms | Baseline p90 | p90 slower | Failure delta |",

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

            ]

        )

        for item in regressions[: args.limit]:

            lines.append(

                "| "

                f"{item.baseline_label} `{item.baseline_subject}` | "

                f"`{item.target_subject}` | "

                f"`{item.scenario}/{item.operation}` | "

                f"{', '.join(item.reasons)} | "

                f"{fmt_ms(item.target.p50_ms)} | "

                f"{fmt_ms(item.baseline.p50_ms)} | "

                f"{fmt_pct(item.p50_slower_pct)} | "

                f"{fmt_ms(item.target.p90_ms)} | "

                f"{fmt_ms(item.baseline.p90_ms)} | "

                f"{fmt_pct(item.p90_slower_pct)} | "

                f"{item.failure_delta_pp:+.1f} pp |"

            )

        if len(regressions) > args.limit:

            lines.append(f"\n_Only the first {args.limit} regressions are shown._")

    lines.extend(

        [

            "",

            "## Metrics",

            "",

            "| Scenario / operation | Subject | n | Failures | Skips | Failure rate | p50 ms | p90 ms | Avg tokens | Avg output bytes | Trunc rows | Avg tools | vs Git p50 | vs Git tokens | vs Git tools | vs Oak p50 | vs Oak tokens | vs Oak tools |",

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

        ]

    )

    scenario_ops = sorted({(scenario, operation) for _, scenario, operation in aggregates})

    for scenario, operation in scenario_ops:

        git_base = aggregates.get((args.git_subject, scenario, operation))

        oak_base = aggregates.get((oak_baseline, scenario, operation)) if oak_baseline else None

        for subject in ordered_subjects:

            aggregate = aggregates.get((subject, scenario, operation))

            if aggregate is None:

                continue

            vs_git = ""

            if git_base and subject != args.git_subject:

                vs_git = fmt_pct(slower_pct(git_base.p50_ms, aggregate.p50_ms))

            vs_oak = ""

            if oak_base and subject != oak_baseline:

                vs_oak = fmt_pct(slower_pct(oak_base.p50_ms, aggregate.p50_ms))

            vs_git_tokens = ""

            if git_base and subject != args.git_subject:

                vs_git_tokens = fmt_pct(lower_is_better_pct(git_base.avg_tokens, aggregate.avg_tokens))

            vs_git_tools = ""

            if git_base and subject != args.git_subject:

                vs_git_tools = fmt_pct(lower_is_better_pct(git_base.avg_tool_calls, aggregate.avg_tool_calls))

            vs_oak_tokens = ""

            if oak_base and subject != oak_baseline and subject != args.git_subject:

                vs_oak_tokens = fmt_pct(lower_is_better_pct(oak_base.avg_tokens, aggregate.avg_tokens))

            vs_oak_tools = ""

            if oak_base and subject != oak_baseline and subject != args.git_subject:

                vs_oak_tools = fmt_pct(lower_is_better_pct(oak_base.avg_tool_calls, aggregate.avg_tool_calls))

            lines.append(

                "| "

                f"`{scenario}/{operation}` | "

                f"`{subject}` | "

                f"{aggregate.sample_count} | "

                f"{aggregate.failure_count} | "

                f"{aggregate.skip_count} | "

                f"{fmt_rate(aggregate.failure_rate)} | "

                f"{fmt_ms(aggregate.p50_ms)} | "

                f"{fmt_ms(aggregate.p90_ms)} | "

                f"{fmt_num(aggregate.avg_tokens)} | "

                f"{fmt_num(aggregate.avg_output_bytes, 0)} | "

                f"{aggregate.truncated_count} | "

                f"{fmt_num(aggregate.avg_tool_calls, 2)} | "

                f"{vs_git} | "

                f"{vs_git_tokens} | "

                f"{vs_git_tools} | "

                f"{vs_oak} | "

                f"{vs_oak_tokens} | "

                f"{vs_oak_tools} |"

            )

    return "\n".join(lines) + "\n", bool(regressions)

def format_set(values: set[str]) -> str:

    if not values:

        return "`none`"

    return ", ".join(f"`{value}`" for value in sorted(values))

def weighted_subject_average(

    aggregates: dict[tuple[str, str, str], Aggregate],

    subject: str,

    attr: str,

) -> Optional[float]:

    total_weight = 0

    total_value = 0.0

    for aggregate in aggregates.values():

        if aggregate.subject != subject:

            continue

        value = getattr(aggregate, attr)

        if value is None:

            continue

        weight = max(aggregate.total_count, 1)

        total_weight += weight

        total_value += float(value) * weight

    if total_weight == 0:

        return None

    return total_value / total_weight

def main() -> int:

    args = parse_args()

    report, has_regressions = markdown_report(args)

    sys.stdout.write(report)

    if has_regressions and args.fail_on_regression:

        return 1

    return 0

if __name__ == "__main__":

    raise SystemExit(main())