# ============================================================
# 计划层 AP（moduleId: domain-planning, PL-01~06，可重生 ✅）
# 分桶 / 粗能力 / 可行性 / 削峰 / 产供方向决策（只读）
# ============================================================
from __future__ import annotations

from calendar import monthrange
from datetime import datetime, timedelta
from typing import Any

from server.aps_domain.orders import SCHEDULABLE_STATUSES
from server.timeutil import add_minutes, fmt_date, parse_dt, today0

World = dict[str, Any]

BUCKET_MODES = {"DAY", "WEEK", "MONTH", "HYBRID"}
CAPACITY_MODES = {"FINITE", "INFINITE"}
WARN_RATIO = 0.85


def _as_date(s: str) -> datetime:
    return parse_dt(s[:10] + " 00:00")


def _monday(d: datetime) -> datetime:
    return d - timedelta(days=d.weekday())


def _month_start(d: datetime) -> datetime:
    return d.replace(day=1, hour=0, minute=0, second=0, microsecond=0)


def _add_days(d: datetime, n: int) -> datetime:
    return add_minutes(d, n * 24 * 60)


def _workdays_inclusive(start: datetime, end: datetime) -> int:
    """桶内工作日数（周一～周五，含起止）。"""
    if end < start:
        return 0
    n = 0
    cur = start
    while cur <= end:
        if cur.weekday() < 5:
            n += 1
        cur = _add_days(cur, 1)
    return n


def daily_capacity(world: World) -> float:
    """ACTIVE 产线日产能合计（件/天，含效率因子）。"""
    total = 0.0
    for line in world.get("lines", []):
        if line.get("status") != "ACTIVE":
            continue
        cap = float(line.get("capacityPerDay") or 0)
        eff = float(line.get("efficiencyFactor") if line.get("efficiencyFactor") is not None else 1.0)
        total += cap * eff
    return round(total, 1)


def _bucket_spec(kind: str, start: datetime, end: datetime, label: str | None = None) -> dict[str, Any]:
    return {
        "kind": kind,
        "key": f"{kind}:{fmt_date(start)}",
        "label": label or _default_label(kind, start, end),
        "start": fmt_date(start),
        "end": fmt_date(end),
        "workdays": _workdays_inclusive(start, end),
    }


def _default_label(kind: str, start: datetime, end: datetime) -> str:
    if kind == "DAY":
        return start.strftime("%m-%d")
    if kind == "WEEK":
        iso = start.isocalendar()
        return f"W{iso.week:02d}"
    if kind == "MONTH":
        return start.strftime("%Y-%m")
    return f"{fmt_date(start)}~{fmt_date(end)}"


def _iter_day_buckets(start: datetime, days: int) -> list[dict[str, Any]]:
    out = []
    for i in range(max(0, days)):
        d = _add_days(start, i)
        out.append(_bucket_spec("DAY", d, d))
    return out


def _iter_week_buckets(start: datetime, end: datetime) -> list[dict[str, Any]]:
    out = []
    cur = _monday(start)
    last = end
    while cur <= last:
        week_end = _add_days(cur, 6)
        # 裁剪到展望窗
        b_start = max(cur, start)
        b_end = min(week_end, last)
        if b_start <= b_end:
            out.append(_bucket_spec("WEEK", b_start, b_end))
        cur = _add_days(cur, 7)
    return out


def _iter_month_buckets(start: datetime, end: datetime) -> list[dict[str, Any]]:
    out = []
    cur = _month_start(start)
    last = end
    while cur <= last:
        last_day = monthrange(cur.year, cur.month)[1]
        month_end = cur.replace(day=last_day)
        b_start = max(cur, start)
        b_end = min(month_end, last)
        if b_start <= b_end:
            out.append(_bucket_spec("MONTH", b_start, b_end))
        # 下一月
        if cur.month == 12:
            cur = cur.replace(year=cur.year + 1, month=1, day=1)
        else:
            cur = cur.replace(month=cur.month + 1, day=1)
    return out


