space-bundle/src/optos/methods.py

"""Optimization method implementations — baseline, exact, scalable, robust."""

from __future__ import annotations

import math
import random
import time
from abc import ABC, abstractmethod
from typing import Any

from optos.constants import SOLVER_CONFIGS
from optos.models import ProblemInstance, SolveMetrics, SolveResult


class BaseMethod(ABC):
    method_id: str = "base"
    method_label: str = "Base"
    method_category: str = "baseline"
    solver_id: str = "heuristic"

    def __init__(self, time_limit_sec: float = 10.0) -> None:
        self.time_limit_sec = time_limit_sec
        self.config = dict(SOLVER_CONFIGS.get(self.solver_id, {}))

    @abstractmethod
    def solve(self, instance: ProblemInstance) -> SolveResult:
        ...

    def _make_result(

        self,

        instance: ProblemInstance,

        obj: float,

        status: str,

        elapsed: float,

        feasible: bool,

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

        bound: float | None = None,

        iterations: int = 0,

        violations: int = 0,

        log: str = "",

        t_first: float | None = None,

    ) -> SolveResult:
        gap = 0.0
        if bound is not None and feasible and obj > 0:
            gap = abs(obj - bound) / max(abs(obj), 1e-9) * 100
        elif instance.known_optimum and feasible:
            gap = abs(obj - instance.known_optimum) / max(abs(instance.known_optimum), 1e-9) * 100

        metrics = SolveMetrics(
            objective_value=round(obj, 4) if feasible else 0.0,
            best_bound=round(bound or obj, 4),
            optimality_gap=round(gap, 4),
            elapsed_time_sec=round(elapsed, 4),
            iterations=iterations,
            constraint_violations=violations,
            feasible=feasible,
            status=status,
            time_to_first_feasible=round(t_first or elapsed, 4),
        )
        return SolveResult(
            method_id=self.method_id,
            method_label=self.method_label,
            method_category=self.method_category,
            solver_id=self.solver_id,
            solver_config=self.config,
            instance_id=instance.instance_id,
            problem_type=instance.problem_type,
            metrics=metrics,
            solution=solution or {},
            log=log,
        )


# ---------------------------------------------------------------------------
# Scheduling
# ---------------------------------------------------------------------------

class SptBaseline(BaseMethod):
    method_id = "spt_baseline"
    method_label = "Shortest Processing Time (SPT)"
    method_category = "baseline"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        n_jobs, n_machines = data["n_jobs"], data["n_machines"]
        machine_free = [0.0] * n_machines
        job_ready = [0.0] * n_jobs
        makespan = 0.0
        for o in range(n_machines):
            order = sorted(range(n_jobs), key=lambda j: data["processing_times"][j][o])
            for j in order:
                start = max(machine_free[o], job_ready[j])
                end = start + data["processing_times"][j][o]
                machine_free[o] = end
                job_ready[j] = end
                makespan = max(makespan, end)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, makespan, "heuristic", elapsed, True, {"makespan": makespan})


