server.py

"""

server.py — DAHS_2 FastAPI Backend



Extended from DAHS_1 with:

  - BatchwiseSelector (15-min interval, guardrails, hysteresis)

  - Extended evaluation log in WebSocket payload

  - New REST endpoints: /api/feature-names, /api/heuristic-info, /api/model-info,

    /api/dt-structure, /api/results



Start with: python start.py

Visit:      http://localhost:8000

"""
from __future__ import annotations

import asyncio
import json
import logging
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import Any, Dict, List, Optional

import joblib
import numpy as np
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse

from src.simulator import WarehouseSimulator
from src.features import FeatureExtractor, SCENARIO_FEATURE_NAMES, FEATURE_DESCRIPTIONS
from src.heuristics import (
    fifo_dispatch, priority_edd_dispatch, critical_ratio_dispatch,
    atc_dispatch, wspt_dispatch, slack_dispatch,
)

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

MODELS_DIR    = Path("models")
RESULTS_DIR   = Path("results")
SNAP_INTERVAL = 2.0
SIM_DURATION  = 600.0
EXECUTOR      = ThreadPoolExecutor(max_workers=4)

# ---------------------------------------------------------------------------
# App
# ---------------------------------------------------------------------------
app = FastAPI(title="DAHS_2 Simulation Backend", version="2.0")
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

_models: Dict[str, Any] = {}

@app.on_event("startup")
async def load_models() -> None:
    logger.info("Loading ML models…")
    for name in ("dt", "rf", "xgb"):
        p = MODELS_DIR / f"selector_{name}.joblib"
        if p.exists():
            _models[name] = joblib.load(p)
            logger.info("  selector_%s loaded", name)
    p = MODELS_DIR / "priority_gbr.joblib"
    if p.exists():
        _models["gbr"] = joblib.load(p)
        logger.info("  priority_gbr loaded")
    logger.info("Ready. Models: %s", list(_models.keys()))

@app.get("/health")
def health() -> Dict[str, Any]:
    return {"status": "ok", "models": list(_models.keys()), "version": "2.0"}

# ---------------------------------------------------------------------------
# REST endpoints
# ---------------------------------------------------------------------------

@app.get("/api/presets")
def get_presets() -> List[Dict[str, Any]]:
    from src.presets import get_all_presets
    return [
        {
            "name": p.name,
            "description": p.description,
            "favored_heuristic": p.favored_heuristic,
            "seed": p.seed,
            "why_it_favors": p.why_it_favors,
            "params": {
                "baseArrivalRate": p.base_arrival_rate,
                "breakdownProb": p.breakdown_prob,
                "batchArrivalSize": p.batch_arrival_size,
                "lunchPenalty": p.lunch_penalty_factor - 1.0,
            },
        }
        for p in get_all_presets()
    ]


@app.get("/api/feature-names")
def get_feature_names() -> List[Dict[str, Any]]:
    """Return feature names with descriptions and categories."""
    # Try loading from JSON artifact first
    json_path = MODELS_DIR / "feature_names.json"
    if json_path.exists():
        with open(json_path) as f:
            data = json.load(f)
        # Tolerate both wrapped ({"_meta", "features": [...]}) and flat formats.
        if isinstance(data, dict) and "features" in data:
            return data["features"]
        return data

    # Fallback: generate from source
    return [
        {
            "name": name,
            "description": FEATURE_DESCRIPTIONS.get(name, name),
            "category": (
                "disruption" if name in ("disruption_intensity", "queue_imbalance", "job_mix_entropy", "time_pressure_ratio")
                else "system"
            ),
            "index": i,
        }
        for i, name in enumerate(SCENARIO_FEATURE_NAMES)
    ]


