# ============================================================
# SOP → 约束规则包（moduleId: domain-sop-rules, IND-02 / C13，可重生 ✅）
# 知识库 SOP 编译为可应用的约束/换型策略补丁；预览 P0，应用 P2
# ============================================================
from __future__ import annotations

import re
import uuid
from datetime import datetime
from typing import Any

from server.timeutil import fmt_dt

World = dict[str, Any]


def _extract_minutes(text: str, *patterns: str, default: float | None = None) -> float | None:
    for pat in patterns:
        m = re.search(pat, text)
        if m:
            try:
                return float(m.group(1))
            except (TypeError, ValueError):
                continue
    return default


def list_compilable_sops(kb_assets: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """列出可编译的 SOP（kind=sop 且已审批）。"""
    out = []
    for a in kb_assets:
        if a.get("kind") != "sop" or not a.get("approved", True):
            continue
        pack = compile_sop_asset(a)
        out.append({
            "assetId": a.get("assetId"),
            "title": a.get("title"),
            "tags": a.get("tags") or [],
            "effectCount": len(pack.get("effects") or []),
            "compilable": bool(pack.get("effects")),
            "summary": pack.get("summary") or "",
            "plannerSummary": pack.get("plannerSummary") or "",
        })
    return out


def compile_sop_asset(asset: dict[str, Any]) -> dict[str, Any]:
    """
    将单条 SOP 编译为规则包预览（确定性模板+关键词，非 LLM）。
    返回 {packId, title, source, effects[], summary, warnings[]}
    """
    title = str(asset.get("title") or "")
    content = str(asset.get("content") or "")
    tags = [str(t) for t in (asset.get("tags") or [])]
    blob = f"{title}\n{content}\n{' '.join(tags)}"
    effects: list[dict[str, Any]] = []
    warnings: list[str] = []

    # —— 换线标准 SOP ——
    if re.search(r"换线|换型", blob):
        cross = _extract_minutes(
            content,
            r"跨产品族换线\s*(\d+)\s*分钟",
            r"跨族[^\d]{0,6}(\d+)\s*分",
            default=60.0,
        )
        std = _extract_minutes(
            content,
            r"换线作业标准\s*(\d+)\s*分钟",
            r"标准\s*(\d+)\s*分钟",
            default=30.0,
        )
        effects.append({
            "op": "constraint.set",
            "id": "C10_changeover",
            "enabled": True,
            "kind": "soft",
            "rationale": "SOP 要求顺序相关换型受控",
        })
        effects.append({
            "op": "changeover.policy",
            "defaultCrossFamilyMin": cross,
            "standardSetupMin": std,
            "noChangeoverAfter": "16:00" if re.search(r"16:00|十六点|夜班", content) else None,
            "rationale": f"跨族默认 {cross:.0f} 分；标准 {std:.0f} 分"
                        + ("；16:00 后不安排换线" if re.search(r"16:00", content) else ""),
        })
        effects.append({
            "op": "strategy.suggest",
            "strategy": "CHANGEOVER_MIN",
            "rationale": "同产品族连续生产优先",
        })

    # —— 齐套 / 库存 SOP ——
    if re.search(r"齐套|缺料|库存", blob) and not re.search(r"换线", title):
        effects.append({
            "op": "constraint.set",
            "id": "C6_material_kit",
            "enabled": True,
            "kind": "soft",
            "rationale": "SOP：缺料须可见，不默认阻断草案",
        })

    # —— 插单审批 SOP ——
    if re.search(r"插单|急单", blob):
        effects.append({
            "op": "process.note",
            "text": "VIP 插单须影响评估 + 主管审批（本系统 rush.apply 已是 P2）",
            "rationale": "与门禁对齐，无需改引擎开关",
        })

    if not effects:
        warnings.append("当前作业标准未识别出可用于排产的约束，可在约束规则库中补充要求。")

    # C13 标记：有可应用效果时启用
    if any(e.get("op") in ("constraint.set", "changeover.policy") for e in effects):
        effects.append({
            "op": "constraint.set",
            "id": "C13_sop",
            "enabled": True,
            "kind": "soft",
            "params": {
                "sourceAssetId": asset.get("assetId"),
                "sourceTitle": title,
            },
            "rationale": "标记本剖面含 SOP 编译规则",
        })

    summary_bits = []
    planner_bits: list[str] = []
    for e in effects:
        if e["op"] == "constraint.set":
            summary_bits.append(f"{e['id']}→{'开' if e.get('enabled') else '关'}/{e.get('kind', '')}")
            constraint_id = str(e.get("id") or "")
            if constraint_id == "C10_changeover":
                planner_bits.append("将换型顺序纳入排产控制")
            elif constraint_id == "C6_material_kit":
                planner_bits.append("物料不齐套时提示风险，不直接阻断排产草案")
            elif constraint_id != "C13_sop":
                planner_bits.append("将作业标准中的约束条件纳入排产")
        elif e["op"] == "changeover.policy":
            summary_bits.append(f"跨族换型默认{e.get('defaultCrossFamilyMin')}分")
            policy_bits: list[str] = []
            cross_min = e.get("defaultCrossFamilyMin")
            standard_min = e.get("standardSetupMin")
            if cross_min is not None:
                policy_bits.append(f"跨产品族换型预留 {float(cross_min):.0f} 分钟")
            if standard_min is not None:
                policy_bits.append(f"常规换型预留 {float(standard_min):.0f} 分钟")
            if e.get("noChangeoverAfter"):
                policy_bits.append(f"{e['noChangeoverAfter']} 后不安排换型")
            planner_bits.append("；".join(policy_bits) if policy_bits else "按作业标准控制换型时间")
        elif e["op"] == "strategy.suggest":
            summary_bits.append(f"建议策略{e.get('strategy')}")
            planner_bits.append("优先连续生产同一产品族，减少换型次数")
        elif e["op"] == "process.note":
            summary_bits.append("流程提示")
            planner_bits.append("急单插单先进行影响评估，并经主管确认后执行")

    planner_bits = list(dict.fromkeys(planner_bits))

    return {
        "packId": f"pack-{asset.get('assetId') or uuid.uuid4().hex[:8]}",
        "title": title,
        "source": {
            "assetId": asset.get("assetId"),
            "kind": asset.get("kind"),
            "version": asset.get("version"),
            "title": title,
        },
        "effects": effects,
        "summary": "；".join(summary_bits) if summary_bits else "无可应用效果",
        "plannerSummary": ("；".join(planner_bits) if planner_bits
                           else "当前作业标准暂未识别出可用于排产的约束"),
        "warnings": warnings,
    }


def compile_sop_by_asset(kb_assets: list[dict[str, Any]], asset_id: str | None = None) -> dict[str, Any]:
    """按 Pi 明确给出的 assetId 精确选择并编译 SOP。"""
    requested = str(asset_id or "").strip()
    sops = [a for a in kb_assets if a.get("kind") == "sop" and a.get("approved", True)]
    available = [
        {"assetId": a.get("assetId"), "title": a.get("title")}
        for a in sops[:12]
    ]
    if not requested:
        return {
            "ok": False,
            "error": "请提供明确的 assetId，不能根据原始问句自动选择 SOP。",
            "available": available,
        }
    hit = next(
        (a for a in sops if str(a.get("assetId") or "") == requested),
        None,
    )
    if hit is None:
        return {
            "ok": False,
            "error": f"未找到可编译的 SOP：assetId={requested}。",
            "available": available,
        }
    return {"ok": True, "pack": compile_sop_asset(hit)}


def compile_sop_by_query(kb_assets: list[dict[str, Any]], query: str | None = None) -> dict[str, Any]:
    """兼容旧调用；禁止用原始问句选择 SOP，调用方必须改用 assetId。"""
    del query
    sops = [a for a in kb_assets if a.get("kind") == "sop" and a.get("approved", True)]
    return {
        "ok": False,
        "error": "请提供明确的 assetId，不能根据原始问句自动选择 SOP。",
        "available": [
            {"assetId": a.get("assetId"), "title": a.get("title")}
            for a in sops[:12]
        ],
    }


def confirmation_for_sop_apply(pack: dict[str, Any]) -> tuple[str, list[str]]:
    title = f"应用作业标准：{pack.get('title') or pack.get('packId')}"
    summary = str(pack.get("plannerSummary") or "当前作业标准暂未识别出可用于排产的约束")
    lines = [bit.strip() for bit in summary.split("；") if bit.strip()]
    src = (pack.get("source") or {}).get("title")
    if src:
        lines.append(f"出处：{src}")
    lines.append("批准后应用到后续排产，历史版本保持不变。")
    for w in pack.get("warnings") or []:
        lines.append(f"提示：{w}")
    return title, lines


def apply_sop_pack(world: World, pack: dict[str, Any]) -> dict[str, Any]:
    """把规则包写入世界（约束剖面 / 换型策略 / 规则包登记）。"""
    from server.aps_domain.constraints import apply_profile_save

    effects = pack.get("effects") or []
    constraint_payload: dict[str, Any] = {"constraints": {}}
    changeover_policy: dict[str, Any] = dict(world.get("changeoverPolicy") or {})
    notes: list[str] = []
    applied: list[str] = []

    for e in effects:
        op = e.get("op")
        if op == "constraint.set":
            cid = str(e.get("id") or "")
            if not cid:
                continue
            patch: dict[str, Any] = {}
            if "enabled" in e:
                patch["enabled"] = bool(e["enabled"])
            if e.get("kind") in ("hard", "soft"):
                patch["kind"] = e["kind"]
            if isinstance(e.get("params"), dict):
                patch["params"] = e["params"]
            constraint_payload["constraints"][cid] = patch
            applied.append(f"constraint:{cid}")
        elif op == "changeover.policy":
            if e.get("defaultCrossFamilyMin") is not None:
                changeover_policy["defaultCrossFamilyMin"] = float(e["defaultCrossFamilyMin"])
            if e.get("standardSetupMin") is not None:
                changeover_policy["standardSetupMin"] = float(e["standardSetupMin"])
            if e.get("noChangeoverAfter"):
                changeover_policy["noChangeoverAfter"] = str(e["noChangeoverAfter"])
            applied.append("changeover.policy")
        elif op == "strategy.suggest":
            notes.append(f"建议后续试排使用策略 {e.get('strategy')}")
            applied.append(f"suggest:{e.get('strategy')}")
        elif op == "process.note":
            notes.append(str(e.get("text") or ""))
            applied.append("process.note")

    if constraint_payload["constraints"]:
        apply_profile_save(world, constraint_payload)

    if any(e.get("op") == "changeover.policy" for e in effects):
        world["changeoverPolicy"] = changeover_policy

    packs = world.setdefault("rulePacks", [])
    rec = {
        "packId": pack.get("packId") or f"pack-{uuid.uuid4().hex[:8]}",
        "title": pack.get("title"),
        "source": pack.get("source"),
        "appliedAt": fmt_dt(datetime.now()),
        "effects": effects,
        "notes": notes,
    }
    # 同 asset 再应用则替换
    src_id = (pack.get("source") or {}).get("assetId")
    packs[:] = [p for p in packs if (p.get("source") or {}).get("assetId") != src_id]
    packs.append(rec)

    return {
        "packId": rec["packId"],
        "applied": applied,
        "notes": notes,
        "changeoverPolicy": changeover_policy,
        "rulePackCount": len(packs),
    }


def get_changeover_policy(world: World) -> dict[str, Any]:
    pol = world.get("changeoverPolicy") or {}
    return {
        "defaultCrossFamilyMin": float(pol.get("defaultCrossFamilyMin") or 30),
        "standardSetupMin": float(pol.get("standardSetupMin") or 30),
        "noChangeoverAfter": pol.get("noChangeoverAfter"),
    }


def sop_as_block(pack: dict[str, Any]) -> Any:
    from server.contracts import UIBlock
    return UIBlock(
        blockId=f"sop-pack-{uuid.uuid4().hex[:8]}",
        type="report",
        props={
            "title": f"作业标准规则：{pack.get('title')}",
            "reportType": "sop-rule-pack",
            "markdown": _pack_markdown(pack),
            "pack": pack,
        },
    )


def _pack_markdown(pack: dict[str, Any]) -> str:
    summary = str(pack.get("plannerSummary") or "当前作业标准暂未识别出可用于排产的约束")
    lines = [
        f"# 作业标准：{pack.get('title')}",
        "",
        "## 排产规则",
    ]
    for bit in summary.split("；"):
        if bit.strip():
            lines.append(f"- {bit.strip()}")
    if pack.get("warnings"):
        lines.append("")
        lines.append("## 提示")
        for w in pack["warnings"]:
            lines.append(f"- {w}")
    src = pack.get("source") or {}
    lines += ["", f"出处：{src.get('title')}"]
    return "\n".join(lines)