class CpSatScheduling(BaseMethod):
    method_id = "cp_sat_scheduling"
    method_label = "CP-SAT Job Shop"
    method_category = "exact"
    solver_id = "cp_sat"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        from ortools.sat.python import cp_model

        t0 = time.perf_counter()
        data = instance.data
        n_jobs, n_machines = data["n_jobs"], data["n_machines"]
        horizon = sum(max(row) for row in data["processing_times"]) * n_jobs
        model = cp_model.CpModel()
        starts, ends = {}, {}
        for j in range(n_jobs):
            for o in range(n_machines):
                dur = data["processing_times"][j][o]
                starts[j, o] = model.new_int_var(0, horizon, f"s_{j}_{o}")
                ends[j, o] = model.new_int_var(0, horizon, f"e_{j}_{o}")
                model.add(ends[j, o] == starts[j, o] + dur)
            for o in range(n_machines - 1):
                model.add(starts[j, o + 1] >= ends[j, o])
        for m in range(n_machines):
            intervals = []
            for j in range(n_jobs):
                for o in range(n_machines):
                    if data["machine_order"][j][o] == m:
                        dur = data["processing_times"][j][o]
                        iv = model.new_interval_var(starts[j, o], dur, ends[j, o], f"iv_{j}_{o}_{m}")
                        intervals.append(iv)
            if intervals:
                model.add_no_overlap(intervals)
        makespan = model.new_int_var(0, horizon, "makespan")
        model.add_max_equality(makespan, [ends[j, n_machines - 1] for j in range(n_jobs)])
        model.minimize(makespan)
        solver = cp_model.CpSolver()
        solver.parameters.max_time_in_seconds = self.time_limit_sec
        solver.parameters.num_search_workers = self.config.get("num_search_workers", 4)
        status = solver.solve(model)
        elapsed = time.perf_counter() - t0
        feasible = status in (cp_model.OPTIMAL, cp_model.FEASIBLE)
        obj = solver.objective_value if feasible else 0.0
        bound = solver.best_objective_bound if feasible else 0.0
        return self._make_result(
            instance, obj, solver.status_name(status), elapsed, feasible,
            {"makespan": obj}, bound=bound, iterations=solver.num_branches,
            log=f"branches={solver.num_branches}",
        )


class GaScheduling(BaseMethod):
    method_id = "ga_scheduling"
    method_label = "Genetic Algorithm"
    method_category = "scalable"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        n_jobs, n_machines = data["n_jobs"], data["n_machines"]
        rng = random.Random(42)
        pop_size = min(40, max(10, n_jobs * 2))

        def eval_perm(perm: list[int]) -> float:
            machine_free = [0.0] * n_machines
            job_ready = [0.0] * n_jobs
            makespan = 0.0
            for j in perm:
                for o in range(n_machines):
                    start = max(machine_free[data["machine_order"][j][o]], job_ready[j])
                    end = start + data["processing_times"][j][o]
                    machine_free[data["machine_order"][j][o]] = end
                    job_ready[j] = end
                    makespan = max(makespan, end)
            return makespan

        population = [list(range(n_jobs)) for _ in range(pop_size)]
        for p in population:
            rng.shuffle(p)
        best = min(population, key=eval_perm)
        best_obj = eval_perm(best)
        iterations = 0
        deadline = t0 + self.time_limit_sec
        while time.perf_counter() < deadline and iterations < 200:
            iterations += 1
            parent = min(random.sample(population, 2), key=eval_perm)
            child = parent[:]
            i, j = rng.sample(range(n_jobs), 2)
            child[i], child[j] = child[j], child[i]
            child_obj = eval_perm(child)
            if child_obj < best_obj:
                best, best_obj = child, child_obj
            population[iterations % pop_size] = child
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, best_obj, "heuristic", elapsed, True,
                                   {"makespan": best_obj, "permutation": best}, iterations=iterations)


class RollingHorizonScheduling(BaseMethod):
    method_id = "rolling_horizon_scheduling"
    method_label = "Rolling Horizon"
    method_category = "robust"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        sub = ProblemInstance(
            problem_type=instance.problem_type,
            instance_id=instance.instance_id + "_rh",
            label=instance.label,
            size=instance.size,
            seed=instance.seed,
            data=dict(instance.data),
            features=instance.features,
        )
        data = sub.data
        window = max(2, data["n_jobs"] // 2)
        total_makespan = 0.0
        remaining_jobs = list(range(data["n_jobs"]))
        machine_free = [0.0] * data["n_machines"]
        while remaining_jobs:
            batch = remaining_jobs[:window]
            remaining_jobs = remaining_jobs[window:]
            mini = dict(data)
            mini["n_jobs"] = len(batch)
            mini["processing_times"] = [data["processing_times"][j] for j in batch]
            mini["machine_order"] = [data["machine_order"][j] for j in batch]
            mini_inst = ProblemInstance(
                problem_type="scheduling", instance_id=sub.instance_id,
                label=sub.label, size=sub.size, seed=sub.seed,
                data=mini, features=sub.features,
            )
            res = SptBaseline(self.time_limit_sec / 3).solve(mini_inst)
            batch_makespan = res.metrics.objective_value
            for m in range(data["n_machines"]):
                machine_free[m] += batch_makespan / data["n_machines"]
            total_makespan = max(machine_free)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, total_makespan, "rolling_horizon", elapsed, True,
                                   {"makespan": total_makespan})