def build_bucket_skeleton(
    *,
    mode: str = "HYBRID",
    start_date: str | None = None,
    horizon_days: int = 90,
) -> list[dict[str, Any]]:
    """生成空分桶骨架（无需求/能力数字）。"""
    mode = (mode or "HYBRID").upper()
    if mode not in BUCKET_MODES:
        raise ValueError("mode 必须是 DAY/WEEK/MONTH/HYBRID")
    horizon_days = max(1, min(int(horizon_days or 90), 366))
    start = _as_date(start_date) if start_date else today0()
    end = _add_days(start, horizon_days - 1)

    if mode == "DAY":
        return _iter_day_buckets(start, horizon_days)
    if mode == "WEEK":
        return _iter_week_buckets(start, end)
    if mode == "MONTH":
        return _iter_month_buckets(start, end)

    # HYBRID：近 7 日 → 随后约 4 周按周 → 其余按月（对齐康尼短中长期口径）
    near_days = min(7, horizon_days)
    buckets = _iter_day_buckets(start, near_days)
    if horizon_days <= near_days:
        return buckets
    mid_start = _add_days(start, near_days)
    mid_span = min(28, horizon_days - near_days)  # ~4 周
    mid_end = _add_days(mid_start, mid_span - 1)
    buckets.extend(_iter_week_buckets(mid_start, mid_end))
    if horizon_days > near_days + mid_span:
        far_start = _add_days(mid_end, 1)
        buckets.extend(_iter_month_buckets(far_start, end))
    return buckets


def _in_bucket(date_s: str, bucket: dict[str, Any]) -> bool:
    d = date_s[:10]
    return bucket["start"] <= d <= bucket["end"]


def _collect_demands(world: World, *, include_forecast: bool) -> list[dict[str, Any]]:
    """收集待分桶需求点：确定订单 + ACTIVE 预测。"""
    points: list[dict[str, Any]] = []
    for so in world.get("salesOrders", []):
        if so.get("status") not in SCHEDULABLE_STATUSES:
            continue
        due = str(so.get("deliveryDate") or "")[:10]
        if not due:
            continue
        for item in so.get("items") or []:
            if item.get("status") in ("CANCELLED", "COMPLETED"):
                continue
            qty = int(item.get("quantity") or 0)
            if qty <= 0:
                continue
            points.append({
                "source": "FIRM",
                "ref": so.get("orderNo"),
                "productId": item.get("productId"),
                "productCode": item.get("productCode"),
                "productName": item.get("productName"),
                "quantity": qty,
                "weightedQty": float(qty),
                "dueDate": due,
            })
    if include_forecast:
        from server.aps_domain.forecast import ensure_forecast_table
        ensure_forecast_table(world)
        for fc in world.get("forecastOrders", []):
            if fc.get("status") != "ACTIVE":
                continue
            due = str(fc.get("dueDate") or fc.get("periodEnd") or "")[:10]
            if not due:
                continue
            qty = int(fc.get("quantity") or 0)
            if qty <= 0:
                continue
            conf = float(fc.get("confidence") if fc.get("confidence") is not None else 1.0)
            conf = max(0.0, min(1.0, conf))
            points.append({
                "source": "FORECAST",
                "ref": fc.get("forecastNo"),
                "productId": fc.get("productId"),
                "productCode": fc.get("productCode"),
                "productName": fc.get("productName"),
                "quantity": qty,
                "weightedQty": round(qty * conf, 1),
                "dueDate": due,
                "confidence": conf,
            })
    return points


def _status_for(ratio: float) -> str:
    if ratio >= 1.0:
        return "OVER"
    if ratio >= WARN_RATIO:
        return "WARN"
    return "OK"


