"""Lightweight consultant dispatch contract and registries."""

from __future__ import annotations

import re
from typing import Any, Optional

DOMAIN_PROJECT = "project"
DOMAIN_TASK = "task"
DOMAIN_SIGNAL = "signal"
DOMAIN_RAG = "rag"
DOMAIN_FOLLOWUP = "followup"
DOMAIN_GENERIC = "generic"

MODE_CLARIFY = "clarify"
MODE_ADVISE = "advise"
MODE_CHALLENGE = "challenge"
MODE_BRAINSTORM = "brainstorm"
MODE_EXECUTE = "execute"

CONSULTANT_DOMAIN_PROMPT_REGISTRY: dict[str, dict[str, str]] = {
    DOMAIN_PROJECT: {"prompt_key": "PROMPT_GENERATE_CHARTER", "role_hint": "pm_dispatcher"},
    DOMAIN_TASK: {"prompt_key": "PROMPT_DECOMPOSE_TASKS", "role_hint": "delivery_coach"},
    DOMAIN_SIGNAL: {"prompt_key": "PROMPT_FEISHU_DIRECT_QA", "role_hint": "delivery_coach"},
    DOMAIN_RAG: {"prompt_key": "PROMPT_RAG_ANSWER", "role_hint": "pm_dispatcher"},
    DOMAIN_FOLLOWUP: {"prompt_key": "PROMPT_AI_PMO_QA", "role_hint": "delivery_coach"},
    DOMAIN_GENERIC: {"prompt_key": "PROMPT_RAG_ANSWER", "role_hint": "pm_dispatcher"},
}

CONSULTANT_MODE_WRAPPER_REGISTRY: dict[str, dict[str, str]] = {
    MODE_CLARIFY: {"label": "信息不足，先澄清再推进", "tone": "direct"},
    MODE_ADVISE: {"label": "直接建议最稳妥方案", "tone": "consultative"},
    MODE_CHALLENGE: {"label": "高风险或范围过大，先挑战假设", "tone": "guardrail"},
    MODE_BRAINSTORM: {"label": "先发散方案，再收敛边界", "tone": "creative"},
    MODE_EXECUTE: {"label": "信息齐全，可继续执行", "tone": "action"},
}

CONSULTANT_CHANNEL_STRATEGIES: dict[str, dict[str, Any]] = {
    "feishu": {"max_chars": 220, "prefer_direct": True},
    "pmflow": {"max_chars": 500, "prefer_direct": False},
    "pmflow_manual": {"max_chars": 500, "prefer_direct": False},
}

_QUERY_OPERATION_CODES = {"query.answer", "query.read_only"}
_SCOPE_EXPANSION_RE = re.compile(
    r"(整个系统|全部重做|全量重构|一次替换所有|一次性全部|推翻重来|从零重写|所有模块都|整体改造)",
    re.IGNORECASE,
)
_BRAINSTORM_RE = re.compile(
    r"(想.idea|想法|brainstorm|头脑风暴|一起想|给我几个方案|给几个方向|发散一下|有哪些思路)",
    re.IGNORECASE,
)
_ADVISE_RE = re.compile(
    r"(建议|怎么做|如何做|优先|取舍|方案|还是|更适合|更应该|值不值得|要不要)",
    re.IGNORECASE,
)

_MISSING_FIELD_LABELS = {
    "project_id": "归属项目",
    "task_title": "任务标题",
    "title": "标题",
    "description": "描述",
    "project_scope": "项目范围",
}


def _normalize_missing_fields(value: Any) -> list[str]:
    if not isinstance(value, list):
        return []
    fields: list[str] = []
    for item in value:
        text = str(item or "").strip()
        if text and text not in fields:
            fields.append(text)
    return fields


def _resolve_domain(*, intent_name: str, primary_operation_code: Optional[str], classification: str) -> str:
    normalized_op = str(primary_operation_code or "").strip().lower()
    normalized_intent = str(intent_name or "").strip().lower()
    normalized_classification = str(classification or "").strip().lower()
    candidate = normalized_op or normalized_intent

    if candidate.startswith("project.") or normalized_classification in {"project", "new_project"}:
        return DOMAIN_PROJECT
    if candidate.startswith("task.") or normalized_classification == "task":
        return DOMAIN_TASK
    if (
        candidate.startswith("signal.")
        or candidate.startswith("signal_source.")
        or candidate.startswith("project_signal.")
        or normalized_classification in {"signal", "project_signal", "command"}
    ):
        return DOMAIN_SIGNAL
    if candidate.startswith("followup."):
        return DOMAIN_FOLLOWUP
    if candidate in _QUERY_OPERATION_CODES or normalized_classification in {"question", "qa"}:
        return DOMAIN_RAG
    return DOMAIN_GENERIC