# ---------------------------------------------------------------------------
# Routing
# ---------------------------------------------------------------------------

def _route_distance(depot: tuple, customers: list, route: list[int]) -> float:
    total = 0.0
    prev = depot
    for c in route:
        pt = customers[c]
        total += math.hypot(pt[0] - prev[0], pt[1] - prev[1])
        prev = pt
    total += math.hypot(prev[0] - depot[0], prev[1] - depot[1])
    return total


class NearestDepotRouting(BaseMethod):
    method_id = "nearest_depot"
    method_label = "Nearest Warehouse Greedy"
    method_category = "baseline"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        depot, customers = data["depot"], data["customers"]
        unvisited = set(range(data["n_customers"]))
        routes: list[list[int]] = []
        total_dist = 0.0
        while unvisited:
            route, load = [], 0
            pos = depot
            while unvisited:
                nearest = min(unvisited, key=lambda c: math.hypot(
                    customers[c][0] - pos[0], customers[c][1] - pos[1]))
                if load + data["demands"][nearest] > data["vehicle_capacity"]:
                    break
                route.append(nearest)
                load += data["demands"][nearest]
                unvisited.remove(nearest)
                pos = customers[nearest]
            if route:
                routes.append(route)
                total_dist += _route_distance(depot, customers, route)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, total_dist, "heuristic", elapsed, True,
                                   {"total_distance": total_dist, "routes": routes})


class CpSatRouting(BaseMethod):
    method_id = "cp_sat_routing"
    method_label = "CP-SAT Routing"
    method_category = "exact"
    solver_id = "cp_sat"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        from ortools.sat.python import cp_model

        t0 = time.perf_counter()
        data = instance.data
        n = data["n_customers"]
        if n > 15:
            return NearestDepotRouting(self.time_limit_sec).solve(instance)

        depot, customers = data["depot"], data["customers"]
        dist = [[0.0] * (n + 1) for _ in range(n + 1)]
        pts = [depot] + customers
        for i in range(n + 1):
            for j in range(n + 1):
                dist[i][j] = int(math.hypot(pts[i][0] - pts[j][0], pts[i][1] - pts[j][1]) * 10)

        model = cp_model.CpModel()
        x = {}
        for i in range(n + 1):
            for j in range(n + 1):
                if i != j:
                    x[i, j] = model.new_bool_var(f"x_{i}_{j}")
        for i in range(1, n + 1):
            model.add(sum(x[i, j] for j in range(n + 1) if j != i) == 1)
            model.add(sum(x[j, i] for j in range(n + 1) if j != i) == 1)
        u = [model.new_int_var(0, n, f"u_{i}") for i in range(n + 1)]
        for i in range(1, n + 1):
            for j in range(1, n + 1):
                if i != j:
                    model.add(u[i] - u[j] + (n + 1) * x[i, j] <= n)
        model.minimize(sum(dist[i][j] * x[i, j] for i in range(n + 1) for j in range(n + 1) if i != j))
        solver = cp_model.CpSolver()
        solver.parameters.max_time_in_seconds = self.time_limit_sec
        status = solver.solve(model)
        elapsed = time.perf_counter() - t0
        feasible = status in (cp_model.OPTIMAL, cp_model.FEASIBLE)
        obj = solver.objective_value / 10.0 if feasible else 0.0
        return self._make_result(instance, obj, solver.status_name(status), elapsed, feasible,
                                   {"total_distance": obj}, bound=solver.best_objective_bound / 10.0 if feasible else 0,
                                   iterations=solver.num_branches)


