# ============================================================
# CP-SAT 排产引擎（moduleId: engines-cp, SC-03 首切片，可重生 ✅）
# OR-Tools：产线分配 + 订单级 NoOverlap + 加权延期最小化；
# 工序落槽仍走 RuleEngine 班次占槽（诚实留痕 placement=shift-slot）。
# ============================================================
from __future__ import annotations

from typing import Any, Callable

from server.contracts import ScheduleResult
from server.engines.base import EngineParams
from server.engines.queries import find_product_lines, find_routing_steps
from server.engines.rule_engine import RuleEngine
from server.timeutil import add_minutes, fmt_date, parse_dt, today0

World = dict[str, Any]


def _job_duration_min(world: World, item: dict, line: dict) -> int:
    """连续时间估算：工艺总分钟（含准备；不含跨族矩阵，物化阶段再加）。"""
    eff = float(line.get("efficiencyFactor") or 1.0) or 1.0
    total = 0.0
    for step in find_routing_steps(world, item["productId"]):
        total += float(step["setupTime"]) + (float(item["quantity"]) * float(step["runTimePerUnit"])) / eff
        total += float(step.get("transferTime") or 0) + float(step.get("waitTime") or 0)
    return max(1, int(round(total)))


def _due_minutes(so: dict, base_start, due_buffer: float) -> int:
    due = parse_dt(so["deliveryDate"] + " 18:00")
    if due_buffer < 1.0 - 1e-9:
        span = (due - base_start).total_seconds() / 60.0
        if span > 0:
            due = add_minutes(base_start, span * due_buffer)
    mins = int((due - base_start).total_seconds() / 60.0)
    return max(0, mins)


def build_rule_warm_start(
    world: World,
    entries: list[dict],
    params: EngineParams,
) -> list[dict[str, int]]:
    """按 RULE 启发式选线，构造连续时间上的贪心起止（供 CP AddHint）。"""
    _ = params  # 与 CP 共用签名；当前 hint 不依赖缓冲/冻结（物化阶段再应用）
    cursor_by_line: dict[int, int] = {}
    hints: list[dict[str, int]] = []
    for entry in entries:
        item = entry["item"]
        opts = find_product_lines(world, item["productId"])
        if not opts:
            hints.append({"lineId": -1, "start": 0, "end": 1})
            continue
        # 与 RULE 默认一致：优先级最高的产线
        line_id = int(opts[0]["lineId"])
        line = next(l for l in world["lines"] if l["id"] == line_id)
        dur = _job_duration_min(world, item, line)
        start = cursor_by_line.get(line_id, 0)
        end = start + dur
        hints.append({"lineId": line_id, "start": start, "end": end})
        cursor_by_line[line_id] = end
    return hints