def _is_query_like(*, primary_operation_code: Optional[str], intent_name: str) -> bool:
    normalized_op = str(primary_operation_code or "").strip().lower()
    normalized_intent = str(intent_name or "").strip().lower()
    return normalized_op in _QUERY_OPERATION_CODES or normalized_intent == "query.read_only"


def _derive_allow_execute(
    *,
    primary_operation_code: Optional[str],
    status: str,
    missing_fields: list[str],
) -> bool:
    if _is_query_like(primary_operation_code=primary_operation_code, intent_name=str(primary_operation_code or "")):
        return False
    if missing_fields:
        return False
    normalized_status = str(status or "").strip().lower()
    return normalized_status in {"succeeded", "answered", "captured", "completed"}


def _looks_like_scope_expansion(message_text: str) -> bool:
    return bool(_SCOPE_EXPANSION_RE.search(str(message_text or "")))


def _looks_like_brainstorm(message_text: str) -> bool:
    return bool(_BRAINSTORM_RE.search(str(message_text or "")))


def _looks_like_advice(message_text: str) -> bool:
    return bool(_ADVISE_RE.search(str(message_text or "")))


def _derive_mode(
    *,
    intent_name: str,
    message_text: str,
    status: str,
    risk_level: str,
    missing_fields: list[str],
    allow_execute: bool,
    primary_operation_code: Optional[str],
) -> str:
    if missing_fields:
        return MODE_CLARIFY
    if _looks_like_scope_expansion(message_text):
        return MODE_CHALLENGE
    if str(risk_level or "").strip().lower() == "high" and not allow_execute and not _is_query_like(
        primary_operation_code=primary_operation_code,
        intent_name=intent_name,
    ):
        return MODE_CHALLENGE
    if _looks_like_brainstorm(message_text):
        return MODE_BRAINSTORM
    if allow_execute and not _is_query_like(primary_operation_code=primary_operation_code, intent_name=intent_name):
        return MODE_EXECUTE
    if _looks_like_advice(message_text) or _is_query_like(primary_operation_code=primary_operation_code, intent_name=intent_name):
        return MODE_ADVISE
    if str(status or "").strip().lower() == "pending_manual":
        return MODE_CHALLENGE
    return MODE_ADVISE


def _build_clarify_next_action(*, missing_fields: list[str], direct_reply_text: str) -> str:
    if direct_reply_text:
        return direct_reply_text[:240]
    labels = [_MISSING_FIELD_LABELS.get(item, item) for item in missing_fields]
    suffix = "、".join([label for label in labels if label]) or "关键信息"
    return f"请先补充 {suffix}，我再继续推进。"


def _build_next_action(
    *,
    domain: str,
    mode: str,
    risk_level: str,
    missing_fields: list[str],
    direct_reply_text: str,
) -> str:
    if mode == MODE_CLARIFY:
        return _build_clarify_next_action(
            missing_fields=missing_fields,
            direct_reply_text=direct_reply_text,
        )
    if mode == MODE_CHALLENGE:
        if direct_reply_text:
            return direct_reply_text[:240]
        if str(risk_level or "").strip().lower() == "high":
            return "建议先拆分范围，再确认是否继续推进高风险动作。"
        return "建议先确认目标边界与优先级，再决定是否继续推进。"
    if mode == MODE_BRAINSTORM:
        return "请补充目标用户、核心场景和约束，我会继续给出 2-3 个可选方向。"
    if mode == MODE_EXECUTE:
        if domain == DOMAIN_PROJECT:
            return "可继续查看项目结果，或补充负责人与排期信息。"
        if domain == DOMAIN_TASK:
            return "可继续补充负责人、优先级或截止时间。"
        if domain == DOMAIN_SIGNAL:
            return "可继续确认归属项目，或查看后续自动处理结果。"
        return "可继续查看结果，或补充更多执行细节。"
    if direct_reply_text:
        return direct_reply_text[:240]
    return "你可以继续追问细节，或让我给出更具体的建议。"