class AlnsRouting(BaseMethod):
    method_id = "alns_routing"
    method_label = "ALNS Routing"
    method_category = "scalable"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        base = NearestDepotRouting(self.time_limit_sec).solve(instance)
        best_dist = base.metrics.objective_value
        best_routes = base.solution.get("routes", [])
        rng = random.Random(42)
        iterations = 0
        deadline = t0 + self.time_limit_sec
        data = instance.data
        while time.perf_counter() < deadline and iterations < 300:
            iterations += 1
            if not best_routes:
                break
            ri = rng.randint(0, len(best_routes) - 1)
            route = list(best_routes[ri])
            if len(route) < 2:
                continue
            i, j = rng.sample(range(len(route)), 2)
            route[i], route[j] = route[j], route[i]
            new_routes = list(best_routes)
            new_routes[ri] = route
            new_dist = sum(_route_distance(data["depot"], data["customers"], r) for r in new_routes)
            if new_dist < best_dist:
                best_dist, best_routes = new_dist, new_routes
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, best_dist, "alns", elapsed, True,
                                   {"total_distance": best_dist, "routes": best_routes}, iterations=iterations)


class ScenarioRouting(BaseMethod):
    method_id = "scenario_routing"
    method_label = "Scenario Robust Routing"
    method_category = "robust"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        objs = []
        for factor in (0.8, 1.0, 1.2):
            perturbed = dict(instance.data)
            perturbed["demands"] = [max(1, int(d * factor)) for d in instance.data["demands"]]
            mini = ProblemInstance(
                problem_type="routing", instance_id=instance.instance_id,
                label=instance.label, size=instance.size, seed=instance.seed,
                data=perturbed, features=instance.features,
            )
            res = NearestDepotRouting(self.time_limit_sec / 3).solve(mini)
            objs.append(res.metrics.objective_value)
        robust_obj = max(objs)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, robust_obj, "scenario_robust", elapsed, True,
                                   {"worst_case_distance": robust_obj, "scenario_costs": objs})


# ---------------------------------------------------------------------------
# Assignment
# ---------------------------------------------------------------------------

class GreedyAssignment(BaseMethod):
    method_id = "greedy_assignment"
    method_label = "Greedy Assignment"
    method_category = "baseline"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        n = instance.data["n_agents"]
        costs = instance.data["cost_matrix"]
        assigned_j, total = [], 0.0
        used = set()
        for i in range(n):
            best_j = min((j for j in range(n) if j not in used), key=lambda j: costs[i][j])
            assigned_j.append(best_j)
            used.add(best_j)
            total += costs[i][best_j]
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, total, "heuristic", elapsed, True,
                                   {"assignment": assigned_j, "total_cost": total})


