"""叩心枢触发条件引擎：接口与实现。

设计 docs/domain/core-domains.md §5。
"""

from __future__ import annotations

from collections.abc import Sequence
from dataclasses import dataclass, field
from datetime import UTC, datetime

from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.big_cycle import BigCycle
from app.models.chat import ChatMessage
from app.models.drive import CuriosityQuestion
from app.models.evolution import EvolutionCandidate
from app.models.memory import Memory
from app.models.personality_emotion import CharacterEmotionState
from app.models.time_anniversary import TimeAnniversary
from app.modules.personality.emotion import EmotionState

# ---------------------------------------------------------------------------
# 条件接口
# ---------------------------------------------------------------------------


@dataclass
class ConditionResult:
    """条件检查结果。"""

    triggered: bool = False
    """是否触发。"""
    trigger_reason: str = ""
    """触发理由描述（传入 opener prompt）。"""
    context: dict = field(default_factory=dict)
    """开场上下文数据（可选的纪念日/好奇心问题等）。"""
    condition_name: str = ""
    """触发条件的唯一名称（用于事件推送的 trigger 字段）。"""


class ProactiveCondition:
    """主动触发条件检查器基类。

    子类重写 check() 方法，返回 ConditionResult。
    纯逻辑，不修改 DB——叩心枢主循环在 check 通过后才执行写入。
    """

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,
    ) -> ConditionResult:
        raise NotImplementedError


# ---------------------------------------------------------------------------
# 第一梯队 ▸ 数据已在系统中流动
# ---------------------------------------------------------------------------


class TimeElapsedCondition(ProactiveCondition):
    """空闲超时：查该角色最后一条消息时间，超过 min_idle_minutes 触发。

    初次创建的角色（无历史消息）不触发——有意为之，避免新建角色立刻问候。
    """

    def __init__(self, min_idle_minutes: int = 360) -> None:
        self.min_idle_minutes = min_idle_minutes

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,
    ) -> ConditionResult:
        now = now or datetime.now(UTC)
        result = await session.execute(
            select(func.max(ChatMessage.created_at)).where(ChatMessage.character_id == character_id)
        )
        last_time: datetime | None = result.scalar()
        if last_time is None:
            return ConditionResult()  # 无历史消息，不触发
        if last_time.tzinfo is None:
            last_time = last_time.replace(tzinfo=UTC)
        idle = (now - last_time).total_seconds() / 60
        if idle >= self.min_idle_minutes:
            hours = int(idle // 60)
            return ConditionResult(
                triggered=True,
                trigger_reason=f"距离上次对话已过去 {hours} 小时",
                condition_name="idle",
            )
        return ConditionResult()


class TimeOfDayCondition(ProactiveCondition):
    """时段问候：若当前时间在配置的时段窗口内，按窗口名触发。

    windows 配置示例：["morning", "late_night"]
    默认时段映射：
      morning   06:00–09:00
      afternoon 12:00–14:00
      evening   17:00–19:00
      late_night 22:00–24:00
    """

    _WINDOWS: dict[str, tuple[int, int]] = {
        "morning": (6, 9),
        "afternoon": (12, 14),
        "evening": (17, 19),
        "late_night": (22, 24),
    }

    def __init__(self, windows: list[str] | None = None) -> None:
        self.windows = windows or ["morning", "late_night"]

    async def check(
        self,
        _character_id: str,
        _session: AsyncSession,
        *,
        now: datetime | None = None,
    ) -> ConditionResult:
        now = now or datetime.now(UTC)
        hour = now.hour
        matched: str | None = None
        for name in self.windows:
            start, end = self._WINDOWS.get(name, (0, 0))
            if start <= hour < end:
                matched = name
                break
        if matched is None:
            return ConditionResult()
        label = {
            "morning": "早晨",
            "afternoon": "午后",
            "evening": "傍晚",
            "late_night": "深夜",
        }.get(matched, matched)
        return ConditionResult(
            triggered=True,
            trigger_reason=f"当前是{label}时段",
            context={"time_of_day": matched},
            condition_name="time_of_day",
        )


class AnniversaryCondition(ProactiveCondition):
    """纪念日匹配：每日首次 tick 检查 TimeAnniversary 表，匹配当天日期。

    已通知标记：每次触发后写一条审计事件或专用记录 key，当天不重复。
    使用简单的轮次标记：本实现通过检查该 character 当天是否有
    已推送的 AnniversaryCondition 触发记录来判断——非精确消费语义，
    但对 30s tick 的场景已足够（最多漏 1 个 tick，不影响）。
    """

    def __init__(self) -> None:
        self._checked_today: set[str] = set()
        """{(character_id, date.isoformat())} 已检查过的组合——防止同一天多次 tick 重复推送。"""

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,
    ) -> ConditionResult:
        now = now or datetime.now(UTC)
        today = now.date().isoformat()
        key = f"{character_id}:{today}"
        if key in self._checked_today:
            return ConditionResult()
        self._checked_today.add(key)

        result = await session.execute(
            select(TimeAnniversary).where(
                TimeAnniversary.character_id == character_id,
                TimeAnniversary.date == today,
            )
        )
        anniversaries: Sequence[TimeAnniversary] = result.scalars().all()
        if not anniversaries:
            return ConditionResult()

        # 取第一个匹配的纪念日作为上下文
        ann = anniversaries[0]
        kind_labels = {"birthday": "生日", "reunion": "重逢纪念日", "custom": "纪念日"}
        kind_label = kind_labels.get(ann.kind, ann.kind)
        return ConditionResult(
            triggered=True,
            trigger_reason=f"今天是{kind_label}",
            context={
                "anniversary_kind": ann.kind,
                "anniversary_label": ann.name or kind_label,
                "anniversary_date": ann.date,
            },
            condition_name="anniversary",
        )


