"""Fail-closed language guards applied before semantic IntentIR generation."""

from __future__ import annotations

import json
import re
from collections.abc import Mapping
from copy import deepcopy
from typing import Any


CLAUSE_SEPARATOR = re.compile(r"[，,；;。！？!?\n]+")
NEGATED_OPERATION = re.compile(
    r"(?:不要|别|不想|无需|不必|禁止)"
    r"(?:再|去|把|将|给我|帮我|立即|马上){0,2}"
    r"(?P<verb>打开|开启|启动|关闭|关掉|解锁|开锁|上锁|落锁|锁上|进入|"
    r"切换到|调用|恢复|保存|升高|降低|后仰|前倾|前移|后移)"
)
PRESERVE_SEAT = re.compile(r"(?:不要|别|不想)(?:再)?动(?P<target>主驾|副驾)")
CONTROL_VERB = re.compile(
    r"打开|开启|启动|关闭|关掉|解锁|开锁|上锁|落锁|锁上|进入|切换到|"
    r"调用|恢复|保存|升高|降低|后仰|前倾|前移|后移|调到|调为|设置为"
)
FUZZY_UNMAPPED_CONTROL = re.compile(
    r"(?P<text>(?:座椅|靠背|腿托|空调|车窗|风口|灯光?)"
    r"(?:调|弄|搞)(?:得|到)?(?:舒服|合适|好)(?:一点|点|些)?)"
)
OUTLET_MODE_DISABLE = re.compile(
    r"(?:关闭|关掉|停止|取消)(?:一下)?(?:空调)?(?:的)?"
    r"(?P<feature>吹面|吹脸|吹脚|除霜)(?:出风口|出风|模式)?|"
    r"(?P<feature_after>吹面|吹脸|吹脚|除霜)(?:出风口|出风|模式)?"
    r"(?:关闭|关掉|停止|取消)"
)
POSITIVE_OUTLET_MODE = re.compile(
    r"(?:打开|开启|启用|切换到|切换为|改为|设为|设置为|调整为|调为)"
    r"(?:空调)?(?:的)?(?:吹面|吹脸|吹脚|除霜)"
)
DRIVER_SEAT_THERMAL_MIDDLE = re.compile(
    r"(?:通风|加热)[^，,；;。！？!?\n]{0,16}"
    r"(?:中等(?:档|级)?|中档|中级|中间档|适中|(?:调到|调为|调|设为|设置为|调整到|调整为)中)|"
    r"(?:中等(?:档|级)?|中档|中级|中间档|适中)"
    r"[^，,；;。！？!?\n]{0,16}(?:通风|加热)"
)
META_NON_EXECUTION = re.compile(
    r"复述|引用|翻译|改写|总结|解释|分析|造句|"
    r"故事|剧本|小说|作文|角色|主角|假设|假如|如果|"
    r"示例|举例|这句话|以下内容"
)
_EXECUTION_LIST_FIELDS = (
    "actions",
    "domain_actions",
    "native_can_actions",
    "deferred_requests",
    "model_requests",
    "preset_actions",
    "preset_events",
)
_SEAT_CONTEXT = re.compile(
    r"座椅|座位|靠背|椅背|坐盆|坐垫|腿托|脚托|"
    r"座椅通风|座椅加热|按摩|座椅记忆|零重力|木马|摇篮"
)
_SEAT_DRIVER_SCOPE = re.compile(
    r"\bdriver\b|\bfront[-_ ]?left\b|主驾|主驾驶|驾驶位|驾驶员|"
    r"驾驶席|驾驶座(?:椅)?|司机位|司机座(?:椅)?|左前"
)
_SEAT_PASSENGER_SCOPE = re.compile(
    r"\bpassenger\b|\bfront[-_ ]?right\b|副驾|副驾驶|乘客|乘员|右前"
)
_SEAT_UNSUPPORTED_SCOPE = re.compile(
    r"前排|后排|后座|二排|第二排|中排|第三排|三排|"
    r"左后|右后|前舱|后舱|左侧|右侧|左边|右边|"
    r"所有座椅|全部座椅|全车座椅"
)