def build_plan_buckets(
    world: World,
    *,
    mode: str = "HYBRID",
    start_date: str | None = None,
    horizon_days: int = 90,
    include_forecast: bool = True,
    capacity_mode: str = "FINITE",
) -> dict[str, Any]:
    """
    PL-01/PL-02：时间分桶 × 需求 vs 粗能力。
    capacity_mode=FINITE：能力=日产能×工作日，超载/预警。
    capacity_mode=INFINITE：不卡能力，给出所需日产能；附有限参照负荷。
    """
    mode = (mode or "HYBRID").upper()
    cap_mode = (capacity_mode or "FINITE").upper()
    if cap_mode not in CAPACITY_MODES:
        raise ValueError("capacityMode 必须是 FINITE/INFINITE")
    skeleton = build_bucket_skeleton(mode=mode, start_date=start_date, horizon_days=horizon_days)
    day_cap = daily_capacity(world)
    demands = _collect_demands(world, include_forecast=include_forecast)

    buckets: list[dict[str, Any]] = []
    for raw in skeleton:
        firm = 0
        forecast = 0
        weighted = 0.0
        firm_orders = 0
        forecast_orders = 0
        by_product: dict[str, dict[str, Any]] = {}
        for p in demands:
            if not _in_bucket(p["dueDate"], raw):
                continue
            code = str(p.get("productCode") or "?")
            slot = by_product.setdefault(code, {
                "productCode": code,
                "productName": p.get("productName") or code,
                "firmQty": 0,
                "forecastQty": 0,
                "weightedQty": 0.0,
            })
            if p["source"] == "FIRM":
                firm += p["quantity"]
                firm_orders += 1
                slot["firmQty"] += p["quantity"]
            else:
                forecast += p["quantity"]
                forecast_orders += 1
                slot["forecastQty"] += p["quantity"]
            weighted += p["weightedQty"]
            slot["weightedQty"] = round(slot["weightedQty"] + p["weightedQty"], 1)

        finite_cap = round(day_cap * raw["workdays"], 1)
        demand_total = firm + forecast
        load_qty = weighted
        finite_ratio = (load_qty / finite_cap) if finite_cap > 0 else (1.0 if load_qty > 0 else 0.0)
        finite_gap = round(load_qty - finite_cap, 1)
        finite_status = _status_for(finite_ratio)
        workdays = max(1, int(raw["workdays"] or 0)) if load_qty > 0 else int(raw["workdays"] or 0)
        required_daily = round(load_qty / workdays, 1) if workdays > 0 else round(load_qty, 1)

        if cap_mode == "INFINITE":
            buckets.append({
                **raw,
                "capacityMode": cap_mode,
                "capacityUnlimited": True,
                "capacity": None,
                "firmQty": firm,
                "forecastQty": forecast,
                "demandQty": demand_total,
                "weightedDemand": round(weighted, 1),
                "firmOrderCount": firm_orders,
                "forecastOrderCount": forecast_orders,
                "loadRatio": 0.0,
                "gap": 0.0,
                "status": "OK",
                "requiredDaily": required_daily,
                "finiteCapacity": finite_cap,
                "finiteLoadRatio": round(finite_ratio, 3),
                "finiteGap": finite_gap,
                "finiteStatus": finite_status,
                "byProduct": sorted(by_product.values(), key=lambda x: -(x["firmQty"] + x["forecastQty"])),
            })
        else:
            buckets.append({
                **raw,
                "capacityMode": cap_mode,
                "capacityUnlimited": False,
                "capacity": finite_cap,
                "firmQty": firm,
                "forecastQty": forecast,
                "demandQty": demand_total,
                "weightedDemand": round(weighted, 1),
                "firmOrderCount": firm_orders,
                "forecastOrderCount": forecast_orders,
                "loadRatio": round(finite_ratio, 3),
                "gap": finite_gap,
                "status": finite_status,
                "requiredDaily": required_daily,
                "finiteCapacity": finite_cap,
                "finiteLoadRatio": round(finite_ratio, 3),
                "finiteGap": finite_gap,
                "finiteStatus": finite_status,
                "byProduct": sorted(by_product.values(), key=lambda x: -(x["firmQty"] + x["forecastQty"])),
            })

    over = sum(1 for b in buckets if b["status"] == "OVER")
    warn = sum(1 for b in buckets if b["status"] == "WARN")
    finite_over = sum(1 for b in buckets if b.get("finiteStatus") == "OVER")
    finite_warn = sum(1 for b in buckets if b.get("finiteStatus") == "WARN")
    total_firm = sum(b["firmQty"] for b in buckets)
    total_fc = sum(b["forecastQty"] for b in buckets)
    total_w = sum(b["weightedDemand"] for b in buckets)
    total_cap = sum((b["capacity"] or 0) for b in buckets)
    peak_required = max((b.get("requiredDaily") or 0) for b in buckets) if buckets else 0
    shortfall = [
        {"key": b["key"], "label": b["label"], "finiteGap": b.get("finiteGap", 0),
         "finiteLoadRatio": b.get("finiteLoadRatio", 0), "requiredDaily": b.get("requiredDaily", 0)}
        for b in buckets if b.get("finiteStatus") == "OVER"
    ]

    if cap_mode == "INFINITE":
        hint = ("无限产能粗评估：不卡产线能力，展示所需日产能；"
                "finite* 列为有限产能参照。负荷=确定需求+预测×置信度。")
    else:
        hint = ("有限产能粗评估：能力=ACTIVE产线日产能×工作日；"
                "≥85%预警、≥100%超载。混合分桶：近7日/中约4周/远月。")

    return {
        "mode": mode,
        "capacityMode": cap_mode,
        "startDate": skeleton[0]["start"] if skeleton else fmt_date(today0()),
        "horizonDays": horizon_days,
        "includeForecast": include_forecast,
        "dailyCapacity": day_cap,
        "warnThreshold": WARN_RATIO,
        "summary": {
            "bucketCount": len(buckets),
            "overCount": over,
            "warnCount": warn,
            "okCount": len(buckets) - over - warn,
            "finiteOverCount": finite_over,
            "finiteWarnCount": finite_warn,
            "firmQty": total_firm,
            "forecastQty": total_fc,
            "weightedDemand": round(total_w, 1),
            "capacity": None if cap_mode == "INFINITE" else round(total_cap, 1),
            "overallLoad": 0.0 if cap_mode == "INFINITE" else (
                round((total_w / total_cap), 3) if total_cap else 0.0
            ),
            "peakRequiredDaily": peak_required,
            "shortfallBucketCount": len(shortfall),
        },
        "shortfallBuckets": shortfall[:12],
        "buckets": buckets,
        "hint": hint,
    }