class UserReunionCondition(ProactiveCondition):
    """用户归来检测：通过 audit_event 或辰正事件判断用户是否刚回来。

    查询最近一次 time.reunion 类型审计事件，若比上次消费的时间更新则触发。
    """

    def __init__(self) -> None:
        self._last_seen_reunion: str | None = None
        """上次已消费的 reunion 事件的 ID——避免重复触发。"""

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,  # noqa: ARG002
    ) -> ConditionResult:
        from app.models.safety import AuditEvent

        result = await session.execute(
            select(AuditEvent)
            .where(
                AuditEvent.character_id == character_id,
                AuditEvent.action == "time.reunion",
            )
            .order_by(AuditEvent.created_at.desc())
            .limit(1)
        )
        event = result.scalar_one_or_none()
        if event is None:
            return ConditionResult()
        if self._last_seen_reunion == event.id:
            return ConditionResult()
        self._last_seen_reunion = event.id
        return ConditionResult(
            triggered=True,
            trigger_reason="用户回到了灵台",
            condition_name="reunion",
        )


class EmotionChangeCondition(ProactiveCondition):
    """情绪变化：对比缓存的上一轮 EmotionState 快照，强度变化超过阈值触发。

    同一 mood 变化后至少 recheck_cooldown_ticks 个 tick 内不再检查。
    """

    def __init__(self, min_delta: float = 0.3, recheck_cooldown_ticks: int = 10) -> None:
        self.min_delta = min_delta
        self.recheck_cooldown_ticks = recheck_cooldown_ticks
        self._previous: dict[str, EmotionState] = {}
        self._cooldown: dict[str, int] = {}

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,  # noqa: ARG002
    ) -> ConditionResult:
        # 冷却检查
        if character_id in self._cooldown:
            remaining = self._cooldown[character_id]
            if remaining > 0:
                self._cooldown[character_id] = remaining - 1
                return ConditionResult()
            del self._cooldown[character_id]

        # 读当前情绪
        result = await session.execute(
            select(CharacterEmotionState).where(CharacterEmotionState.character_id == character_id)
        )
        row = result.scalar_one_or_none()
        if row is None:
            return ConditionResult()
        current = EmotionState(mood=row.mood, intensity=row.intensity)

        # 对比快照
        previous = self._previous.get(character_id)
        self._previous[character_id] = current  # 更新快照
        if previous is None:
            return ConditionResult()  # 首次无对比基线

        if abs(current.intensity - previous.intensity) < self.min_delta:
            return ConditionResult()

        # 触发
        mood_labels = {
            "neutral": "平静",
            "pleased": "愉悦",
            "touched": "感动",
            "wistful": "怅然怀念",
            "concerned": "关切",
            "festive": "喜庆",
            "melancholy": "惆怅",
        }
        from_label = mood_labels.get(previous.mood, previous.mood)
        to_label = mood_labels.get(current.mood, current.mood)
        intensity_pct = round(current.intensity * 100)
        self._cooldown[character_id] = self.recheck_cooldown_ticks

        return ConditionResult(
            triggered=True,
            trigger_reason=f"情绪从「{from_label}」变为「{to_label}（强度 {intensity_pct}%）」",
            context={
                "from_mood": previous.mood,
                "to_mood": current.mood,
                "from_intensity": previous.intensity,
                "to_intensity": current.intensity,
            },
            condition_name="emotion",
        )