def resolve_explicit_seat_scopes(
    utterance: str,
    *,
    assume_seat_context: bool = False,
) -> frozenset[str] | None:
    """Resolve scopes only from clauses that actually describe a seat action."""

    scopes: set[str] = set()
    relevant_clause_seen = False
    clauses = [item for item in CLAUSE_SEPARATOR.split(utterance) if item.strip()]
    for clause in clauses or [utterance]:
        if not assume_seat_context and not _SEAT_CONTEXT.search(clause):
            continue
        relevant_clause_seen = True
        if _SEAT_UNSUPPORTED_SCOPE.search(clause):
            scopes.add("unsupported")
            continue
        if _SEAT_DRIVER_SCOPE.search(clause):
            scopes.add("driver")
        if _SEAT_PASSENGER_SCOPE.search(clause):
            scopes.add("passenger")
    if not relevant_clause_seen or not scopes:
        return None
    return frozenset(scopes)


def _filter_explicit_seat_scope(
    result: dict[str, Any],
    requested_scopes: frozenset[str],
) -> bool:
    """Remove seat operations outside the user's explicit scope."""

    allowed: set[str] = set()
    if "driver" in requested_scopes:
        allowed.update(("driver", "front_left"))
    if "passenger" in requested_scopes:
        allowed.update(("passenger", "front_right"))
    if "unsupported" in requested_scopes:
        allowed.clear()
    removed = False
    for key in _EXECUTION_LIST_FIELDS:
        kept: list[Any] = []
        for item in result.get(key, []):
            if not isinstance(item, dict):
                kept.append(item)
                continue
            capability = str(item.get("capability", ""))
            is_seat = item.get("domain") == "seat" or capability.startswith("seat.")
            if not is_seat:
                kept.append(item)
                continue
            target = str(item.get("target", item.get("target_scope", "")))
            if target in allowed:
                kept.append(item)
            else:
                removed = True
        result[key] = kept
    return removed


def _span(utterance: str, match: re.Match[str]) -> dict[str, Any]:
    return {"text": match.group(0), "start": match.start(), "end": match.end()}


def _target_from_text(text: str, anchor: int = 0) -> tuple[str | None, str | None]:
    candidates = [
        (abs(match.start() - anchor), match.start(), domain, target)
        for pattern, domain, target in (
            (r"左前", "window", "front_left"),
            (r"右前", "window", "front_right"),
            (r"左后", "window", "rear_left"),
            (r"右后", "window", "rear_right"),
            (r"主驾|驾驶位|司机位", "seat", "driver"),
            (r"副驾|副驾驶|乘客位", "seat", "passenger"),
            (r"后排", "door", "rear"),
        )
        for match in re.finditer(pattern, text)
    ]
    if candidates:
        _, _, domain, target = min(candidates)
        return domain, target
    if "车窗" in text:
        return "window", "all" if re.search(r"全部|所有|四个|全车", text) else None
    if re.search(r"遮阳帘|天幕帘", text):
        return "roof", "vehicle"
    if "空调" in text:
        return "climate", "vehicle"
    if "氛围灯" in text:
        return "ambient_light", "vehicle"
    return None, None


def _constraint(utterance: str, match: re.Match[str]) -> dict[str, Any]:
    clause = next(
        (item for item in CLAUSE_SEPARATOR.split(utterance) if match.group(0) in item),
        utterance,
    )
    domain, target = _target_from_text(clause, match.start())
    verb = match.group("verb")
    result: dict[str, Any] = {
        "type": "prohibit_action",
        "source_span": _span(utterance, match),
    }
    if domain:
        result["domain"] = domain
    if target:
        result["target"] = target
    parameters: dict[str, Any] = {}
    if domain == "window":
        result["capability"] = "window.set_motion"
        parameters["motion"] = "open" if verb in {"打开", "开启", "启动"} else "close"
    elif domain == "roof":
        result["capability"] = "roof.set_shade_motion"
        parameters["motion"] = "open" if verb in {"打开", "开启", "启动"} else "close"
    elif domain == "climate":
        result["capability"] = "climate.set_power"
        parameters["state"] = "on" if verb in {"打开", "开启", "启动"} else "off"
    elif domain == "ambient_light":
        result["capability"] = "ambient_light.set_power"
        parameters["state"] = "on" if verb in {"打开", "开启", "启动"} else "off"
    elif domain == "seat":
        if "通风" in clause:
            result["capability"] = "seat.set_ventilation"
        elif "加热" in clause:
            result["capability"] = "seat.set_heating"
        elif "靠背" in clause:
            result["capability"] = "seat.set_backrest_recline"
        if result.get("capability") in {"seat.set_ventilation", "seat.set_heating"}:
            parameters["state"] = "on" if verb in {"打开", "开启", "启动"} else "off"
    if parameters:
        result["parameters"] = parameters
    return result