def build_rccp_compare(
    world: World,
    *,
    mode: str = "HYBRID",
    start_date: str | None = None,
    horizon_days: int = 90,
    include_forecast: bool = True,
) -> dict[str, Any]:
    """PL-02：有限 vs 无限粗能力对照摘要。"""
    finite = build_plan_buckets(
        world, mode=mode, start_date=start_date, horizon_days=horizon_days,
        include_forecast=include_forecast, capacity_mode="FINITE",
    )
    infinite = build_plan_buckets(
        world, mode=mode, start_date=start_date, horizon_days=horizon_days,
        include_forecast=include_forecast, capacity_mode="INFINITE",
    )
    fs, iis = finite["summary"], infinite["summary"]
    return {
        "mode": mode,
        "horizonDays": horizon_days,
        "includeForecast": include_forecast,
        "dailyCapacity": finite["dailyCapacity"],
        "finite": {
            "overCount": fs["overCount"],
            "warnCount": fs["warnCount"],
            "overallLoad": fs["overallLoad"],
            "capacity": fs["capacity"],
            "weightedDemand": fs["weightedDemand"],
        },
        "infinite": {
            "peakRequiredDaily": iis["peakRequiredDaily"],
            "weightedDemand": iis["weightedDemand"],
            "shortfallBucketCount": iis["shortfallBucketCount"],
        },
        "delta": {
            "capacityGapDaily": round(
                max(0.0, float(iis["peakRequiredDaily"] or 0) - float(finite["dailyCapacity"] or 0)), 1
            ),
            "finiteOverCount": fs["overCount"],
            "message": (
                f"有限模式超载桶 {fs['overCount']}；无限模式峰值所需日产能 "
                f"{iis['peakRequiredDaily']}（当前日产能 {finite['dailyCapacity']}）。"
            ),
        },
        "shortfallBuckets": infinite.get("shortfallBuckets") or [],
        "hint": "RCCP 双模式：有限看缺口桶，无限看峰值所需能力。完整表见「分桶计划」视口切换。",
        # 默认带回有限全表，便于视口直接渲染
        "report": finite,
    }


def _feasibility_status(*, due: str, start: str, slack: float, load_ratio: float) -> str:
    if due < start:
        return "LATE"
    if slack < 0:
        return "INFEASIBLE"
    if load_ratio >= WARN_RATIO:
        return "AT_RISK"
    return "FEASIBLE"


def _portfolio_verdict(statuses: list[str]) -> str:
    if any(s in ("INFEASIBLE", "LATE") for s in statuses):
        return "INFEASIBLE"
    if any(s == "AT_RISK" for s in statuses):
        return "AT_RISK"
    return "FEASIBLE"