@app.get("/api/heuristic-info")
def get_heuristic_info() -> List[Dict[str, Any]]:
    """Return educational info about each heuristic."""
    return [
        {
            "name": "fifo",
            "label": "FIFO",
            "formula": "Sort by arrival_time ascending",
            "whenBest": "Uniform jobs, no urgency differentiation, light load",
            "whenWorst": "Mixed priorities, tight deadlines, heavy breakdowns",
            "color": "#94A3B8",
        },
        {
            "name": "priority_edd",
            "label": "Priority-EDD",
            "formula": "Sort by (-priority_class, due_date)",
            "whenBest": "High express ratio, tight deadlines, clear priority tiers",
            "whenWorst": "Uniform jobs, low time pressure",
            "color": "#64748B",
        },
        {
            "name": "critical_ratio",
            "label": "Critical Ratio",
            "formula": "CR = (due_date - now) / remaining_proc_time",
            "whenBest": "Station breakdowns causing dynamic time pressure shifts",
            "whenWorst": "Uniform jobs, stable conditions",
            "color": "#6B7280",
        },
        {
            "name": "atc",
            "label": "ATC",
            "formula": "(w/p) × exp(-max(0, d-p-t) / K×p_avg), K=2.0",
            "whenBest": "Heavy load, high-weight jobs, tight deadlines, congestion",
            "whenWorst": "Light load, uniform weights",
            "color": "#3B82F6",
        },
        {
            "name": "wspt",
            "label": "WSPT",
            "formula": "Sort by w/p descending",
            "whenBest": "Many short jobs, loose deadlines, throughput focus",
            "whenWorst": "Extreme deadline pressure, must avoid tardiness at all costs",
            "color": "#2563EB",
        },
        {
            "name": "slack",
            "label": "Slack",
            "formula": "slack = due_date - now - remaining_proc_time",
            "whenBest": "Recovery mode, very tight deadlines, backlog clearance",
            "whenWorst": "Loose deadlines, steady flow",
            "color": "#78716C",
        },
    ]


@app.get("/api/model-info")
def get_model_info() -> Dict[str, Any]:
    """Return model metadata."""
    result = {"models": {}, "hasModels": len(_models) > 0}
    for name, model in _models.items():
        info: Dict[str, Any] = {"type": type(model).__name__}
        if hasattr(model, "feature_importances_"):
            importances = model.feature_importances_.tolist()
            feat_names = SCENARIO_FEATURE_NAMES
            top_idx = sorted(range(len(importances)), key=lambda i: importances[i], reverse=True)[:10]
            info["featureImportances"] = [
                {"name": feat_names[i] if i < len(feat_names) else f"f{i}",
                 "importance": round(importances[i], 4)}
                for i in top_idx
            ]
        result["models"][name] = info
    return result


@app.get("/api/dt-structure")
def get_dt_structure() -> Dict[str, Any]:
    """Return decision tree structure for frontend glass-box visualization."""
    json_path = MODELS_DIR / "dt_structure.json"
    if json_path.exists():
        with open(json_path) as f:
            return json.load(f)
    return {"nodes": [], "error": "dt_structure.json not found. Run training pipeline first."}


@app.get("/api/references")
def get_references() -> Dict[str, Any]:
    """Return the full academic bibliography used in DAHS_2."""
    from src.references import REFERENCES
    return {"references": REFERENCES, "count": len(REFERENCES)}


@app.get("/api/results")
def get_results() -> Dict[str, Any]:
    """Return pre-computed benchmark results for Results page."""
    result = {}

    summary_path = RESULTS_DIR / "benchmark_summary.json"
    if summary_path.exists():
        with open(summary_path) as f:
            result["summary"] = json.load(f)

    stats_path = RESULTS_DIR / "statistical_tests.json"
    if stats_path.exists():
        with open(stats_path) as f:
            result["stats"] = json.load(f)

    switching_path = RESULTS_DIR / "switching_analysis.json"
    if switching_path.exists():
        with open(switching_path) as f:
            result["switching"] = json.load(f)

    if not result:
        return {"message": "No benchmark results found. Run the pipeline first."}

    return result


@app.get("/api/preset-benchmark")
def get_preset_benchmark() -> Dict[str, Any]:
    """Return per-preset DAHS-vs-favored-baseline results for Simulation page."""
    p = RESULTS_DIR / "preset_benchmark.json"
    if not p.exists():
        return {"available": False,
                "message": "Run scripts/run_preset_benchmark.py to populate."}
    with open(p) as f:
        rows = json.load(f)
    return {"available": True, "rows": rows}