def optimize_line_assignment(
    world: World,
    entries: list[dict],
    params: EngineParams,
    *,
    warm_start: list[dict[str, int]] | None = None,
    pipeline_label: str | None = None,
) -> tuple[list[dict], dict[str, Any]]:
    """
    CP-SAT：每单选一条可行产线，同线订单区间不重叠，最小化加权延期。
    返回：带 forcedLineId 的重排序条目 + solverMeta。
    warm_start：可选 RULE 初解 hint（lineId/start/end）。
    """
    try:
        from ortools.sat.python import cp_model
    except ImportError as exc:  # pragma: no cover
        raise RuntimeError(
            "未安装 ortools，无法运行 CP-SAT。请执行：pip install ortools"
        ) from exc

    from server.aps_domain.params import level_weight as _level_w

    n = len(entries)
    meta: dict[str, Any] = {
        "backend": "OR-Tools CP-SAT",
        "placement": "shift-slot",
        "model": "line-assignment+no-overlap",
    }
    if pipeline_label:
        meta["pipeline"] = pipeline_label
    if warm_start:
        meta["warmStart"] = "RULE"
    if n == 0:
        meta.update({"status": "TRIVIAL", "wallTimeSec": 0.0, "gap": 0.0, "objective": 0})
        return entries, meta

    base_start = (
        parse_dt(params.startDate + " 08:00") if params.startDate
        else add_minutes(today0(), 24 * 60)
    )
    if params.freezeWindowHours is not None and float(params.freezeWindowHours) > 0:
        base_start = add_minutes(base_start, int(float(params.freezeWindowHours) * 60))
    due_buffer = (
        1.0 if params.deliveryBufferRatio is None
        else max(0.5, min(1.0, float(params.deliveryBufferRatio)))
    )
    horizon_days = int(params.planningHorizonDays or 14)
    # 连续时间上界：展望期×每日分钟 + 余量（忽略班次空隙的乐观模型）
    horizon = max(horizon_days * 24 * 60 * 2, 7 * 24 * 60)

    # 预计算候选
    job_opts: list[list[tuple[int, int]]] = []  # [(lineId, duration), ...]
    dues: list[int] = []
    weights: list[int] = []
    for entry in entries:
        so, item = entry["so"], entry["item"]
        opts: list[tuple[int, int]] = []
        for lp in find_product_lines(world, item["productId"]):
            line = next(l for l in world["lines"] if l["id"] == lp["lineId"])
            opts.append((int(lp["lineId"]), _job_duration_min(world, item, line)))
        if not opts:
            # 无产线：仍参与序，物化阶段报 NO_LINE
            opts = [(-1, 1)]
        job_opts.append(opts)
        dues.append(_due_minutes(so, base_start, due_buffer))
        w = int(round(_level_w(world, so.get("customerLevel")) * 100))
        if so.get("isRush"):
            w += 200
        if so.get("isForecast"):
            w = max(1, w // 2)
        weights.append(max(1, w))

    model = cp_model.CpModel()
    intervals_by_line: dict[int, list] = {}
    job_start = []
    job_end = []
    chosen_line_vars: list[list] = []

    for j in range(n):
        starts_j = []
        ends_j = []
        pres_j = []
        line_ids_j = []
        for k, (line_id, dur) in enumerate(job_opts[j]):
            pres = model.NewBoolVar(f"j{j}_k{k}")
            st = model.NewIntVar(0, horizon, f"s{j}_{k}")
            en = model.NewIntVar(0, horizon, f"e{j}_{k}")
            if line_id < 0:
                # 哑元：零冲突占位
                model.Add(st == 0).OnlyEnforceIf(pres)
                model.Add(en == dur).OnlyEnforceIf(pres)
            else:
                iv = model.NewOptionalIntervalVar(st, dur, en, pres, f"iv{j}_{k}")
                intervals_by_line.setdefault(line_id, []).append(iv)
            starts_j.append(st)
            ends_j.append(en)
            pres_j.append(pres)
            line_ids_j.append(line_id)
        model.Add(sum(pres_j) == 1)
        js = model.NewIntVar(0, horizon, f"js{j}")
        je = model.NewIntVar(0, horizon, f"je{j}")
        for st, en, pres in zip(starts_j, ends_j, pres_j):
            model.Add(js == st).OnlyEnforceIf(pres)
            model.Add(je == en).OnlyEnforceIf(pres)
        job_start.append(js)
        job_end.append(je)
        chosen_line_vars.append(list(zip(pres_j, line_ids_j)))

    for _lid, ivs in intervals_by_line.items():
        if len(ivs) >= 2:
            model.AddNoOverlap(ivs)

    # 加权延期
    obj_terms = []
    for j in range(n):
        late = model.NewIntVar(0, horizon, f"late{j}")
        model.Add(late >= job_end[j] - dues[j])
        model.Add(late >= 0)
        obj_terms.append(late * weights[j])
    model.Minimize(sum(obj_terms))

    # RULE 热启动：仅 hint 选线（不 hint 起止，避免部分版本 fixed_search 崩溃）
    if warm_start and len(warm_start) == n:
        for j, hint in enumerate(warm_start):
            want = int(hint.get("lineId", -1))
            for pres, lid in chosen_line_vars[j]:
                model.AddHint(pres, 1 if lid == want else 0)

    solver = cp_model.CpSolver()
    limit = float(params.timeLimitSeconds) if params.timeLimitSeconds is not None else 8.0
    solver.parameters.max_time_in_seconds = max(0.5, limit)
    # 有 hint 时单线程更稳（部分 ortools 在多 worker + hint 下会 check-fail）
    solver.parameters.num_search_workers = 1 if warm_start else 4
    status = solver.Solve(model)

    status_name = {
        cp_model.OPTIMAL: "OPTIMAL",
        cp_model.FEASIBLE: "FEASIBLE",
        cp_model.INFEASIBLE: "INFEASIBLE",
        cp_model.MODEL_INVALID: "MODEL_INVALID",
        cp_model.UNKNOWN: "UNKNOWN",
    }.get(status, str(status))

    wall = round(float(solver.WallTime()), 4)
    meta["status"] = status_name
    meta["wallTimeSec"] = wall
    meta["timeLimitSec"] = limit

    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
        meta["gap"] = None
        meta["objective"] = None
        meta["fallback"] = "heuristic-order"
        # 诚实：无可行解时保留启发式序；若有 warm_start 则带上强制线
        if warm_start and len(warm_start) == n:
            out = []
            for entry, hint in zip(entries, warm_start):
                e = dict(entry)
                if int(hint.get("lineId", -1)) >= 0:
                    e["forcedLineId"] = int(hint["lineId"])
                out.append(e)
            return out, meta
        return entries, meta

    obj = float(solver.ObjectiveValue())
    bound = float(solver.BestObjectiveBound())
    meta["objective"] = obj
    meta["bestBound"] = bound
    if obj > 1e-9:
        meta["gap"] = round(abs(obj - bound) / abs(obj), 6)
    else:
        meta["gap"] = 0.0

    # 读解：选线 + 按开始时间排序
    enriched: list[tuple[float, int, dict]] = []
    for j, entry in enumerate(entries):
        line_id = None
        for pres, lid in chosen_line_vars[j]:
            if solver.Value(pres) == 1:
                line_id = lid if lid >= 0 else None
                break
        e = dict(entry)
        if line_id is not None:
            e["forcedLineId"] = line_id
        enriched.append((solver.Value(job_start[j]), j, e))
    enriched.sort(key=lambda t: (t[0], t[1]))
    return [e for _, _, e in enriched], meta


class CpSatEngine(RuleEngine):
    """SC-03：CP-SAT 产线分配与排序，再班次占槽物化。"""

    name = "CP"
    supports_anytime = True

    def __init__(self) -> None:
        super().__init__(requested_type="CP")

    def solve(self, world: World, params: EngineParams, next_id: Callable[[str], int]) -> ScheduleResult:
        entries, campaign_meta, source_count = self.collect_and_order(world, params)
        try:
            ordered, solver_meta = optimize_line_assignment(
                world, entries, params, pipeline_label="CP-SAT→shift-slot",
            )
        except RuntimeError as exc:
            # 缺依赖：写空版本 + ENGINE_UNAVAILABLE，绝不静默改跑 RULE 却标 CP
            return self._unavailable(world, params, next_id, campaign_meta, source_count, str(exc))
        return self.materialize_schedule(
            world, params, next_id, ordered, campaign_meta, source_count, solver_meta=solver_meta,
        )

    def _unavailable(
        self,
        world: World,
        params: EngineParams,
        next_id: Callable[[str], int],
        campaign_meta: dict[str, Any],
        source_count: int,
        message: str,
    ) -> ScheduleResult:
        from datetime import datetime

        from server.aps_domain.constraints import profile_snapshot
        from server.timeutil import fmt_dt

        now = datetime.now()
        version_id = next_id("scheduleVersion")
        version = {
            "id": version_id,
            "versionNo": "V" + fmt_date(now).replace("-", "") + f"-{len(world['scheduleVersions']) + 1:03d}",
            "versionName": params.name or ("CP 不可用 " + fmt_dt(now)),
            "triggerType": params.triggerType,
            "engineType": "CP",
            "status": "DRAFT",
            "parentVersionId": world["scheduleVersions"][-1]["id"] if world["scheduleVersions"] else None,
            "orderCount": source_count, "poCount": 0, "woCount": 0,
            "totalTardiness": 0.0, "totalCost": 0.0, "avgUtilization": 0.0,
            "conflictCount": 1, "resolvedCount": 0,
            "createdBy": "agent", "createdAt": fmt_dt(now), "publishedAt": None,
            "note": "solver=CP-SAT;status=UNAVAILABLE",
            "constraintProfile": profile_snapshot(world),
            "campaign": campaign_meta,
            "solverMeta": {
                "backend": "OR-Tools CP-SAT", "status": "UNAVAILABLE",
                "wallTimeSec": 0.0, "gap": None, "error": message,
            },
        }
        world["scheduleVersions"].append(version)
        world["conflicts"].append({
            "id": next_id("conflict"), "versionId": version_id,
            "conflictType": "ENGINE_UNAVAILABLE", "severity": "CRITICAL",
            "isResolved": False, "resolutionAction": "",
            "resourceType": "ENGINE", "description": message,
            "suggestedSolution": "pip install ortools 后重试 CP 试排",
        })
        return ScheduleResult(
            versionId=version_id, versionNo=version["versionNo"],
            engineType="CP", strategy=params.strategyTemplate, status="DRAFT",
            orderCount=source_count, poCount=0, woCount=0, conflictCount=1,
            totalTardiness=0.0, avgUtilization=0.0, totalCost=0.0,
            evidenceRefs=[f"run:{version['versionNo']}", "solver:UNAVAILABLE"],
            solveStatus="UNAVAILABLE", solveTimeSec=0.0, optimalityGap=None,
        )


class HybridEngine(RuleEngine):
    """SC-03：HYBRID = RULE 策略序/选线热启动 → CP-SAT 改良 → 班次占槽。"""

    name = "HYBRID"
    supports_anytime = True

    def __init__(self) -> None:
        super().__init__(requested_type="HYBRID")

    def solve(self, world: World, params: EngineParams, next_id: Callable[[str], int]) -> ScheduleResult:
        entries, campaign_meta, source_count = self.collect_and_order(world, params)
        warm = build_rule_warm_start(world, entries, params)
        try:
            ordered, solver_meta = optimize_line_assignment(
                world, entries, params,
                warm_start=warm,
                pipeline_label="RULE→CP-SAT→shift-slot",
            )
        except RuntimeError as exc:
            # 缺 ortools：降级为 RULE 构造并诚实标注（非静默冒充）
            solver_meta = {
                "backend": "HYBRID",
                "pipeline": "RULE→shift-slot",
                "warmStart": "RULE",
                "status": "DEGRADED_RULE",
                "wallTimeSec": 0.0,
                "gap": None,
                "error": str(exc),
            }
            for entry, hint in zip(entries, warm):
                if int(hint.get("lineId", -1)) >= 0:
                    entry["forcedLineId"] = int(hint["lineId"])
            return self.materialize_schedule(
                world, params, next_id, entries, campaign_meta, source_count, solver_meta=solver_meta,
            )
        return self.materialize_schedule(
            world, params, next_id, ordered, campaign_meta, source_count, solver_meta=solver_meta,
        )