def build_feasibility(
    world: World,
    *,
    start_date: str | None = None,
    horizon_days: int = 90,
    include_forecast: bool = True,
) -> dict[str, Any]:
    """
    PL-03：计划层交期可行性（前置于详细排产）。
    规则：按交期排序，累计加权需求 vs 从计划起点到交期的累计粗能力（日产能×工作日）。
    """
    start = _as_date(start_date) if start_date else today0()
    start_s = fmt_date(start)
    horizon_days = max(1, min(int(horizon_days or 90), 366))
    day_cap = daily_capacity(world)

    # 订单级行（同一 SO 合并明细）
    rows_in: list[dict[str, Any]] = []
    for so in world.get("salesOrders", []):
        if so.get("status") not in SCHEDULABLE_STATUSES:
            continue
        due = str(so.get("deliveryDate") or "")[:10]
        if not due:
            continue
        qty = 0
        products: list[str] = []
        for item in so.get("items") or []:
            if item.get("status") in ("CANCELLED", "COMPLETED"):
                continue
            q = int(item.get("quantity") or 0)
            if q <= 0:
                continue
            qty += q
            code = str(item.get("productCode") or "")
            if code and code not in products:
                products.append(code)
        if qty <= 0:
            continue
        rows_in.append({
            "source": "FIRM",
            "ref": so.get("orderNo"),
            "customerName": so.get("customerName"),
            "customerLevel": so.get("customerLevel"),
            "priority": int(so.get("priority") or 9),
            "productCodes": products,
            "quantity": qty,
            "weightedQty": float(qty),
            "dueDate": due,
        })

    if include_forecast:
        from server.aps_domain.forecast import ensure_forecast_table
        ensure_forecast_table(world)
        for fc in world.get("forecastOrders", []):
            if fc.get("status") != "ACTIVE":
                continue
            due = str(fc.get("dueDate") or fc.get("periodEnd") or "")[:10]
            if not due:
                continue
            qty = int(fc.get("quantity") or 0)
            if qty <= 0:
                continue
            conf = float(fc.get("confidence") if fc.get("confidence") is not None else 1.0)
            conf = max(0.0, min(1.0, conf))
            rows_in.append({
                "source": "FORECAST",
                "ref": fc.get("forecastNo"),
                "customerName": fc.get("customerName") or "预测需求",
                "customerLevel": fc.get("customerLevel") or "C",
                "priority": 9,
                "productCodes": [str(fc.get("productCode") or "")],
                "quantity": qty,
                "weightedQty": round(qty * conf, 1),
                "dueDate": due,
                "confidence": conf,
            })

    rows_in.sort(key=lambda r: (r["dueDate"], r["priority"], str(r["ref"] or "")))

    # 有限分桶：用于缺口定位
    rccp = build_plan_buckets(
        world, mode="HYBRID", start_date=start_s, horizon_days=horizon_days,
        include_forecast=include_forecast, capacity_mode="FINITE",
    )
    over_buckets = [b for b in rccp["buckets"] if b.get("status") == "OVER"]

    cum_demand = 0.0
    out_rows: list[dict[str, Any]] = []
    for r in rows_in:
        due = r["dueDate"]
        due_dt = _as_date(due)
        # 交期早于起点：无可用工作日
        if due_dt < start:
            workdays = 0
            cum_cap = 0.0
        else:
            workdays = _workdays_inclusive(start, due_dt)
            cum_cap = round(day_cap * workdays, 1)
        cum_demand = round(cum_demand + float(r["weightedQty"]), 1)
        slack = round(cum_cap - cum_demand, 1)
        load_ratio = (cum_demand / cum_cap) if cum_cap > 0 else (1.0 if cum_demand > 0 else 0.0)
        status = _feasibility_status(due=due, start=start_s, slack=slack, load_ratio=load_ratio)

        reasons: list[str] = []
        if status == "LATE":
            reasons.append("交期早于计划起点")
        elif status == "INFEASIBLE":
            reasons.append(f"至交期累计能力不足 {abs(slack)} 件")
        elif status == "AT_RISK":
            reasons.append(f"至交期累计负荷 {round(load_ratio * 100)}%（≥{int(WARN_RATIO * 100)}% 预警）")

        hit_overs = [
            b["label"] for b in over_buckets
            if b["start"] <= due and b["end"] >= start_s
        ][:4]
        if hit_overs and status in ("INFEASIBLE", "AT_RISK"):
            reasons.append("重叠超载桶：" + "、".join(hit_overs))

        out_rows.append({
            "source": r["source"],
            "ref": r["ref"],
            "customerName": r.get("customerName"),
            "customerLevel": r.get("customerLevel"),
            "priority": r["priority"],
            "productCodes": r["productCodes"],
            "quantity": r["quantity"],
            "weightedQty": r["weightedQty"],
            "dueDate": due,
            "workdaysToDue": workdays,
            "cumulativeCapacity": cum_cap,
            "cumulativeDemand": cum_demand,
            "slack": slack,
            "loadRatio": round(load_ratio, 3),
            "status": status,
            "reasons": reasons,
        })

    statuses = [r["status"] for r in out_rows]
    verdict = _portfolio_verdict(statuses) if statuses else "FEASIBLE"
    counts = {
        "all": len(out_rows),
        "feasible": sum(1 for s in statuses if s == "FEASIBLE"),
        "atRisk": sum(1 for s in statuses if s == "AT_RISK"),
        "infeasible": sum(1 for s in statuses if s == "INFEASIBLE"),
        "late": sum(1 for s in statuses if s == "LATE"),
    }

    return {
        "startDate": start_s,
        "horizonDays": horizon_days,
        "includeForecast": include_forecast,
        "dailyCapacity": day_cap,
        "warnThreshold": WARN_RATIO,
        "verdict": verdict,
        "summary": {
            **counts,
            "shortfallBucketCount": len(over_buckets),
            "overallLoad": rccp["summary"].get("overallLoad"),
        },
        "gaps": [
            {
                "key": b["key"], "label": b["label"], "start": b["start"], "end": b["end"],
                "gap": b.get("gap"), "loadRatio": b.get("loadRatio"),
                "firmQty": b.get("firmQty"), "forecastQty": b.get("forecastQty"),
            }
            for b in over_buckets[:12]
        ],
        "orders": out_rows,
        "hint": (
            "可行性=按交期累计需求 vs 起点→交期累计粗能力（前置于排产）；"
            "不等同详细排程准时率。缺口桶来自有限产能分桶。"
        ),
    }