class HighsAssignment(BaseMethod):
    method_id = "highs_assignment"
    method_label = "HiGHS MIP Assignment"
    method_category = "exact"
    solver_id = "highs"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        import highspy

        t0 = time.perf_counter()
        n = instance.data["n_agents"]
        costs = instance.data["cost_matrix"]
        h = highspy.Highs()
        h.setOptionValue("time_limit", self.time_limit_sec)
        cols = []
        for i in range(n):
            for j in range(n):
                cols.append(highspy.HighsVarType.kInteger)
        h.addVars(n * n, cols)
        for i in range(n):
            row = [0.0] * (n * n)
            for j in range(n):
                row[i * n + j] = 1.0
            h.addRow(1.0, 1.0, len(row), list(range(n * n)), row)
        for j in range(n):
            row = [0.0] * (n * n)
            for i in range(n):
                row[i * n + j] = 1.0
            h.addRow(1.0, 1.0, len(row), list(range(n * n)), row)
        for idx in range(n * n):
            h.changeColBounds(idx, 0, 1)
        obj = [costs[idx // n][idx % n] for idx in range(n * n)]
        h.changeColsCost(n * n, list(range(n * n)), obj)
        h.changeObjectiveSense(highspy.ObjSense.kMinimize)
        h.run()
        elapsed = time.perf_counter() - t0
        sol = h.getSolution()
        feasible = h.getModelStatus() == highspy.HighsModelStatus.kOptimal
        total = sum(sol.col_value[idx] * costs[idx // n][idx % n] for idx in range(n * n)) if feasible else 0
        return self._make_result(instance, total, "optimal" if feasible else "infeasible", elapsed, feasible,
                                   {"total_cost": total}, bound=total if feasible else 0)


class LocalSearchAssignment(BaseMethod):
    method_id = "local_search_assignment"
    method_label = "Local Search"
    method_category = "scalable"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        base = GreedyAssignment(self.time_limit_sec).solve(instance)
        perm = list(base.solution.get("assignment", []))
        costs = instance.data["cost_matrix"]
        n = len(perm)
        best = sum(costs[i][perm[i]] for i in range(n))
        iterations = 0
        deadline = t0 + self.time_limit_sec
        while time.perf_counter() < deadline and iterations < 500:
            iterations += 1
            i, j = random.randint(0, n - 1), random.randint(0, n - 1)
            new_perm = list(perm)
            new_perm[i], new_perm[j] = new_perm[j], new_perm[i]
            new_cost = sum(costs[k][new_perm[k]] for k in range(n))
            if new_cost < best:
                best, perm = new_cost, new_perm
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, best, "local_search", elapsed, True,
                                   {"assignment": perm, "total_cost": best}, iterations=iterations)


class StochasticAssignment(BaseMethod):
    method_id = "stochastic_assignment"
    method_label = "Stochastic Assignment"
    method_category = "robust"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        costs = instance.data["cost_matrix"]
        n = instance.data["n_agents"]
        rng = random.Random(42)
        worst = 0.0
        for _ in range(5):
            perturbed = [[c * rng.uniform(0.85, 1.15) for c in row] for row in costs]
            mini = ProblemInstance(
                problem_type="assignment", instance_id=instance.instance_id,
                label=instance.label, size=instance.size, seed=instance.seed,
                data={"n_agents": n, "cost_matrix": perturbed},
                features=instance.features,
            )
            res = GreedyAssignment(self.time_limit_sec / 5).solve(mini)
            worst = max(worst, res.metrics.objective_value)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, worst, "stochastic", elapsed, True, {"worst_case_cost": worst})


# ---------------------------------------------------------------------------
# Inventory, Facility, Packing (condensed implementations)
# ---------------------------------------------------------------------------

class ReorderPointInventory(BaseMethod):
    method_id = "reorder_point"
    method_label = "Reorder Point Heuristic"
    method_category = "baseline"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        total_cost = 0.0
        for i in range(data["n_items"]):
            stock = data["initial_stock"][i]
            for t in range(data["horizon"]):
                d = data["demand"][i][t]
                if stock < d:
                    total_cost += data["stockout_cost"][i] * (d - stock)
                    stock = 0
                else:
                    stock -= d
                total_cost += data["holding_cost"][i] * stock
                if stock < sum(data["demand"][i]) / data["horizon"]:
                    total_cost += data["order_cost"][i]
                    stock += sum(data["demand"][i])
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, total_cost, "heuristic", elapsed, True, {"total_cost": total_cost})


class CpSatInventory(BaseMethod):
    method_id = "cp_sat_inventory"
    method_label = "CP-SAT Inventory MIP"
    method_category = "exact"
    solver_id = "cp_sat"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        from ortools.sat.python import cp_model

        t0 = time.perf_counter()
        data = instance.data
        ni, h = data["n_items"], data["horizon"]
        model = cp_model.CpModel()
        order = {}
        stock = {}
        for i in range(ni):
            for t in range(h):
                order[i, t] = model.new_int_var(0, data["max_order"][i], f"o_{i}_{t}")
                stock[i, t] = model.new_int_var(0, data["max_order"][i] * 2, f"s_{i}_{t}")
        obj_terms = []
        for i in range(ni):
            for t in range(h):
                d = data["demand"][i][t]
                shortfall = model.new_int_var(0, d, f"sh_{i}_{t}")
                model.add(stock[i, t] + order[i, t] >= d - shortfall)
                if t == 0:
                    model.add(stock[i, t] == data["initial_stock"][i] + order[i, t] - d + shortfall)
                else:
                    model.add(stock[i, t] == stock[i, t - 1] + order[i, t] - d + shortfall)
                obj_terms.append(int(data["holding_cost"][i] * 100) * stock[i, t])
                obj_terms.append(int(data["stockout_cost"][i] * 100) * shortfall)
                obj_terms.append(int(data["order_cost"][i] * 100) * order[i, t])
        model.minimize(sum(obj_terms))
        solver = cp_model.CpSolver()
        solver.parameters.max_time_in_seconds = self.time_limit_sec
        status = solver.solve(model)
        elapsed = time.perf_counter() - t0
        feasible = status in (cp_model.OPTIMAL, cp_model.FEASIBLE)
        obj = solver.objective_value / 100.0 if feasible else 0.0
        return self._make_result(instance, obj, solver.status_name(status), elapsed, feasible,
                                   {"total_cost": obj}, bound=obj if feasible else 0,
                                   iterations=solver.num_branches)


class DecompositionInventory(BaseMethod):
    method_id = "decomposition_inventory"
    method_label = "Rolling Decomposition"
    method_category = "scalable"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        total = 0.0
        data = instance.data
        window = max(2, data["horizon"] // 3)
        for start in range(0, data["horizon"], window):
            end = min(start + window, data["horizon"])
            mini_data = dict(data)
            mini_data["horizon"] = end - start
            mini_data["demand"] = [row[start:end] for row in data["demand"]]
            mini = ProblemInstance(
                problem_type="inventory", instance_id=instance.instance_id,
                label=instance.label, size=instance.size, seed=instance.seed,
                data=mini_data, features=instance.features,
            )
            res = ReorderPointInventory(self.time_limit_sec / 3).solve(mini)
            total += res.metrics.objective_value
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, total, "decomposition", elapsed, True, {"total_cost": total})


class SimulationInventory(BaseMethod):
    method_id = "simulation_inventory"
    method_label = "Simulation-Based Optimization"
    method_category = "robust"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        rng = random.Random(42)
        costs = []
        for _ in range(8):
            data = dict(instance.data)
            data["demand"] = [
                [max(1, int(d * rng.uniform(0.7, 1.3))) for d in row]
                for row in instance.data["demand"]
            ]
            mini = ProblemInstance(
                problem_type="inventory", instance_id=instance.instance_id,
                label=instance.label, size=instance.size, seed=instance.seed,
                data=data, features=instance.features,
            )
            res = ReorderPointInventory(self.time_limit_sec / 8).solve(mini)
            costs.append(res.metrics.objective_value)
        avg = sum(costs) / len(costs)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, avg, "simulation", elapsed, True,
                                   {"expected_cost": avg, "scenario_costs": costs})