def build_consultant_dispatch_contract(
    *,
    intent_name: str,
    message_text: str,
    source_system: str,
    status: str,
    classification: str,
    primary_operation_code: Optional[str],
    risk_level: str,
    missing_fields: Optional[list[str]] = None,
    direct_reply_text: str = "",
) -> dict[str, Any]:
    normalized_missing = _normalize_missing_fields(missing_fields)
    domain = _resolve_domain(
        intent_name=intent_name,
        primary_operation_code=primary_operation_code,
        classification=classification,
    )
    allow_execute = _derive_allow_execute(
        primary_operation_code=primary_operation_code,
        status=status,
        missing_fields=normalized_missing,
    )
    mode = _derive_mode(
        intent_name=intent_name,
        message_text=message_text,
        status=status,
        risk_level=risk_level,
        missing_fields=normalized_missing,
        allow_execute=allow_execute,
        primary_operation_code=primary_operation_code,
    )
    _ = resolve_prompt_dispatch(domain=domain, mode=mode, channel=source_system)
    return {
        "domain": domain,
        "mode": mode,
        "risk_level": str(risk_level or "low").strip().lower() or "low",
        "missing_fields": normalized_missing,
        "allow_execute": bool(allow_execute),
        "next_action": _build_next_action(
            domain=domain,
            mode=mode,
            risk_level=risk_level,
            missing_fields=normalized_missing,
            direct_reply_text=str(direct_reply_text or "").strip(),
        ),
    }


def resolve_prompt_dispatch(*, domain: str, mode: str, channel: str) -> dict[str, Any]:
    normalized_domain = str(domain or "").strip().lower() or DOMAIN_GENERIC
    normalized_mode = str(mode or "").strip().lower() or MODE_ADVISE
    normalized_channel = str(channel or "").strip().lower() or "pmflow"
    return {
        "domain_prompt": CONSULTANT_DOMAIN_PROMPT_REGISTRY.get(
            normalized_domain,
            CONSULTANT_DOMAIN_PROMPT_REGISTRY[DOMAIN_GENERIC],
        ),
        "mode_wrapper": CONSULTANT_MODE_WRAPPER_REGISTRY.get(
            normalized_mode,
            CONSULTANT_MODE_WRAPPER_REGISTRY[MODE_ADVISE],
        ),
        "channel_strategy": CONSULTANT_CHANNEL_STRATEGIES.get(
            normalized_channel,
            CONSULTANT_CHANNEL_STRATEGIES["pmflow"],
        ),
    }


def build_channel_consultant_reply(
    *,
    consultant_dispatch: Any,
    direct_reply_text: str = "",
    channel: str,
) -> str:
    if not isinstance(consultant_dispatch, dict):
        return ""
    mode = str(consultant_dispatch.get("mode") or "").strip().lower()
    if mode not in {MODE_CLARIFY, MODE_CHALLENGE, MODE_BRAINSTORM, MODE_ADVISE}:
        return ""

    dispatch_meta = resolve_prompt_dispatch(
        domain=str(consultant_dispatch.get("domain") or DOMAIN_GENERIC),
        mode=mode,
        channel=channel,
    )
    channel_strategy = dispatch_meta.get("channel_strategy") if isinstance(dispatch_meta, dict) else {}
    max_chars = int((channel_strategy or {}).get("max_chars") or 220)
    reply_text = str(direct_reply_text or "").strip()
    if reply_text:
        return reply_text[:max_chars]

    next_action = str(consultant_dispatch.get("next_action") or "").strip()
    missing_fields = _normalize_missing_fields(consultant_dispatch.get("missing_fields"))
    if mode == MODE_CLARIFY:
        labels = [_MISSING_FIELD_LABELS.get(item, item) for item in missing_fields]
        suffix = "、".join([label for label in labels if label]) or "关键信息"
        return f"当前还不能继续推进，请先补充 {suffix}。{next_action or '补齐后我再继续处理。'}"[:max_chars]
    if mode == MODE_CHALLENGE:
        return f"这次动作风险较高，建议先不要直接推进。{next_action or '请先确认边界后再继续。'}"[:max_chars]
    if mode == MODE_BRAINSTORM:
        return f"我们可以先一起发散方案。{next_action or '请补充目标和约束，我给你几个方向。'}"[:max_chars]
    return f"当前建议：{next_action or '先按最稳妥方向继续。'}"[:max_chars]


__all__ = [
    "build_channel_consultant_reply",
    "build_consultant_dispatch_contract",
    "resolve_prompt_dispatch",
]