def _peak_and_variance(loads: list[float], caps: list[float]) -> tuple[float, float, float]:
    """返回 (peakLoadRatio, avgLoadRatio, loadVariance)。"""
    ratios = []
    for load, cap in zip(loads, caps):
        if cap > 0:
            ratios.append(load / cap)
        elif load > 0:
            ratios.append(1.0)
        else:
            ratios.append(0.0)
    if not ratios:
        return 0.0, 0.0, 0.0
    peak = max(ratios)
    avg = sum(ratios) / len(ratios)
    var = sum((r - avg) ** 2 for r in ratios) / len(ratios)
    return round(peak, 3), round(avg, 3), round(var, 4)


def build_leveling(
    world: World,
    *,
    mode: str = "WEEK",
    start_date: str | None = None,
    horizon_days: int = 90,
    include_forecast: bool = True,
    target_load: float = 0.85,
) -> dict[str, Any]:
    """
    PL-05：计划层产能平衡/削峰建议（只读）。
    从超载桶把多余需求挪到前/后有空档的桶（先提前、再延后），不改订单交期。
    """
    mode = (mode or "WEEK").upper()
    if mode not in BUCKET_MODES:
        raise ValueError("mode 必须是 DAY/WEEK/MONTH/HYBRID")
    target = float(target_load if target_load is not None else WARN_RATIO)
    target = max(0.5, min(1.0, target))

    base = build_plan_buckets(
        world, mode=mode, start_date=start_date, horizon_days=horizon_days,
        include_forecast=include_forecast, capacity_mode="FINITE",
    )
    buckets = base["buckets"]
    loads = [float(b.get("weightedDemand") or 0) for b in buckets]
    caps = [float(b.get("capacity") or 0) for b in buckets]
    peak_b, avg_b, var_b = _peak_and_variance(loads, caps)

    moves: list[dict[str, Any]] = []
    working = list(loads)

    for i, b in enumerate(buckets):
        surplus = working[i] - caps[i]
        if surplus <= 0.5:
            continue
        products = list(b.get("byProduct") or [])
        prod_idx = 0

        def _next_product() -> dict[str, Any]:
            nonlocal prod_idx
            if not products:
                return {"productCode": "?", "productName": "混合需求"}
            p = products[prod_idx % len(products)]
            prod_idx += 1
            return p

        # ① 向前提到有空档的桶（PULL_AHEAD）
        for j in range(i - 1, -1, -1):
            if surplus <= 0.5:
                break
            room = caps[j] * target - working[j]
            if room <= 0.5:
                continue
            qty = min(surplus, room)
            p = _next_product()
            moves.append({
                "fromKey": b["key"], "toKey": buckets[j]["key"],
                "fromLabel": b["label"], "toLabel": buckets[j]["label"],
                "fromStart": b["start"], "toStart": buckets[j]["start"],
                "quantity": round(qty, 1),
                "direction": "PULL_AHEAD",
                "productCode": p.get("productCode"),
                "productName": p.get("productName"),
                "reason": f"超载桶 {b['label']} → 提前到空档 {buckets[j]['label']}",
            })
            working[i] = round(working[i] - qty, 1)
            working[j] = round(working[j] + qty, 1)
            surplus = working[i] - caps[i]

        # ② 向后推到空档（PUSH_BACK）
        for j in range(i + 1, len(buckets)):
            if surplus <= 0.5:
                break
            room = caps[j] * target - working[j]
            if room <= 0.5:
                continue
            qty = min(surplus, room)
            p = _next_product()
            moves.append({
                "fromKey": b["key"], "toKey": buckets[j]["key"],
                "fromLabel": b["label"], "toLabel": buckets[j]["label"],
                "fromStart": b["start"], "toStart": buckets[j]["start"],
                "quantity": round(qty, 1),
                "direction": "PUSH_BACK",
                "productCode": p.get("productCode"),
                "productName": p.get("productName"),
                "reason": f"超载桶 {b['label']} → 延后到空档 {buckets[j]['label']}（可能影响交期）",
            })
            working[i] = round(working[i] - qty, 1)
            working[j] = round(working[j] + qty, 1)
            surplus = working[i] - caps[i]

    peak_a, avg_a, var_a = _peak_and_variance(working, caps)
    after_buckets = []
    for b, load in zip(buckets, working):
        cap = float(b.get("capacity") or 0)
        ratio = (load / cap) if cap > 0 else (1.0 if load > 0 else 0.0)
        after_buckets.append({
            "key": b["key"], "label": b["label"], "kind": b["kind"],
            "start": b["start"], "end": b["end"],
            "capacity": cap,
            "demandBefore": b.get("weightedDemand"),
            "demandAfter": round(load, 1),
            "loadBefore": b.get("loadRatio"),
            "loadAfter": round(ratio, 3),
            "statusBefore": b.get("status"),
            "statusAfter": _status_for(ratio),
            "delta": round(load - float(b.get("weightedDemand") or 0), 1),
        })

    over_before = sum(1 for b in buckets if b.get("status") == "OVER")
    over_after = sum(1 for b in after_buckets if b["statusAfter"] == "OVER")

    return {
        "mode": mode,
        "horizonDays": horizon_days,
        "includeForecast": include_forecast,
        "targetLoad": target,
        "dailyCapacity": base["dailyCapacity"],
        "before": {
            "peakLoad": peak_b, "avgLoad": avg_b, "variance": var_b, "overCount": over_before,
        },
        "after": {
            "peakLoad": peak_a, "avgLoad": avg_a, "variance": var_a, "overCount": over_after,
        },
        "improvement": {
            "peakDelta": round(peak_b - peak_a, 3),
            "varianceDelta": round(var_b - var_a, 4),
            "overCountDelta": over_before - over_after,
            "moveCount": len(moves),
            "movedQty": round(sum(m["quantity"] for m in moves), 1),
        },
        "moves": moves[:40],
        "buckets": after_buckets,
        "hint": (
            f"削峰目标负荷≤{int(target * 100)}%：优先提前到空档，其次延后；"
            "本切片只给建议，不改订单交期。确认挪单请改交期或走产能均衡试排。"
        ),
    }