class CuriosityCondition(ProactiveCondition):
    """好奇心触发：查该角色是否有 CuriosityQuestion（status=active）未被用户看到。

    取最新一条作为开场上下文。消费后应标记该问题为 'answered' 或 'seen'（由外部驱动，
    叩心枢只读不写）。
    """

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,  # noqa: ARG002
    ) -> ConditionResult:
        result = await session.execute(
            select(CuriosityQuestion)
            .where(CuriosityQuestion.character_id == character_id)
            .order_by(CuriosityQuestion.created_at.desc())
            .limit(1)
        )
        question = result.scalar_one_or_none()
        if question is None:
            return ConditionResult()
        return ConditionResult(
            triggered=True,
            trigger_reason="角色有一个想问的问题",
            context={
                "curiosity_question": question.question,
                "curiosity_id": question.id,
            },
            condition_name="curiosity",
        )


# ---------------------------------------------------------------------------
# 第二梯队 ▸ 需跨模块联动
# ---------------------------------------------------------------------------


class EvolutionAppliedCondition(ProactiveCondition):
    """演化应用：查 evolution_candidates 表，自上次检查后有新 applied 的记录则触发。

    取最近一条 status=applied 的记录，用 title 和 proposal 作为开场上下文。
    这样角色可以自然地谈起自己的变化。
    """

    def __init__(self) -> None:
        self._last_seen_at: datetime | None = None
        """上次已触发的演化候选的 created_at。"""

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,  # noqa: ARG002
    ) -> ConditionResult:
        result = await session.execute(
            select(EvolutionCandidate)
            .where(
                EvolutionCandidate.character_id == character_id,
                EvolutionCandidate.status == "applied",
            )
            .order_by(EvolutionCandidate.created_at.desc())
            .limit(1)
        )
        candidate = result.scalar_one_or_none()
        if candidate is None:
            return ConditionResult()
        if self._last_seen_at is not None and candidate.created_at <= self._last_seen_at:
            return ConditionResult()
        self._last_seen_at = candidate.created_at
        return ConditionResult(
            triggered=True,
            trigger_reason=f"发生了新的变化：{candidate.title}",
            context={
                "evolution_title": candidate.title,
                "evolution_proposal": candidate.proposal[:200],
                "evolution_level": candidate.level,
            },
            condition_name="evolution_applied",
        )


class BigCycleCompletedCondition(ProactiveCondition):
    """大周天完成：查 big_cycles 表，自上次检查后有新完成的循环则触发。

    取最近一条 status=completed 的记录，从 summary 提取可分享的体悟。
    """

    def __init__(self) -> None:
        self._last_seen_at: datetime | None = None
        """上次已触发的循环的 completed_at。"""

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,  # noqa: ARG002
    ) -> ConditionResult:
        result = await session.execute(
            select(BigCycle)
            .where(
                BigCycle.character_id == character_id,
                BigCycle.status == "completed",
                BigCycle.completed_at.isnot(None),
            )
            .order_by(BigCycle.completed_at.desc())
            .limit(1)
        )
        cycle = result.scalar_one_or_none()
        if cycle is None:
            return ConditionResult()
        if self._last_seen_at is not None and cycle.completed_at <= self._last_seen_at:
            return ConditionResult()
        self._last_seen_at = cycle.completed_at
        summary = cycle.summary or "回顾了一下最近的记忆"
        return ConditionResult(
            triggered=True,
            trigger_reason="大周天自我评估完成，有了新的体悟",
            context={
                "big_cycle_summary": summary,
                "big_cycle_trigger": cycle.trigger,
            },
            condition_name="big_cycle_completed",
        )