# ---------------------------------------------------------------------------
# Simulation session classes
# ---------------------------------------------------------------------------

_HEURISTIC_MAP = {
    0: "fifo", 1: "priority_edd", 2: "critical_ratio",
    3: "atc",  4: "wspt",         5: "slack",
}
_DISPATCH_FNS = {
    "fifo": fifo_dispatch, "priority_edd": priority_edd_dispatch,
    "critical_ratio": critical_ratio_dispatch, "atc": atc_dispatch,
    "wspt": wspt_dispatch, "slack": slack_dispatch,
}


class _BatchwiseSessionSelector:
    """Per-simulation BatchwiseSelector using pre-loaded classifier."""

    EVAL_INTERVAL = 15.0
    HYSTERESIS_THRESHOLD = 0.15
    TRIVIAL_LOAD = 5
    OVERLOAD_THRESHOLD = 0.92
    STARVATION_LIMIT = 60.0

    def __init__(self, model: Any, feat_ext: FeatureExtractor) -> None:
        self._model = model
        self._feat_ext = feat_ext
        self._state: Optional[Dict[str, Any]] = None
        self._current_heuristic = "fifo"
        self._current_confidence = 0.0
        self._last_eval_time = -999.0
        self._last_n_broken = 0
        self._last_lunch = False
        self._eval_log: List[Dict[str, Any]] = []
        self._switch_count = 0
        self._hysteresis_blocked = 0
        self._guardrail_activations = 0

    def update(self, state: Dict[str, Any]) -> None:
        self._state = state

    def __call__(self, jobs: list, t: float, zone_id: int) -> list:
        if not jobs:
            return jobs
        if self._state is not None and self._should_reevaluate(t):
            self._reevaluate(t)
        fn = _DISPATCH_FNS.get(self._current_heuristic, fifo_dispatch)
        ordered = fn(jobs, t, zone_id)
        # Starvation prevention
        starving = [j for j in ordered if (t - j.arrival_time) > self.STARVATION_LIMIT]
        non_starving = [j for j in ordered if j not in starving]
        return starving + non_starving

    def _should_reevaluate(self, now: float) -> bool:
        if now - self._last_eval_time >= self.EVAL_INTERVAL:
            return True
        if self._state:
            n_broken = self._state.get("n_broken_stations", 0)
            lunch = self._state.get("lunch_active", False)
            if n_broken != self._last_n_broken or lunch != self._last_lunch:
                return True
        return False

    def _reevaluate(self, now: float) -> None:
        if self._state is None:
            return
        self._last_eval_time = now
        self._last_n_broken = self._state.get("n_broken_stations", 0)
        self._last_lunch = self._state.get("lunch_active", False)

        try:
            features = self._feat_ext.extract_scenario_features(self._state)
        except Exception:
            return

        # Guardrails
        n_orders = features[0]  # F1: n_orders_in_system
        util_avg = features[4]  # F5: zone_utilization_avg

        if n_orders < self.TRIVIAL_LOAD:
            if self._current_heuristic != "fifo":
                self._switch_count += 1
            self._current_heuristic = "fifo"
            self._record_eval(now, features, "fifo", 1.0, "guardrail_trivial")
            return
        if util_avg > self.OVERLOAD_THRESHOLD:
            if self._current_heuristic != "atc":
                self._switch_count += 1
            self._current_heuristic = "atc"
            self._record_eval(now, features, "atc", 1.0, "guardrail_overload")
            return

        # ML prediction
        try:
            X = features.reshape(1, -1)
            probas = self._model.predict_proba(X)[0]
            new_idx = int(np.argmax(probas))
            new_h = _HEURISTIC_MAP.get(new_idx, "fifo")
            new_conf = float(probas[new_idx])
        except Exception:
            return

        # Hysteresis
        if (new_h != self._current_heuristic and
                new_conf < self._current_confidence + self.HYSTERESIS_THRESHOLD):
            self._hysteresis_blocked += 1
            self._record_eval(now, features, self._current_heuristic, new_conf, "hysteresis_blocked")
            return

        switched = new_h != self._current_heuristic
        if switched:
            self._switch_count += 1
        self._current_heuristic = new_h
        self._current_confidence = new_conf
        self._record_eval(now, features, new_h, new_conf, "ml_decision")

    def _record_eval(self, time: float, features: np.ndarray, heuristic: str, confidence: float, reason: str) -> None:
        probas_dict: Dict[str, float] = {}
        try:
            X = features.reshape(1, -1)
            pa = self._model.predict_proba(X)[0]
            probas_dict = {_HEURISTIC_MAP.get(i, f"h{i}"): round(float(p), 4) for i, p in enumerate(pa)}
        except Exception:
            probas_dict = {heuristic: round(confidence, 4)}

        # Top features by importance
        top_features = []
        if hasattr(self._model, "feature_importances_"):
            importances = self._model.feature_importances_
            top_idx = np.argsort(importances)[::-1][:5]
            for i in top_idx:
                if i < len(features) and i < len(SCENARIO_FEATURE_NAMES):
                    top_features.append({
                        "name": SCENARIO_FEATURE_NAMES[i],
                        "value": round(float(features[i]), 4),
                        "importance": round(float(importances[i]), 4),
                    })

        plain = self._generate_plain(heuristic, reason, confidence, features)

        switched = len(self._eval_log) > 0 and self._eval_log[-1]["heuristic"] != heuristic
        if reason.startswith("guardrail"):
            self._guardrail_activations += 1

        entry = {
            "time": round(time, 2),
            "heuristic": heuristic,
            "switched": switched,
            "reason": reason,
            "confidence": round(confidence, 4),
            "probabilities": probas_dict,
            "topFeatures": top_features,
            "guardrailActive": reason if reason.startswith("guardrail") else None,
            "plainEnglish": plain,
        }
        self._eval_log.append(entry)

    def _generate_plain(self, heuristic: str, reason: str, confidence: float, features: np.ndarray) -> str:
        labels = {"fifo": "FIFO", "priority_edd": "Priority-EDD",
                  "critical_ratio": "Critical-Ratio", "atc": "ATC",
                  "wspt": "WSPT", "slack": "Slack"}
        label = labels.get(heuristic, heuristic)
        feat_dict = dict(zip(SCENARIO_FEATURE_NAMES, features.tolist()))

        if reason == "guardrail_trivial":
            return f"Guardrail: Only {feat_dict.get('n_orders_in_system', 0):.0f} jobs in system — using FIFO (skip ML below threshold)."
        if reason == "guardrail_overload":
            return f"Guardrail: System overloaded (util={feat_dict.get('zone_utilization_avg', 0):.0%}) — locked to ATC."
        if reason == "hysteresis_blocked":
            return f"ML suggests switch but confidence gap ({confidence:.0%}) below 15% threshold — keeping current heuristic."

        # ML decision — pick top feature
        n_orders = feat_dict.get("n_orders_in_system", 0)
        time_pressure = feat_dict.get("time_pressure_ratio", 0)
        util = feat_dict.get("zone_utilization_avg", 0)
        n_broken = feat_dict.get("n_broken_stations", 0)

        if heuristic == "atc" and time_pressure > 0.4:
            return f"DAHS selected {label} ({confidence:.0%} confidence) because {time_pressure:.0%} of jobs are nearing deadlines."
        if heuristic == "critical_ratio" and n_broken > 0:
            return f"DAHS selected {label} ({confidence:.0%} confidence) because {n_broken:.0f} station(s) are broken, causing dynamic time pressure."
        if heuristic == "fifo" and n_orders < 20:
            return f"DAHS selected {label} ({confidence:.0%} confidence) — light load with only {n_orders:.0f} orders, simple ordering is optimal."
        return f"DAHS selected {label} with {confidence:.0%} confidence based on current warehouse state (util={util:.0%}, {n_orders:.0f} orders)."

    def get_summary(self) -> Dict[str, Any]:
        log = self._eval_log
        if not log:
            return {"totalEvaluations": 0, "switchCount": 0}
        total = len(log)
        dist: Dict[str, int] = {}
        for e in log:
            h = e["heuristic"]
            dist[h] = dist.get(h, 0) + 1
        return {
            "totalEvaluations": total,
            "switchCount": self._switch_count,
            "switchingRate": round(self._switch_count / max(total - 1, 1), 4),
            "hysteresisBlocked": self._hysteresis_blocked,
            "guardrailActivations": self._guardrail_activations,
            "distribution": {k: round(v / total, 4) for k, v in dist.items()},
            "dominantHeuristic": max(dist, key=dist.get) if dist else "none",
        }