class NearestFacility(BaseMethod):
    method_id = "nearest_facility"
    method_label = "Nearest Facility Greedy"
    method_category = "baseline"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        opened, total = set(), 0.0
        for c in range(data["n_customers"]):
            f = min(range(data["n_facilities"]), key=lambda f: data["transport_costs"][c][f])
            if f not in opened:
                opened.add(f)
                total += data["fixed_costs"][f]
            total += data["transport_costs"][c][f]
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, total, "heuristic", elapsed, True,
                                   {"opened_facilities": list(opened), "total_cost": total})


class CbcFacility(BaseMethod):
    method_id = "cbc_facility"
    method_label = "CBC Facility MIP"
    method_category = "exact"
    solver_id = "cbc"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        import pulp

        t0 = time.perf_counter()
        data = instance.data
        nf, nc = data["n_facilities"], data["n_customers"]
        prob = pulp.LpProblem("facility", pulp.LpMinimize)
        y = [pulp.LpVariable(f"y{f}", cat="Binary") for f in range(nf)]
        x = {}
        for c in range(nc):
            for f in range(nf):
                x[c, f] = pulp.LpVariable(f"x_{c}_{f}", cat="Binary")
        prob += sum(data["fixed_costs"][f] * y[f] for f in range(nf))
        prob += sum(data["transport_costs"][c][f] * x[c, f] for c in range(nc) for f in range(nf))
        for c in range(nc):
            prob += sum(x[c, f] for f in range(nf)) == 1
        for c in range(nc):
            for f in range(nf):
                prob += x[c, f] <= y[f]
        prob.solve(pulp.PULP_CBC_CMD(timeLimit=self.time_limit_sec, msg=False))
        elapsed = time.perf_counter() - t0
        feasible = prob.status == 1
        obj = pulp.value(prob.objective) if feasible else 0.0
        return self._make_result(instance, obj, "optimal" if feasible else "infeasible", elapsed, feasible,
                                   {"total_cost": obj}, bound=obj if feasible else 0)