class MemoryRecallCondition(ProactiveCondition):
    """记忆唤醒：查角色的 memories 表，自上次检查后有新记忆则触发。

    新记忆的写入源可能是：大周天抽取、资料导入、用户主动创建。
    每次 tick 取最新的未消费记忆作为开场素材。
    """

    def __init__(self) -> None:
        self._last_seen_at: datetime | None = None
        """上次已触发的记忆的 created_at。"""

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,  # noqa: ARG002
    ) -> ConditionResult:
        result = await session.execute(
            select(Memory)
            .where(
                Memory.character_id == character_id,
                Memory.status == "active",
            )
            .order_by(Memory.created_at.desc())
            .limit(1)
        )
        memory = result.scalar_one_or_none()
        if memory is None:
            return ConditionResult()
        if self._last_seen_at is not None and memory.created_at <= self._last_seen_at:
            return ConditionResult()
        self._last_seen_at = memory.created_at
        return ConditionResult(
            triggered=True,
            trigger_reason=f"想起了一件关于「{memory.title}」的事",
            context={
                "memory_title": memory.title,
                "memory_content": memory.content[:200],
                "memory_type": memory.type,
            },
            condition_name="memory_recall",
        )


class RelationshipMilestoneCondition(ProactiveCondition):
    """关系里程碑：统计对话消息数与认识天数，达到阈值时触发。

    每个角色只触发一次同类型的里程碑（记录到 _triggered 集合去重）。
    按 message_milestones → day_milestones 顺序检查，命中即停。
    """

    def __init__(
        self,
        message_milestones: list[int] | None = None,
        day_milestones: list[int] | None = None,
    ) -> None:
        self.message_milestones = message_milestones or [100, 500, 1000]
        self.day_milestones = day_milestones or [30, 180, 365]
        self._triggered: set[str] = set()
        """已触发过的标记集合。格式：{character_id}:messages|days:{value}"""

    async def check(
        self,
        character_id: str,
        session: AsyncSession,
        *,
        now: datetime | None = None,
    ) -> ConditionResult:
        now = now or datetime.now(UTC)

        # 1. 消息数里程碑
        count_result = await session.execute(
            select(func.count())
            .select_from(ChatMessage)
            .where(ChatMessage.character_id == character_id)
        )
        total_messages: int = count_result.scalar() or 0
        for threshold in sorted(self.message_milestones):
            key = f"{character_id}:messages:{threshold}"
            if key in self._triggered:
                continue
            if total_messages >= threshold:
                self._triggered.add(key)
                return ConditionResult(
                    triggered=True,
                    trigger_reason=f"我们已聊了 {total_messages} 条消息",
                    context={
                        "milestone_type": "messages",
                        "milestone_value": total_messages,
                        "milestone_threshold": threshold,
                    },
                    condition_name="relationship_milestone",
                )

        # 2. 天数里程碑
        first_result = await session.execute(
            select(ChatMessage.created_at)
            .where(ChatMessage.character_id == character_id)
            .order_by(ChatMessage.created_at.asc())
            .limit(1)
        )
        first_msg_at: datetime | None = first_result.scalar()
        if first_msg_at is not None:
            if first_msg_at.tzinfo is None:
                first_msg_at = first_msg_at.replace(tzinfo=UTC)
            days = (now - first_msg_at).days
            for threshold in sorted(self.day_milestones):
                key = f"{character_id}:days:{threshold}"
                if key in self._triggered:
                    continue
                if days >= threshold:
                    self._triggered.add(key)
                    return ConditionResult(
                        triggered=True,
                        trigger_reason=f"我们已认识了 {days} 天",
                        context={
                            "milestone_type": "days",
                            "milestone_value": days,
                            "milestone_threshold": threshold,
                        },
                        condition_name="relationship_milestone",
                    )

        return ConditionResult()