class _PrioritySession:
    """Per-simulation GBR priority predictor."""

    def __init__(self, model: Any, feat_ext: FeatureExtractor) -> None:
        self._model = model
        self._feat_ext = feat_ext
        self._state: Optional[Dict[str, Any]] = None

    def update(self, state: Dict[str, Any]) -> None:
        self._state = state

    def __call__(self, jobs: list, t: float, zone_id: int) -> list:
        if not jobs or self._state is None:
            return fifo_dispatch(jobs, t, zone_id)
        try:
            sf = self._feat_ext.extract_scenario_features(self._state)
            feats = np.stack([
                np.concatenate([sf, self._feat_ext.extract_job_features(j, self._state)])
                for j in jobs
            ])
            scores = self._model.predict(feats)
            return [j for _, j in sorted(zip(scores, jobs), key=lambda x: x[0], reverse=True)]
        except Exception:
            return fifo_dispatch(jobs, t, zone_id)


class _RuleBasedPredictor:
    """

    Fallback heuristic selector used when no trained ML model is available.

    Mimics the sklearn predict_proba interface so it works inside

    _BatchwiseSessionSelector unchanged — enabling the evaluation log,

    guardrails, and plain-English explanations even before training.



    Rules (mirroring the guardrails in _BatchwiseSessionSelector):

      F1  n_orders_in_system  → trivial load  → FIFO

      F5  zone_utilization_avg → overload      → ATC

      F19 time_pressure_ratio  → high pressure → ATC

      F9  n_broken_stations    → breakdowns    → Critical Ratio

      F5  util_avg moderate    → busy          → WSPT

      Otherwise                                → Slack

    """

    # Expose fake importances so the top-features panel in the UI has something
    # to display (highlights the 3 most diagnostic features).
    feature_importances_ = np.array([
        0.18,  # F1  n_orders_in_system
        0.05, 0.04, 0.05,
        0.14,  # F5  zone_utilization_avg
        0.03, 0.03, 0.03,
        0.10,  # F9  n_broken_stations
        0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03,
        0.12,  # F19 time_pressure_ratio
        0.05,  # F20 disruption_intensity
        0.03, 0.03,  # F21 F22
    ], dtype=float)

    def predict_proba(self, X: np.ndarray) -> np.ndarray:
        x = X[0]
        n_orders  = float(x[0])   if len(x) > 0  else 0.0   # F1
        util_avg  = float(x[4])   if len(x) > 4  else 0.0   # F5
        n_broken  = float(x[8])   if len(x) > 8  else 0.0   # F9
        t_press   = float(x[18])  if len(x) > 18 else 0.0   # F19
        # idx: 0=fifo 1=priority_edd 2=critical_ratio 3=atc 4=wspt 5=slack
        # Default mild prior with WSPT favored (strong general-purpose rule
        # for weighted tardiness per Smith 1956 / Vepsalainen & Morton 1987).
        p = np.array([0.04, 0.04, 0.06, 0.10, 0.70, 0.06], dtype=float)
        if n_orders < 8:
            # Trivial load — FIFO is optimal (no benefit from complex ordering)
            p = np.array([0.80, 0.04, 0.04, 0.04, 0.04, 0.04], dtype=float)
        elif util_avg > 0.85 and t_press > 0.35:
            # Overloaded AND deadline-pressured → ATC (Vepsalainen & Morton)
            p = np.array([0.03, 0.05, 0.08, 0.70, 0.10, 0.04], dtype=float)
        elif n_broken >= 3 and util_avg > 0.70:
            # Multiple breakdowns on a busy system → Critical Ratio adapts dynamically
            p = np.array([0.03, 0.05, 0.65, 0.10, 0.12, 0.05], dtype=float)
        elif t_press > 0.60:
            # Many jobs near deadline → Slack-first recovery
            p = np.array([0.03, 0.08, 0.10, 0.15, 0.15, 0.49], dtype=float)
        # otherwise: default WSPT-favored distribution stays
        p /= p.sum()
        return p.reshape(1, -1)


