"""Core optimization engine — dispatches problems to registered methods."""

from __future__ import annotations

import time
import uuid

from optos.constants import ENGINE_VERSION, METHODS, PROBLEM_TYPES
from optos.generators import generate_instance
from optos.methods import get_method
from optos.models import ExperimentRun, ProblemInstance, SolveResult


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

    def solve_instance(
        self,
        instance: ProblemInstance,
        methods: list[str] | None = None,
    ) -> list[SolveResult]:
        pt = instance.problem_type
        method_map = METHODS.get(pt, {})
        if methods:
            method_ids = methods
        else:
            method_ids = [m["id"] for m in method_map.values()]

        results: list[SolveResult] = []
        per_method_limit = self.time_limit_sec / max(len(method_ids), 1)
        for mid in method_ids:
            try:
                solver = get_method(mid, per_method_limit)
                results.append(solver.solve(instance))
            except Exception as exc:
                from optos.models import SolveMetrics
                results.append(SolveResult(
                    method_id=mid,
                    method_label=mid,
                    method_category="error",
                    solver_id="none",
                    solver_config={},
                    instance_id=instance.instance_id,
                    problem_type=pt,
                    metrics=SolveMetrics(status="error", feasible=False),
                    log=str(exc),
                ))
        return results

    def run_experiment(
        self,
        problem_type: str,
        size: str = "medium",
        seed: int = 42,
        time_limit: float | None = None,
        constraints: dict | None = None,
        objectives: dict | None = None,
    ) -> ExperimentRun:
        t0 = time.perf_counter()
        instance = generate_instance(problem_type, size, seed, constraints, objectives)
        limit = time_limit or self.time_limit_sec
        engine = OptimizationEngine(limit)
        results = engine.solve_instance(instance)
        winner = self._pick_winner(results, problem_type)
        gap = self._winner_gap(results, winner, problem_type)
        return ExperimentRun(
            run_id=uuid.uuid4().hex[:12],
            instance=instance,
            model_version=ENGINE_VERSION,
            solver_id="multi",
            solver_config={"time_limit": limit},
            parameters={"size": size, "seed": seed, "problem_type": problem_type},
            results=results,
            winner=winner,
            winner_gap_pct=gap,
            runtime_sec=round(time.perf_counter() - t0, 4),
        )

    @staticmethod
    def _pick_winner(results: list[SolveResult], problem_type: str) -> str:
        feasible = [r for r in results if r.metrics.feasible]
        if not feasible:
            return results[0].method_id if results else "none"
        minimize = PROBLEM_TYPES.get(problem_type, {}).get("objective") == "minimize"
        if minimize:
            best = min(feasible, key=lambda r: (r.metrics.objective_value, r.metrics.elapsed_time_sec))
        else:
            best = max(feasible, key=lambda r: (r.metrics.objective_value, -r.metrics.elapsed_time_sec))
        return best.method_id

    @staticmethod
    def _winner_gap(results: list[SolveResult], winner: str, problem_type: str) -> float:
        winner_r = next((r for r in results if r.method_id == winner), None)
        if not winner_r or not winner_r.metrics.feasible:
            return 0.0
        others = [r for r in results if r.method_id != winner and r.metrics.feasible]
        if not others:
            return 0.0
        gaps = []
        for r in others:
            if winner_r.metrics.objective_value > 0:
                gaps.append(
                    abs(r.metrics.objective_value - winner_r.metrics.objective_value)
                    / winner_r.metrics.objective_value * 100
                )
        return round(sum(gaps) / len(gaps), 2) if gaps else 0.0