class GaFacility(BaseMethod):
    method_id = "ga_facility"
    method_label = "GA Facility Selection"
    method_category = "scalable"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        nf, nc = data["n_facilities"], data["n_customers"]
        rng = random.Random(42)

        def eval_open(mask: list[int]) -> float:
            opened = [f for f in range(nf) if mask[f]]
            if not opened:
                return 1e18
            total = sum(data["fixed_costs"][f] for f in opened)
            for c in range(nc):
                total += min(data["transport_costs"][c][f] for f in opened)
            return total

        best_mask = [1] * nf
        best = eval_open(best_mask)
        iterations = 0
        deadline = t0 + self.time_limit_sec
        while time.perf_counter() < deadline and iterations < 200:
            iterations += 1
            f = rng.randint(0, nf - 1)
            new_mask = list(best_mask)
            new_mask[f] = 1 - new_mask[f]
            new_obj = eval_open(new_mask)
            if new_obj < best:
                best, best_mask = new_obj, new_mask
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, best, "ga", elapsed, True,
                                   {"total_cost": best, "opened": [f for f in range(nf) if best_mask[f]]},
                                   iterations=iterations)


class ScenarioFacility(BaseMethod):
    method_id = "scenario_facility"
    method_label = "Scenario Robust Location"
    method_category = "robust"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        worst = 0.0
        for factor in (1.0, 1.15, 1.3):
            data = dict(instance.data)
            data["fixed_costs"] = [int(c * factor) for c in instance.data["fixed_costs"]]
            mini = ProblemInstance(
                problem_type="facility_location", instance_id=instance.instance_id,
                label=instance.label, size=instance.size, seed=instance.seed,
                data=data, features=instance.features,
            )
            res = NearestFacility(self.time_limit_sec / 3).solve(mini)
            worst = max(worst, res.metrics.objective_value)
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, worst, "scenario_robust", elapsed, True, {"worst_case_cost": worst})


class FirstFitDecreasing(BaseMethod):
    method_id = "first_fit_decreasing"
    method_label = "First Fit Decreasing"
    method_category = "baseline"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        items = sorted(range(data["n_items"]), key=lambda i: -data["item_sizes"][i])
        bins: list[list[int]] = []
        bin_loads: list[int] = []
        for i in items:
            placed = False
            for b, load in enumerate(bin_loads):
                if load + data["item_sizes"][i] <= data["bin_capacity"]:
                    bins[b].append(i)
                    bin_loads[b] += data["item_sizes"][i]
                    placed = True
                    break
            if not placed:
                bins.append([i])
                bin_loads.append(data["item_sizes"][i])
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, len(bins), "heuristic", elapsed, True,
                                   {"bins_used": len(bins), "bins": bins})