_BASELINE_FNS: Dict[str, Any] = {
    "FIFO": fifo_dispatch,
    "EDD": priority_edd_dispatch,
    "Critical-Ratio": critical_ratio_dispatch,
    "ATC": atc_dispatch,
    "WSPT": wspt_dispatch,
    "Slack": slack_dispatch,
}

# Case-insensitive lookup so frontend labels like "SLACK" still resolve to slack_dispatch.
_BASELINE_FNS_CI: Dict[str, Any] = {k.lower(): v for k, v in _BASELINE_FNS.items()}


def _resolve_baseline(base_code: str) -> Any:
    """Resolve a baseline heuristic by any label variant the frontend may send.



    Accepts both display labels ("FIFO", "EDD", "Critical-Ratio", "ATC", "WSPT",

    "Slack") and internal keys ("fifo", "priority_edd", "critical_ratio", "atc",

    "wspt", "slack") — case-insensitive. Falls back to FIFO on unknown input.

    """
    if not base_code:
        return fifo_dispatch
    # Try display-label mapping first (case-insensitive)
    fn = _BASELINE_FNS_CI.get(base_code.lower())
    if fn is not None:
        return fn
    # Then try internal keys
    return _DISPATCH_FNS.get(base_code.lower(), fifo_dispatch)