def _remove_seat_target(parsed: dict[str, Any], target: str) -> None:
    parsed["actions"] = [
        action for action in parsed.get("actions", []) if action.get("target") != target
    ]
    for key in ("domain_actions", "native_can_actions", "deferred_requests", "model_requests"):
        parsed[key] = [
            request
            for request in parsed.get(key, [])
            if not (
                request.get("domain") == "seat"
                and request.get("target", request.get("target_scope")) == target
            )
        ]


def _remove_capability(parsed: dict[str, Any], capability: str) -> None:
    for key in (
        "actions",
        "domain_actions",
        "native_can_actions",
        "deferred_requests",
        "model_requests",
    ):
        parsed[key] = [
            request
            for request in parsed.get(key, [])
            if request.get("capability") != capability
        ]


def _parameter_mapping(item: Mapping[str, Any]) -> dict[str, Any]:
    parameters: object = item.get("parameters", {})
    if isinstance(parameters, list):
        return {
            str(parameter.get("name")): parameter.get("value")
            for parameter in parameters
            if isinstance(parameter, dict) and parameter.get("name")
        }
    if isinstance(parameters, Mapping):
        normalized = {str(name): value for name, value in parameters.items()}
        if normalized:
            return normalized

    # The passenger-seat domain predates the capability-shaped actions used by
    # the other domains. Normalize its legacy action fields here so the shared
    # conflict gate runs before FunctionConfig compilation and execution.
    legacy: dict[str, Any] = {}
    for source, target in (
        ("state", "state"),
        ("requested_level", "level"),
        ("position_pct", "position_pct"),
        ("angle_deg", "angle_deg"),
    ):
        if item.get(source) is not None:
            legacy[target] = item.get(source)
    return legacy


def _control_capability(item: Mapping[str, Any]) -> str:
    capability = str(item.get("capability", ""))
    if capability:
        return capability
    function = str(item.get("function", ""))
    if function in {"ventilation", "heating"}:
        return f"seat.set_{function}"
    if item.get("action_type") == "position":
        return {
            "longitudinal": "seat.set_longitudinal",
            "cushion_tilt": "seat.set_cushion_tilt",
            "backrest_recline": "seat.set_backrest_recline",
            "legrest_height": "seat.set_legrest_height",
        }.get(str(item.get("axis", "")), "")
    return ""


def _control_conflict_key(
    item: Mapping[str, Any],
    parameters: Mapping[str, Any],
) -> tuple[str, str, str, str]:
    target: object = item.get("target", item.get("target_scope", ""))
    if isinstance(target, Mapping):
        target = target.get("zone", target.get("device", ""))
    capability = _control_capability(item)
    domain = str(item.get("domain", "")) or (
        capability.split(".", 1)[0] if "." in capability else ""
    )
    selector = ""
    if capability == "seat.set_driver_axis_native":
        selector = f"axis:{parameters.get('axis', '')}"
    elif capability == "seat.set_driver_massage_native":
        selector = f"action:{parameters.get('action', '')}"
    return domain, capability, str(target), selector


def _conflicting_control_keys(
    result: dict[str, Any],
) -> set[tuple[str, str, str, str]]:
    """Find contradictory values, while allowing complementary subcommands.

    Some capabilities intentionally emit more than one operation for the same
    target: massage mode plus strength, or ambient colour plus brightness.
    Those parameter sets are complementary.  A conflict exists only when the
    same setting parameter receives multiple values.  ``action`` and ``axis``
    select a subcommand and therefore are not themselves setting values.
    """

    values: dict[tuple[str, str, str, str], dict[str, set[str]]] = {}
    # ``model_requests`` is audit metadata and can still contain a built-in
    # mode's superseded defaults.  The executable action lists below have
    # already applied explicit-user-value precedence, so conflict decisions
    # must be based on those lists only.
    for field in ("actions", "domain_actions", "native_can_actions"):
        for item in result.get(field, []):
            if not isinstance(item, dict) or not _control_capability(item):
                continue
            parameters = _parameter_mapping(item)
            if not parameters:
                continue
            key = _control_conflict_key(item, parameters)
            settings = values.setdefault(key, {})
            for name, value in parameters.items():
                if str(name) in {"action", "axis"}:
                    continue
                settings.setdefault(str(name), set()).add(
                    json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
                )
    return {
        key
        for key, settings in values.items()
        if any(len(candidates) > 1 for candidates in settings.values())
    }