# 产供建议相对成本指数（越小越优先；首切片启发式，非财务报价）
_SUPPLY_COST = {"LEVELING": 1.0, "OVERTIME": 1.35, "EXPAND": 2.1, "OUTSOURCE": 1.75}
_OVERTIME_RATIO = 0.25   # 加班最多再挖 25% 桶能力
_EXPAND_RATIO = 0.40     # 扩线/提效假设可再加 40% 桶能力


def _inactive_or_alt_lines(world: World) -> list[dict[str, Any]]:
    """可扩容线索：停用产线，或 ACTIVE 产线声明的替代产线。"""
    lines = {ln["id"]: ln for ln in world.get("lines", [])}
    hints: list[dict[str, Any]] = []
    for ln in lines.values():
        if ln.get("status") == "INACTIVE":
            hints.append({
                "code": ln.get("code"), "name": ln.get("name"),
                "kind": "INACTIVE_LINE",
                "capacityPerDay": float(ln.get("capacityPerDay") or 0),
            })
        for aid in ln.get("alternativeLineIds") or []:
            alt = lines.get(aid)
            if not alt:
                continue
            hints.append({
                "code": alt.get("code"), "name": alt.get("name"),
                "kind": "ALT_LINE",
                "capacityPerDay": float(alt.get("capacityPerDay") or 0),
                "forLine": ln.get("code"),
            })
    # 去重 by code
    seen: set[str] = set()
    uniq = []
    for h in hints:
        c = str(h.get("code") or "")
        if c and c not in seen:
            seen.add(c)
            uniq.append(h)
    return uniq