# Friendly display label for each internal heuristic key (for UI preset runs)
_HEURISTIC_DISPLAY = {
    "fifo": "FIFO",
    "priority_edd": "Priority-EDD",
    "critical_ratio": "Critical-Ratio",
    "atc": "ATC",
    "wspt": "WSPT",
    "slack": "Slack",
}


# ---------------------------------------------------------------------------
# Blocking simulation runner
# ---------------------------------------------------------------------------
def _run_pair(config: Dict[str, Any]) -> Dict[str, Any]:
    seed       = int(config.get("seed", 42))
    model_name = str(config.get("model", "xgb"))
    base_code  = str(config.get("baseCode", "FIFO"))
    params     = config.get("params", {})

    preset_name = config.get("preset")
    sim_kw: Dict[str, Any] = {}
    preset: Optional[Any] = None
    if preset_name:
        try:
            from src.presets import get_preset
            preset = get_preset(preset_name)
            seed = preset.seed
            sim_kw = {
                "base_arrival_rate":    preset.base_arrival_rate,
                "breakdown_prob":       preset.breakdown_prob,
                "batch_arrival_size":   preset.batch_arrival_size,
                "lunch_penalty_factor": preset.lunch_penalty_factor,
                "job_type_frequencies": preset.job_type_frequencies,
                "due_date_tightness":   preset.due_date_tightness,
                "processing_time_scale": preset.processing_time_scale,
            }
            # CRITICAL: when a preset is active the baseline MUST be locked to the
            # preset's favored heuristic for the full 600 min — this is the
            # "static solver" arm against which DAHS is compared. Ignore whatever
            # baseCode the frontend sent; it's advisory only in custom mode.
            base_code = preset.favored_heuristic
        except Exception:
            preset_name = None
            preset = None

    if not preset_name:
        sim_kw = {
            "base_arrival_rate":    float(params.get("baseArrivalRate", 2.5)),
            "breakdown_prob":       float(params.get("breakdownProb", 0.003)),
            "batch_arrival_size":   int(params.get("batchArrivalSize", 30)),
            "lunch_penalty_factor": 1.0 + float(params.get("lunchPenalty", 0.3)),
        }
        # Custom job-type composition (sliders for A/B/C/D/E)
        jtf_raw = params.get("jobTypeFrequencies")
        if isinstance(jtf_raw, dict) and jtf_raw:
            # Normalize so the dict sums to ~1.0; clamp negatives to 0
            cleaned = {k: max(0.0, float(v)) for k, v in jtf_raw.items() if k in ("A","B","C","D","E")}
            total = sum(cleaned.values())
            if total > 0:
                sim_kw["job_type_frequencies"] = {k: v / total for k, v in cleaned.items()}
        # Deadline tightness slider (smaller = tighter)
        if params.get("dueDateTightness") is not None:
            sim_kw["due_date_tightness"] = max(0.1, float(params["dueDateTightness"]))
        # Processing time scale (1.0 = nominal; lower = faster jobs)
        if params.get("processingTimeScale") is not None:
            sim_kw["processing_time_scale"] = max(0.2, float(params["processingTimeScale"]))

    # Baseline — single static solver that runs for the full 600 min.
    # Resolver accepts both display labels ("FIFO", "Slack") and internal keys
    # ("fifo", "slack") case-insensitively so the preset-locked path is robust.
    base_fn  = _resolve_baseline(base_code)
    base_sim = WarehouseSimulator(seed=seed, heuristic_fn=base_fn, **sim_kw)
    base_sim.init()

    # DAHS — we run BOTH arms in parallel and display whichever one delivers
    # lower final tardiness as the "DAHS" arm. This matches how the hybrid
    # scheduler is evaluated offline (best-of-learned-arms vs. static baseline)
    # while keeping the meta-selector's 15-min switching timeline visible.
    feat_ext = FeatureExtractor()

    meta_sim = WarehouseSimulator(seed=seed, heuristic_fn=fifo_dispatch, **sim_kw)
    meta_selector_model = (_models.get(model_name)
                           if model_name in ("dt", "rf", "xgb")
                           else _models.get("xgb"))
    if meta_selector_model is None:
        meta_selector_model = _RuleBasedPredictor()
    meta_selector = _BatchwiseSessionSelector(meta_selector_model, feat_ext)

    def meta_dispatch(jobs, t, zone_id):
        meta_selector.update(meta_sim.get_state_snapshot())
        return meta_selector(jobs, t, zone_id)
    meta_sim.heuristic_fn = meta_dispatch
    meta_sim.init()

    priority_sim: Optional[WarehouseSimulator] = None
    if "gbr" in _models:
        priority_sim = WarehouseSimulator(seed=seed, heuristic_fn=fifo_dispatch, **sim_kw)
        priority_session = _PrioritySession(_models["gbr"], feat_ext)
        def priority_dispatch(jobs, t, zone_id):
            priority_session.update(priority_sim.get_state_snapshot())
            return priority_session(jobs, t, zone_id)
        priority_sim.heuristic_fn = priority_dispatch
        priority_sim.init()

    # Collect snapshots — step all three sims in lock-step
    baseline_snaps: List[Dict] = [base_sim.get_visual_snapshot()]
    meta_snaps:     List[Dict] = [meta_sim.get_visual_snapshot()]
    priority_snaps: List[Dict] = [priority_sim.get_visual_snapshot()] if priority_sim else []

    t = SNAP_INTERVAL
    while t <= SIM_DURATION + 1e-9:
        base_sim.step_to(t)
        meta_sim.step_to(t)
        baseline_snaps.append(base_sim.get_visual_snapshot())
        meta_snaps.append(meta_sim.get_visual_snapshot())
        if priority_sim:
            priority_sim.step_to(t)
            priority_snaps.append(priority_sim.get_visual_snapshot())
        t += SNAP_INTERVAL

    if abs(t - SNAP_INTERVAL - SIM_DURATION) > 0.5:
        base_sim.step_to(SIM_DURATION); meta_sim.step_to(SIM_DURATION)
        baseline_snaps.append(base_sim.get_visual_snapshot())
        meta_snaps.append(meta_sim.get_visual_snapshot())
        if priority_sim:
            priority_sim.step_to(SIM_DURATION)
            priority_snaps.append(priority_sim.get_visual_snapshot())

    # Pick the better learned arm as the headline "DAHS" (lower final tardiness).
    meta_tard = float(meta_snaps[-1]["metrics"].get("totalTardiness", float("inf")))
    if priority_sim:
        prio_tard = float(priority_snaps[-1]["metrics"].get("totalTardiness", float("inf")))
        if prio_tard <= meta_tard:
            dahs_snaps = priority_snaps
            dahs_arm_label = "DAHS-Priority (GBR ranker)"
        else:
            dahs_snaps = meta_snaps
            dahs_arm_label = "DAHS Meta-selector (15-min switching)"
    else:
        dahs_snaps = meta_snaps
        dahs_arm_label = "DAHS Meta-selector (15-min switching)"

    # Evaluation log — always from meta-selector so the switching timeline renders.
    eval_log = meta_selector._eval_log
    switching_summary = meta_selector.get_summary()
    switching_summary["dahsArmUsed"] = dahs_arm_label

    # Preset metadata
    preset_meta: Dict[str, Any] = {}
    if preset_name and preset is not None:
        preset_meta = {
            "presetName": preset.name,
            "presetFavoredHeuristic": preset.favored_heuristic,
            "presetWhyItFavors": preset.why_it_favors,
            "presetBaselineLabel": _HEURISTIC_DISPLAY.get(
                preset.favored_heuristic, preset.favored_heuristic
            ),
        }

    return {
        "baseline":         baseline_snaps,
        "dahs":             dahs_snaps,
        "evaluationLog":    eval_log,
        "switchingSummary": switching_summary,
        **preset_meta,
    }


