"""Benchmark engine — compare methods and solvers across instance sizes."""

from __future__ import annotations

from datetime import datetime, timezone

from optos.constants import PROBLEM_TYPES, SIZE_PRESETS
from optos.engine import OptimizationEngine
from optos.generators import generate_instance
from optos.models import ExperimentRun


class BenchmarkEngine:
    def __init__(self, time_limit_sec: float = 10.0) -> None:
        self.engine = OptimizationEngine(time_limit_sec)

    def run_instance_benchmark(
        self,
        problem_type: str,
        size: str,
        seed: int = 42,
    ) -> ExperimentRun:
        return self.engine.run_experiment(problem_type, size, seed)

    def run_problem_suite(
        self,
        problem_type: str,
        sizes: list[str] | None = None,
        seeds: list[int] | None = None,
    ) -> list[ExperimentRun]:
        sizes = sizes or ["small", "medium", "large"]
        seeds = seeds or [42, 123]
        return [
            self.engine.run_experiment(problem_type, size, seed)
            for size in sizes
            for seed in seeds
        ]

    def run_full_benchmark(
        self,
        sizes: list[str] | None = None,
        seeds: list[int] | None = None,
    ) -> dict:
        sizes = sizes or ["small", "medium", "large"]
        seeds = seeds or [42, 123]
        rows = []
        comparisons: dict = {}

        for pt in PROBLEM_TYPES:
            comparisons[pt] = {}
            for size in sizes:
                for seed in seeds:
                    run = self.engine.run_experiment(pt, size, seed)
                    comparisons[pt][f"{size}_s{seed}"] = {
                        "instance_label": run.instance.label,
                        "winner": run.winner,
                        "winner_gap_pct": run.winner_gap_pct,
                        "results": {
                            r.method_id: r.metrics.to_dict() for r in run.results
                        },
                    }
                    for r in run.results:
                        rows.append({
                            "problem_type": pt,
                            "problem_label": PROBLEM_TYPES[pt]["label"],
                            "size": size,
                            "seed": seed,
                            "instance_id": run.instance.instance_id,
                            "method_id": r.method_id,
                            "method_label": r.method_label,
                            "method_category": r.method_category,
                            "solver_id": r.solver_id,
                            "objective_value": r.metrics.objective_value,
                            "best_bound": r.metrics.best_bound,
                            "optimality_gap": r.metrics.optimality_gap,
                            "elapsed_time_sec": r.metrics.elapsed_time_sec,
                            "iterations": r.metrics.iterations,
                            "constraint_violations": r.metrics.constraint_violations,
                            "feasible": r.metrics.feasible,
                            "status": r.metrics.status,
                            "winner": r.method_id == run.winner,
                            "n_variables": run.instance.features.n_variables,
                            "n_constraints": run.instance.features.n_constraints,
                        })

        scalability = []
        for row in rows:
            scalability.append({
                "problem_type": row["problem_type"],
                "size": row["size"],
                "method_id": row["method_id"],
                "elapsed_time_sec": row["elapsed_time_sec"],
                "objective_value": row["objective_value"],
            })

        winners: dict[str, int] = {}
        for row in rows:
            if row.get("winner"):
                winners[row["method_id"]] = winners.get(row["method_id"], 0) + 1

        return {
            "generated_at": datetime.now(timezone.utc).isoformat(),
            "benchmarks": {"rows": rows},
            "comparisons": comparisons,
            "scalability": {"rows": scalability},
            "summary": {
                "total_runs": len(rows),
                "unique_instances": len({r["instance_id"] for r in rows}),
                "problem_types": len(PROBLEM_TYPES),
                "winner_distribution": winners,
            },
        }

    def category_comparison(self, runs: list[ExperimentRun]) -> list[dict]:
        """Compare baseline vs exact vs scalable vs robust averages."""
        cats: dict[str, list[float]] = {}
        for run in runs:
            for r in run.results:
                if r.metrics.feasible:
                    cats.setdefault(r.method_category, []).append(r.metrics.objective_value)
        return [
            {
                "category": cat,
                "avg_objective": round(sum(vals) / len(vals), 2),
                "count": len(vals),
            }
            for cat, vals in sorted(cats.items())
        ]