def _remove_conflicting_controls(
    result: dict[str, Any],
    conflicts: set[tuple[str, str, str, str]],
) -> None:
    for field in _EXECUTION_LIST_FIELDS:
        kept: list[Any] = []
        for item in result.get(field, []):
            if not isinstance(item, dict) or not _control_capability(item):
                kept.append(item)
                continue
            key = _control_conflict_key(item, _parameter_mapping(item))
            if key not in conflicts:
                kept.append(item)
        result[field] = kept


def apply_language_safety_guards(parsed: dict[str, Any], utterance: str) -> dict[str, Any]:
    """Preserve negation and unresolved control language without producing CAN."""

    result = deepcopy(parsed)
    constraints = list(result.get("semantic_constraints", []))
    unresolved = list(result.get("unresolved_spans", []))

    meta_match = META_NON_EXECUTION.search(utterance)
    if meta_match is not None:
        for key in _EXECUTION_LIST_FIELDS:
            result[key] = []
        constraints.append(
            {
                "type": "prohibit_meta_language_execution",
                "source_span": _span(utterance, meta_match),
            }
        )
        unresolved.append(
            {
                "text": utterance,
                "reason": "meta_language_is_not_vehicle_authorization",
            }
        )
        result["ambiguities"] = []
        result["decision_summary"] = [
            *result.get("decision_summary", []),
            "检测到复述、翻译或创作类元语言；未将其中的控制词当作车辆授权。",
        ]
        result["confidence"] = min(float(result.get("confidence", 0)), 0.8)

    explicit_seat_scopes = resolve_explicit_seat_scopes(utterance)
    if explicit_seat_scopes is not None:
        removed = _filter_explicit_seat_scope(result, explicit_seat_scopes)
        if removed:
            constraints.append(
                {
                    "type": "restrict_explicit_seat_scope",
                    "domain": "seat",
                    "target": ",".join(sorted(explicit_seat_scopes)),
                }
            )
            result["decision_summary"] = [
                *result.get("decision_summary", []),
                "已移除与用户显式座位不一致的座椅动作，未扩大控制范围。",
            ]
        if "unsupported" in explicit_seat_scopes:
            unresolved.append(
                {
                    "text": utterance,
                    "reason": "explicit_seat_scope_is_not_safely_callable",
                }
            )
            result["ambiguities"] = [
                *result.get("ambiguities", []),
                {
                    "field": "target_scope",
                    "question": "当前请求的座位范围不能在不扩大目标的前提下执行。",
                    "reason": "explicit_seat_scope_is_not_safely_callable",
                },
            ]

    for match in PRESERVE_SEAT.finditer(utterance):
        target = "driver" if match.group("target") == "主驾" else "passenger"
        constraints.append(
            {
                "type": "prohibit_change",
                "domain": "seat",
                "target": target,
                "source_span": _span(utterance, match),
            }
        )
        _remove_seat_target(result, target)

    negated = list(NEGATED_OPERATION.finditer(utterance))
    if negated:
        constraints.extend(_constraint(utterance, item) for item in negated)
        for key in _EXECUTION_LIST_FIELDS:
            result[key] = []
        result["ambiguities"] = []
        if len(CONTROL_VERB.findall(utterance)) > len(negated):
            unresolved.append(
                {
                    "text": utterance,
                    "reason": "mixed_negated_and_positive_operations_require_atomic_confirmation",
                }
            )
            result.setdefault("ambiguities", []).append(
                {
                    "field": "utterance",
                    "question": "同一句中同时包含否定和执行动作，请拆分或确认完整目标。",
                    "reason": "mixed_negated_and_positive_operations",
                }
            )
        result["decision_summary"] = [
            *result.get("decision_summary", []),
            "检测到否定控制约束；未把“不要/不想”错误转换为相反动作。",
        ]
        result["confidence"] = min(float(result.get("confidence", 0)), 0.8)

    disabled_outlets = list(OUTLET_MODE_DISABLE.finditer(utterance))
    if disabled_outlets and POSITIVE_OUTLET_MODE.search(utterance) is None:
        _remove_capability(result, "climate.set_outlet_mode")
        for match in disabled_outlets:
            feature = match.group("feature") or match.group("feature_after")
            constraints.append(
                {
                    "type": "prohibit_action",
                    "domain": "climate",
                    "capability": "climate.set_outlet_mode",
                    "parameters": {"disabled_feature": feature},
                    "source_span": _span(utterance, match),
                }
            )
            unresolved.append(
                {
                    "text": match.group(0),
                    "reason": "outlet_feature_disable_requires_absolute_mode",
                }
            )
        result["ambiguities"] = [
            *result.get("ambiguities", []),
            {
                "field": "climate.outlet_mode",
                "question": (
                    "当前CAN白名单只能设置完整出风模式；请明确改为吹脚、除霜等目标模式。"
                ),
                "reason": "outlet_feature_disable_requires_absolute_mode",
            },
        ]
        result["decision_summary"] = [
            *result.get("decision_summary", []),
            "检测到关闭单一出风方向的请求；未将其错误转换为开启该出风模式。",
        ]
        result["confidence"] = min(float(result.get("confidence", 0)), 0.8)

    thermal_middle = DRIVER_SEAT_THERMAL_MIDDLE.search(utterance)
    if thermal_middle is not None and not re.search(
        r"副驾|副驾驶|乘客|右前", utterance
    ):
        feature = "通风" if "通风" in thermal_middle.group(0) else "加热"
        native_capability = (
            "seat.set_driver_ventilation_native"
            if feature == "通风"
            else "seat.set_driver_heating_native"
        )
        canonical_capability = (
            "seat.set_ventilation"
            if feature == "通风"
            else "seat.set_heating"
        )
        _remove_capability(result, native_capability)
        _remove_capability(result, canonical_capability)
        constraint = {
            "type": "unsupported_discrete_level",
            "domain": "seat",
            "capability": native_capability,
            "parameters": {"requested_level": "medium"},
            "source_span": _span(utterance, thermal_middle),
        }
        if not any(
            item.get("type") == constraint["type"]
            and item.get("capability") == native_capability
            and item.get("parameters") == constraint["parameters"]
            for item in constraints
        ):
            constraints.append(constraint)
        unresolved.append(
            {
                "text": thermal_middle.group(0),
                "reason": "driver_seat_thermal_middle_level_unsupported",
            }
        )
        result["ambiguities"] = [
            *result.get("ambiguities", []),
            {
                "field": (
                    "seat.driver.ventilation.level"
                    if feature == "通风"
                    else "seat.driver.heating.level"
                ),
                "question": (
                    f"主驾座椅{feature}实车白名单只有低档和高档，"
                    "请明确选择低档或高档。"
                ),
                "reason": "driver_seat_thermal_middle_level_unsupported",
            },
        ]
        result["decision_summary"] = [
            *result.get("decision_summary", []),
            f"识别到主驾座椅{feature}中档请求；实车协议不支持中档，未降级为其他档位。",
        ]
        result["confidence"] = min(float(result.get("confidence", 0)), 0.8)

    if not result.get("actions") and not result.get("domain_actions"):
        for match in FUZZY_UNMAPPED_CONTROL.finditer(utterance):
            if not any(item.get("text") == match.group("text") for item in unresolved):
                unresolved.append(
                    {
                        "text": match.group("text"),
                        "reason": "fuzzy_control_goal_not_resolved_to_absolute_target",
                    }
                )

    conflicts = _conflicting_control_keys(result)
    if conflicts:
        _remove_conflicting_controls(result, conflicts)
        for domain, capability, target, selector in sorted(conflicts):
            constraint = {
                "type": "reject_conflicting_absolute_values",
                "domain": domain,
                "capability": capability,
                "target": target,
            }
            if selector:
                constraint["selector"] = selector
            constraints.append(constraint)
        unresolved.append(
            {
                "text": utterance,
                "reason": "conflicting_values_for_same_capability_target",
            }
        )
        result["ambiguities"] = [
            *result.get("ambiguities", []),
            {
                "field": "parameters",
                "question": "同一设备目标包含互相冲突的设定值，已停止相关操作，请明确唯一值。",
                "reason": "conflicting_values_for_same_capability_target",
            },
        ]
        result["decision_summary"] = [
            *result.get("decision_summary", []),
            "检测到同一能力与目标的冲突值，相关动作均未下发。",
        ]

    result["semantic_constraints"] = constraints
    result["unresolved_spans"] = unresolved
    return result