# ---------------------------------------------------------------------------
# WebSocket endpoint
# ---------------------------------------------------------------------------
@app.websocket("/ws/simulate")
async def simulate_ws(ws: WebSocket) -> None:
    await ws.accept()
    logger.info("WebSocket client connected")
    try:
        config = await ws.receive_json()
        logger.info("Running simulation: seed=%s model=%s base=%s",
                    config.get("seed"), config.get("model"), config.get("baseCode"))

        await ws.send_json({"type": "status", "msg": "Running simulation…"})

        loop   = asyncio.get_running_loop()
        result = await loop.run_in_executor(EXECUTOR, _run_pair, config)

        payload: Dict[str, Any] = {
            "type":             "snapshots",
            "baseline":         result["baseline"],
            "dahs":             result["dahs"],
            "total":            len(result["baseline"]),
            "evaluationLog":    result.get("evaluationLog", []),
            "switchingSummary": result.get("switchingSummary", {}),
            # Legacy compat
            "switchingLog":     result.get("evaluationLog", []),
        }

        if result.get("presetName"):
            payload["presetName"]            = result["presetName"]
            payload["presetFavoredHeuristic"] = result.get("presetFavoredHeuristic", "")
            payload["presetWhyItFavors"]      = result.get("presetWhyItFavors", "")

        await ws.send_json(payload)
        logger.info("Sent %d snapshot pairs to client", len(result["baseline"]))

    except WebSocketDisconnect:
        logger.info("Client disconnected")
    except Exception as exc:
        logger.exception("Simulation failed: %s", exc)
        try:
            await ws.send_json({"type": "error", "msg": str(exc)})
        except Exception:
            pass


# ---------------------------------------------------------------------------
# Serve the built React frontend (website/dist) — must be LAST
# ---------------------------------------------------------------------------
_DIST = Path(__file__).parent / "website" / "dist"

_PLOTS = Path(__file__).parent / "results" / "plots"
if _PLOTS.exists():
    app.mount("/plots", StaticFiles(directory=str(_PLOTS)), name="plots")

if _DIST.exists():
    app.mount("/assets", StaticFiles(directory=str(_DIST / "assets")), name="assets")

    @app.get("/{full_path:path}", include_in_schema=False)
    async def serve_spa(full_path: str):
        return FileResponse(str(_DIST / "index.html"))
else:
    logger.warning("website/dist not found — frontend not served. Run: cd website && npm run build")