class CpSatPacking(BaseMethod):
    method_id = "cp_sat_packing"
    method_label = "CP-SAT Bin Packing"
    method_category = "exact"
    solver_id = "cp_sat"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        from ortools.sat.python import cp_model

        t0 = time.perf_counter()
        data = instance.data
        n, cap = data["n_items"], data["bin_capacity"]
        max_bins = n
        model = cp_model.CpModel()
        y = [model.new_bool_var(f"y{b}") for b in range(max_bins)]
        x = {}
        for i in range(n):
            for b in range(max_bins):
                x[i, b] = model.new_bool_var(f"x_{i}_{b}")
        for i in range(n):
            model.add(sum(x[i, b] for b in range(max_bins)) == 1)
        for b in range(max_bins):
            model.add(sum(data["item_sizes"][i] * x[i, b] for i in range(n)) <= cap * y[b])
        model.minimize(sum(y))
        solver = cp_model.CpSolver()
        solver.parameters.max_time_in_seconds = self.time_limit_sec
        status = solver.solve(model)
        elapsed = time.perf_counter() - t0
        feasible = status in (cp_model.OPTIMAL, cp_model.FEASIBLE)
        obj = solver.objective_value if feasible else 0.0
        return self._make_result(instance, obj, solver.status_name(status), elapsed, feasible,
                                   {"bins_used": obj}, bound=obj if feasible else 0,
                                   iterations=solver.num_branches)


class AlnsPacking(BaseMethod):
    method_id = "alns_packing"
    method_label = "ALNS Packing"
    method_category = "scalable"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        base = FirstFitDecreasing(self.time_limit_sec).solve(instance)
        best_bins = base.solution.get("bins", [])
        best = len(best_bins)
        iterations = 0
        deadline = t0 + self.time_limit_sec
        data = instance.data
        while time.perf_counter() < deadline and iterations < 200 and len(best_bins) >= 2:
            iterations += 1
            bi = random.randint(0, len(best_bins) - 1)
            if not best_bins[bi]:
                continue
            item = random.choice(best_bins[bi])
            new_bins = [list(b) for b in best_bins]
            new_bins[bi].remove(item)
            new_bins = [b for b in new_bins if b]
            placed = False
            for b in new_bins:
                load = sum(data["item_sizes"][i] for i in b)
                if load + data["item_sizes"][item] <= data["bin_capacity"]:
                    b.append(item)
                    placed = True
                    break
            if not placed:
                new_bins.append([item])
            if len(new_bins) < best:
                best, best_bins = len(new_bins), new_bins
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, best, "alns", elapsed, True,
                                   {"bins_used": best, "bins": best_bins}, iterations=iterations)


class DynamicPacking(BaseMethod):
    method_id = "dynamic_packing"
    method_label = "Dynamic Item Arrival"
    method_category = "robust"

    def solve(self, instance: ProblemInstance) -> SolveResult:
        t0 = time.perf_counter()
        data = instance.data
        rng = random.Random(42)
        order = list(range(data["n_items"]))
        rng.shuffle(order)
        bins: list[list[int]] = []
        loads: list[int] = []
        for i in order:
            placed = False
            for b, load in enumerate(loads):
                if load + data["item_sizes"][i] <= data["bin_capacity"]:
                    bins[b].append(i)
                    loads[b] += data["item_sizes"][i]
                    placed = True
                    break
            if not placed:
                bins.append([i])
                loads.append(data["item_sizes"][i])
        elapsed = time.perf_counter() - t0
        return self._make_result(instance, len(bins), "dynamic", elapsed, True,
                                   {"bins_used": len(bins), "arrival_order": order})


METHOD_REGISTRY: dict[str, BaseMethod] = {
    cls.method_id: cls  # type: ignore[misc]
    for cls in [
        SptBaseline, CpSatScheduling, GaScheduling, RollingHorizonScheduling,
        NearestDepotRouting, CpSatRouting, AlnsRouting, ScenarioRouting,
        GreedyAssignment, HighsAssignment, LocalSearchAssignment, StochasticAssignment,
        ReorderPointInventory, CpSatInventory, DecompositionInventory, SimulationInventory,
        NearestFacility, CbcFacility, GaFacility, ScenarioFacility,
        FirstFitDecreasing, CpSatPacking, AlnsPacking, DynamicPacking,
    ]
}


def get_method(method_id: str, time_limit_sec: float = 10.0) -> BaseMethod:
    cls = METHOD_REGISTRY.get(method_id)
    if cls is None:
        raise ValueError(f"Unknown method: {method_id}")
    return cls(time_limit_sec)