def build_supply_decisions(
    world: World,
    *,
    mode: str = "WEEK",
    start_date: str | None = None,
    horizon_days: int = 90,
    include_forecast: bool = True,
    target_load: float = 0.85,
) -> dict[str, Any]:
    """
    PL-06：产供方向决策（加班 / 扩线 / 外协）结构化建议，只读。
    先跑削峰；对削峰后仍超载的桶，按 加班→扩线→外协 覆盖缺口并打相对成本分。
    """
    leveling = build_leveling(
        world, mode=mode, start_date=start_date, horizon_days=horizon_days,
        include_forecast=include_forecast, target_load=target_load,
    )
    day_cap = float(leveling.get("dailyCapacity") or daily_capacity(world))
    alt_hints = _inactive_or_alt_lines(world)
    expand_pool = sum(h.get("capacityPerDay") or 0 for h in alt_hints)

    gaps: list[dict[str, Any]] = []
    options: list[dict[str, Any]] = []
    total_residual = 0.0

    for b in leveling["buckets"]:
        if b.get("statusAfter") != "OVER":
            continue
        cap = float(b.get("capacity") or 0)
        dem = float(b.get("demandAfter") or 0)
        gap = round(dem - cap, 1)
        if gap <= 0.5:
            continue
        total_residual = round(total_residual + gap, 1)
        workdays = max(1, int((_as_date(b["end"]) - _as_date(b["start"])).days) + 1)
        # 粗估工作日：用能力反推
        if day_cap > 0 and cap > 0:
            workdays = max(1, int(round(cap / day_cap)))

        remaining = gap
        bucket_opts: list[dict[str, Any]] = []

        # ① 加班
        ot_room = round(cap * _OVERTIME_RATIO, 1)
        ot_cover = round(min(remaining, ot_room), 1)
        if ot_cover >= 1:
            bucket_opts.append({
                "kind": "OVERTIME",
                "label": "加班",
                "bucketKey": b["key"], "bucketLabel": b["label"],
                "coverQty": ot_cover,
                "extraCapacity": ot_cover,
                "costIndex": _SUPPLY_COST["OVERTIME"],
                "leadDays": 0,
                "detail": f"桶内加班约 +{int(_OVERTIME_RATIO * 100)}% 能力，覆盖 {ot_cover} 件",
            })
            remaining = round(remaining - ot_cover, 1)

        # ② 扩线 / 启用替代产线
        expand_room = round(cap * _EXPAND_RATIO + expand_pool * workdays * 0.15, 1)
        expand_cover = round(min(remaining, expand_room), 1) if remaining >= 1 else 0.0
        if expand_cover >= 1:
            alt_txt = "、".join(f"{h['code']}" for h in alt_hints[:3]) or "提效/扩班"
            bucket_opts.append({
                "kind": "EXPAND",
                "label": "扩线/启用替代",
                "bucketKey": b["key"], "bucketLabel": b["label"],
                "coverQty": expand_cover,
                "extraCapacity": expand_cover,
                "costIndex": _SUPPLY_COST["EXPAND"],
                "leadDays": 14,
                "detail": f"启用/加开 {alt_txt}，覆盖 {expand_cover} 件（含约 2 周准备）",
                "altLines": alt_hints[:5],
            })
            remaining = round(remaining - expand_cover, 1)

        # ③ 外协吃掉剩余
        if remaining >= 1:
            bucket_opts.append({
                "kind": "OUTSOURCE",
                "label": "外协",
                "bucketKey": b["key"], "bucketLabel": b["label"],
                "coverQty": remaining,
                "extraCapacity": remaining,
                "costIndex": _SUPPLY_COST["OUTSOURCE"],
                "leadDays": 7,
                "detail": f"外协 {remaining} 件，约 7 天交期缓冲",
            })
            remaining = 0.0

        gaps.append({
            "key": b["key"], "label": b["label"], "start": b["start"], "end": b["end"],
            "capacity": cap, "demandAfterLeveling": dem, "gap": gap,
            "options": bucket_opts,
        })
        options.extend(bucket_opts)

    # 组合推荐：按成本指数排序取覆盖路径摘要
    ranked = sorted(options, key=lambda o: (o["costIndex"], -o["coverQty"]))
    mix = {"OVERTIME": 0.0, "EXPAND": 0.0, "OUTSOURCE": 0.0, "LEVELING": float(leveling["improvement"].get("movedQty") or 0)}
    for o in options:
        mix[o["kind"]] = round(mix.get(o["kind"], 0) + o["coverQty"], 1)

    if total_residual <= 0.5 and leveling["improvement"]["moveCount"] == 0:
        verdict = "BALANCED"
        message = "削峰后无残留超载，无需加班/扩线/外协。"
    elif total_residual <= 0.5:
        verdict = "LEVELING_ENOUGH"
        message = f"削峰挪动 {mix['LEVELING']} 件后已消除超载；优先执行削峰建议。"
    else:
        verdict = "NEED_SUPPLY"
        message = (
            f"削峰后仍缺口约 {total_residual} 件：建议加班 {mix['OVERTIME']} / "
            f"扩线 {mix['EXPAND']} / 外协 {mix['OUTSOURCE']}。"
        )

    return {
        "mode": mode,
        "horizonDays": horizon_days,
        "includeForecast": include_forecast,
        "targetLoad": leveling["targetLoad"],
        "dailyCapacity": day_cap,
        "verdict": verdict,
        "message": message,
        "leveling": {
            "moveCount": leveling["improvement"]["moveCount"],
            "movedQty": leveling["improvement"]["movedQty"],
            "overBefore": leveling["before"]["overCount"],
            "overAfter": leveling["after"]["overCount"],
            "peakBefore": leveling["before"]["peakLoad"],
            "peakAfter": leveling["after"]["peakLoad"],
        },
        "summary": {
            "residualGap": total_residual,
            "gapBucketCount": len(gaps),
            "optionCount": len(options),
            "mix": mix,
            "altLineCount": len(alt_hints),
        },
        "gaps": gaps,
        "options": ranked[:30],
        "altLines": alt_hints,
        "hint": (
            "产供决策：先削峰，残留缺口按 加班→扩线→外协 覆盖；"
            "costIndex 为相对成本启发式，非财务报价。本切片只读建议。"
        ),
    }