WechatOnCloud/bridge/woc_bridge/ui/flows/send_text.py

"""L4 SendTextFlow：发送文本消息状态机。

8 个 transition：activate → click_search_box → type_query → open_session →
focus_input → type_content → send → cleanup。

会话缓存命中时跳过前 4 步，仅做 _verify_session_still_open。
异常时调 _reset_to_idle 恢复 UI 状态。

发送结果校验：通过 SSEVerifyBus 注册等待，MessageStreamer 广播消息时
notify 匹配 talker + content。无 DB 轮询，无熔断器，无雪崩风险。
"""

from __future__ import annotations

import asyncio
import logging
import random
import time
from typing import Optional

from woc_bridge.ui.backends.base import WindowGeometry
from woc_bridge.ui.errors import FlowError, PermanentError
from woc_bridge.ui.flow import (
    Flow,
    FlowContext,
    FlowResult,
    FlowState,
    _FLOW_TIMEOUT_SEC,
)

logger = logging.getLogger("woc-bridge")

# 微信窗口标题
_WECHAT_WINDOW_TITLE = "微信"


class SendTextFlow(Flow):
    """发送文本消息 Flow。"""

    def __init__(self, actions, db_reader=None, session_cache=None,
                 verify_bus=None) -> None:
        """初始化 SendTextFlow。

        Args:
            actions: L3 Actions 实例
            db_reader: 保留参数兼容性（不再用于 verify，仅供 base 类）
            session_cache: 会话缓存（SessionCache 实例）
            verify_bus: SSE 发送结果校验总线（SSEVerifyBus 实例）。
                        None 时 verified 永远为 False（不阻塞发送）。
        """
        super().__init__(actions, db_reader)
        self.session_cache = session_cache
        self.verify_bus = verify_bus

    async def run(self, ctx: FlowContext) -> FlowResult:
        """执行发送文本流程。"""
        started_at = time.monotonic()

        logger.info(
            "[flow:send_text] START to_wxid=%s display_name=%s content_len=%d client_request_id=%s",
            ctx.to_wxid, ctx.display_name, len(ctx.content), ctx.client_request_id,
        )
        try:
            async with asyncio.timeout(_FLOW_TIMEOUT_SEC):
                # 检查会话缓存（用 to_wxid 做 key，display_name 非唯一）
                cache_hit = False
                if self.session_cache is not None:
                    cache_hit = self.session_cache.get(ctx.to_wxid)
                    if cache_hit:
                        logger.info(
                            "[flow:send_text] session cache hit for %s",
                            ctx.to_wxid,
                        )

                if cache_hit:
                    # 跳过 click_search_box ~ open_session，但仍需激活窗口
                    # （30s 内用户可能切到其他应用，微信失去焦点）
                    t0 = time.perf_counter()
                    # 仅激活窗口 + 获取几何，跳过 Esc 清场（会话已打开）
                    await self.actions.backend.activate_window(_WECHAT_WINDOW_TITLE)
                    ctx.win_geom = self._ensure_valid_geometry(
                        await self.actions.backend.get_window_geometry(
                            _WECHAT_WINDOW_TITLE
                        )
                    )
                    # 校验会话仍打开；失败时回退到完整流程，不直接返回失败
                    try:
                        await self._verify_session_still_open(ctx)
                        ctx.current_state = FlowState.SESSION_OPENED
                        logger.info(
                            "[flow:send_text] cache_hit branch done geom=%dx%d (%.0fms)",
                            ctx.win_geom.width, ctx.win_geom.height,
                            (time.perf_counter() - t0) * 1000,
                        )
                    except PermanentError as verify_exc:
                        logger.info(
                            "[flow:send_text] cache_hit verify failed, fallback to full flow: %s (%.0fms)",
                            verify_exc, (time.perf_counter() - t0) * 1000,
                        )
                        # 失效缓存，走完整流程
                        if self.session_cache is not None:
                            self.session_cache.invalidate(ctx.to_wxid)
                        cache_hit = False

                if not cache_hit:
                    # 完整流程
                    await self._activate(ctx)
                    await self._click_search_box(ctx)
                    await self._type_query(ctx)
                    await self._open_session(ctx)

                await self._focus_input(ctx)
                await self._type_content(ctx)
                await self._send(ctx)
                await self._cleanup(ctx)

                # 成功：更新会话缓存（用 to_wxid 做 key）
                # SSE verify 通过才缓存，避免发错会话被缓存
                if self.session_cache is not None and ctx.verified:
                    self.session_cache.set(ctx.to_wxid)

                logger.info(
                    "[flow:send_text] DONE success=%s verified=%s local_id=%s state=%s (%.0fms)",
                    True, ctx.verified, ctx.local_send_id, ctx.current_state,
                    (time.monotonic() - started_at) * 1000,
                )

                return FlowResult(
                    success=True,
                    local_id=ctx.local_send_id,
                    verified=ctx.verified,
                    state=ctx.current_state,
                    image_confidence=ctx.image_confidence,
                    duration_ms=(time.monotonic() - started_at) * 1000,
                )

        except (FlowError, asyncio.TimeoutError) as exc:
            logger.warning(
                "[flow:send_text] failed at state=%s: %s: %s",
                ctx.current_state, type(exc).__name__, exc,
            )
            # 尝试恢复
            try:
                await self._reset_to_idle(ctx.win_geom)
            except Exception as reset_exc:
                logger.warning(
                    "[flow:send_text] reset_to_idle failed: %s", reset_exc
                )
            # 失败时仅失效当前联系人会话缓存
            if self.session_cache is not None:
                self.session_cache.invalidate(ctx.to_wxid)

            error_code = "SEND_FAILED"
            error_msg = str(exc)
            if isinstance(exc, FlowError) and exc.code:
                error_code = exc.code
            elif isinstance(exc, asyncio.TimeoutError):
                error_code = "SEND_TIMEOUT"

            return FlowResult(
                success=False,
                local_id=ctx.local_send_id,
                verified=False,
                error=error_msg,
                error_code=error_code,
                state=FlowState.FAILED,
                duration_ms=(time.monotonic() - started_at) * 1000,
            )
        except Exception as exc:
            logger.exception("[flow:send_text] unexpected exception")
            try:
                await self._reset_to_idle(ctx.win_geom)
            except Exception:
                pass
            if self.session_cache is not None:
                self.session_cache.invalidate(ctx.to_wxid)
            return FlowResult(
                success=False,
                error=str(exc),
                error_code="BRIDGE_INTERNAL_ERROR",
                state=FlowState.FAILED,
                duration_ms=(time.monotonic() - started_at) * 1000,
            )

    # ------------------------------------------------------------------
    # Transitions
    # ------------------------------------------------------------------
    async def _activate(self, ctx: FlowContext) -> None:
        """激活窗口 + Esc 清场（关闭残留搜索框/弹窗）。"""
        t0 = time.perf_counter()
        logger.info("[flow:send_text] step=activate start")
        await self.actions.backend.activate_window(_WECHAT_WINDOW_TITLE)
        ctx.win_geom = self._ensure_valid_geometry(
            await self.actions.backend.get_window_geometry(_WECHAT_WINDOW_TITLE)
        )
        # 点击 session_manager_icon 强制回到会话列表首页，清除搜索覆盖层
        await self.actions.click_element("session_manager_icon", ctx.win_geom)
        # Esc 关闭可能的弹窗/搜索框
        await self.actions.backend.key_press("Escape")
        await asyncio.sleep(0.3)
        ctx.current_state = FlowState.WINDOW_ACTIVATED
        logger.info(
            "[flow:send_text] activated window geom=%dx%d (%.0fms)",
            ctx.win_geom.width, ctx.win_geom.height,
            (time.perf_counter() - t0) * 1000,
        )

    async def _click_search_box(self, ctx: FlowContext) -> None:
        """点击搜索框。"""
        t0 = time.perf_counter()
        logger.info("[flow:send_text] step=search_box click start")
        await self.actions.click_element("search_box", ctx.win_geom)
        ctx.current_state = FlowState.SEARCH_BOX_CLICKED
        logger.info(
            "[flow:send_text] step=search_box click done (%.0fms)",
            (time.perf_counter() - t0) * 1000,
        )

    async def _type_query(self, ctx: FlowContext) -> None:
        """输入搜索查询（display_name）。"""
        t0 = time.perf_counter()
        logger.info(
            "[flow:send_text] step=type_query start display_name=%r",
            ctx.display_name,
        )
        # 清空可能的残留：Ctrl+A 全选 + BackSpace 删除，比 BackSpace×30 更可靠
        await self.actions.backend.key_press("ctrl+a")
        await self.actions.backend.key_press("BackSpace")
        await asyncio.sleep(0.2)
        await self.actions.backend.type_text(ctx.display_name)
        ctx.current_state = FlowState.QUERY_TYPED
        # 纯坐标模式下无法用 OpenCV 验证搜索结果是否渲染，
        # 改为固定等待 0.5s 让微信渲染搜索结果列表。
        await asyncio.sleep(0.5)
        logger.info(
            "[flow:send_text] step=type_query done (fixed wait 0.5s, %.0fms)",
            (time.perf_counter() - t0) * 1000,
        )

    async def _open_session(self, ctx: FlowContext) -> None:
        """按 Enter 打开搜索结果第一项（比点击坐标更可靠）。"""
        t0 = time.perf_counter()
        logger.info(
            "[flow:send_text] step=open_session press Enter to open first search result"
        )
        # 微信 4.x 搜索框输入 display_name 后，直接按 Enter 即可打开第一项搜索结果。
        # 这比 click search_result_first 的固定坐标更稳定，不受"搜索网络结果" /
        # "最近在搜" / 联系人结果排序变化的影响。
        await self.actions.backend.key_press("Return")
        ctx.current_state = FlowState.SESSION_OPENED
        # 等待会话切换完成、输入框自动聚焦。
        await asyncio.sleep(0.5)
        logger.info(
            "[flow:send_text] step=open_session done (fixed wait 0.5s, %.0fms)",
            (time.perf_counter() - t0) * 1000,
        )

    async def _focus_input(self, ctx: FlowContext) -> None:
        """聚焦输入框。"""
        t0 = time.perf_counter()
        logger.info("[flow:send_text] step=focus_input click input_box start")
        await self.actions.click_element("input_box", ctx.win_geom)
        ctx.current_state = FlowState.INPUT_FOCUSED
        await asyncio.sleep(0.1)
        logger.info(
            "[flow:send_text] step=focus_input done (%.0fms)",
            (time.perf_counter() - t0) * 1000,
        )

    async def _type_content(self, ctx: FlowContext) -> None:
        """输入消息内容。"""
        t0 = time.perf_counter()
        # 1. 清理首尾空白
        cleaned_content = ctx.content.strip()
        # 2. 把换行符（含 \r\n / \n / \r）替换为空格，避免 xdotool type 把 \n
        #    解析为 Return 键，导致消息在输入过程中被提前分段发送。
        #    微信输入框本身支持 Shift+Enter 换行，但 xdotool type 无法区分。
        normalized_content = cleaned_content.replace("\r\n", " ").replace("\n", " ").replace("\r", " ")
        # 3. 合并连续空格为一个，保持内容整洁
        normalized_content = " ".join(normalized_content.split())
        if normalized_content != ctx.content:
            logger.info(
                "[flow:send_text] step=type_content normalized: "
                "original_len=%d cleaned_len=%d",
                len(ctx.content), len(normalized_content),
            )
        ctx.content = normalized_content
        logger.info(
            "[flow:send_text] step=type_content start content_len=%d",
            len(ctx.content),
        )
        # 4. 输入前清空输入框，避免上次残留内容与本次内容混合
        await self.actions.backend.key_press("ctrl+a")
        await self.actions.backend.key_press("Delete")
        await asyncio.sleep(0.05)
        await self.actions.backend.type_text(ctx.content)
        ctx.current_state = FlowState.TEXT_TYPED
        logger.info(
            "[flow:send_text] step=type_content done (%.0fms)",
            (time.perf_counter() - t0) * 1000,
        )

    async def _send(self, ctx: FlowContext) -> None:
        """触发发送 + SSE 校验。

        纯坐标模式（WOC_DISABLE_OPENCV=1）下用 Enter 键发送，
        避免发送按钮坐标偏移导致点空。微信 4.x 默认 Enter 即发送。
        OpenCV 模式保留点击 send_button（坐标+模板双重保障）。

        关键：register 必须在 send 之前，否则存在竞态条件：
        - T0: 按 Enter 发送
        - T0+0.05: 微信写 DB
        - T0+0.05~T0+1.0: MessageStreamer 轮询 + 广播 + notify（无 waiter → 丢失）
        - T0+0.1: register（已晚于 notify）
        先注册 future，发送后等待 notify 匹配，超时（2.5s）未匹配则
        verified=False，不阻塞发送成功语义（success=True），调用方按需重试。
        """
        t0 = time.perf_counter()
        from woc_bridge.ui.actions import _DISABLE_OPENCV

        # 1. 先注册 SSE 校验等待，避免 send 后 broadcast 已发生的竞态
        verify_future = None
        if self.verify_bus is not None:
            verify_future = self.verify_bus.register(
                to_wxid=ctx.to_wxid,
                content=ctx.content,
            )

        # 2. 触发发送
        if _DISABLE_OPENCV:
            logger.info("[flow:send_text] step=send press Enter start")
            # 短暂等待输入框聚焦稳定，避免 type_text 后焦点未完全落位
            await asyncio.sleep(0.1)
            await self.actions.backend.key_press("Return")
            logger.info("[flow:send_text] step=send press Enter done")
        else:
            logger.info("[flow:send_text] step=send click send_button start")
            await self.actions.click_element("send_button", ctx.win_geom)
        ctx.current_state = FlowState.SENT
        ctx.local_send_id = f"local_{int(time.time())}_{random.randint(1000,9999)}"

        # 3. 等待 SSE 校验结果
        ctx.verified = await self._wait_verify(verify_future, ctx)
        logger.info(
            "[flow:send_text] step=send done local_id=%s verified=%s (%.0fms)",
            ctx.local_send_id, ctx.verified,
            (time.perf_counter() - t0) * 1000,
        )

    async def _cleanup(self, ctx: FlowContext) -> None:
        """清理：Esc。"""
        t0 = time.perf_counter()
        logger.info("[flow:send_text] step=cleanup Esc start")
        await self.actions.backend.key_press("Escape")
        await asyncio.sleep(0.2)
        ctx.current_state = FlowState.CLEANED_UP
        logger.info(
            "[flow:send_text] step=cleanup done (%.0fms)",
            (time.perf_counter() - t0) * 1000,
        )

    # ------------------------------------------------------------------
    # 校验：SSE 推送匹配
    # ------------------------------------------------------------------
    async def _wait_verify(self, future: Optional[asyncio.Future], ctx: FlowContext) -> bool:
        """等待 SSEVerifyBus 的 future 完成。

        future 由 _send 在触发发送前 register，确保 MessageStreamer
        广播消息时 notify 能匹配到 waiter。匹配到返回 True，超时返回 False。

        无 DB 轮询、无截图校验、无熔断器，避免雪崩。
        future 为 None 时（verify_bus 未注入）直接返回 False，不阻塞发送。
        """
        if future is None:
            logger.warning(
                "[flow:send_text] no verify_bus, skip SSE verify (verified=False)"
            )
            return False
        t0 = time.perf_counter()
        try:
            result = await self.verify_bus.wait(future)
            elapsed_ms = (time.perf_counter() - t0) * 1000
            if result:
                logger.info(
                    "[flow:send_text] SSE verify OK (talker=%s content matched, %.0fms)",
                    ctx.to_wxid, elapsed_ms,
                )
            else:
                logger.warning(
                    "[flow:send_text] SSE verify timeout (talker=%s no matching broadcast, %.0fms)",
                    ctx.to_wxid, elapsed_ms,
                )
            return result
        except Exception as exc:
            logger.warning(
                "[flow:send_text] SSE verify exception: %s (%.0fms)",
                exc, (time.perf_counter() - t0) * 1000,
            )
            return False

    async def _verify_session_still_open(self, ctx: FlowContext) -> None:
        """会话缓存命中时校验会话仍打开。

        纯坐标模式（WOC_DISABLE_OPENCV=1）下 wait_for("input_box") 纯算术
        返回，无法真正校验 UI 状态。此时改用 is_window_active 校验窗口焦点：
        若微信窗口已失焦（用户切到其他应用），cache 失效走完整流程。
        会话是否真的打开仍靠后续 SSE verify 兜底（content 不匹配则 invalidate）。

        OpenCV 模式下保留原逻辑（wait_for input_box 模板匹配）。

        异常处理：get_window_geometry 的 RuntimeError（窗口消失）也转为
        PermanentError，触发 cache_hit 回退到完整流程，避免冒泡为
        BRIDGE_INTERNAL_ERROR。
        """
        t0 = time.perf_counter()
        # 获取窗口几何（缓存命中时未走 _activate），并校验/窄化类型
        try:
            ctx.win_geom = self._ensure_valid_geometry(
                await self.actions.backend.get_window_geometry(_WECHAT_WINDOW_TITLE)
            )
        except (RuntimeError, PermanentError) as exc:
            logger.warning(
                "[flow:send_text] session_still_open FAIL: get_window_geometry failed: %s (%.0fms)",
                exc, (time.perf_counter() - t0) * 1000,
            )
            raise PermanentError(
                "WINDOW_NOT_FOUND",
                f"session cache verify failed: window not found: {exc}",
            )
        from woc_bridge.ui.actions import _DISABLE_OPENCV

        if _DISABLE_OPENCV:
            # 纯坐标模式：校验窗口焦点，避免命中已失焦的会话
            is_active = await self.actions.backend.is_window_active(
                _WECHAT_WINDOW_TITLE
            )
            elapsed_ms = (time.perf_counter() - t0) * 1000
            if not is_active:
                logger.warning(
                    "[flow:send_text] session_still_open FAIL: window not active (%.0fms)",
                    elapsed_ms,
                )
                raise PermanentError(
                    "ELEMENT_NOT_FOUND",
                    "session cache verify failed: window not active",
                )
            logger.info(
                "[flow:send_text] session_still_open OK (window active, %.0fms)",
                elapsed_ms,
            )
            return

        # OpenCV 模式：用 input_box 模板匹配校验
        try:
            elem = await self.actions.wait_for(
                "input_box", ctx.win_geom, timeout=2.0, interval=0.3
            )
            if elem is None:
                logger.warning(
                    "[flow:send_text] session_still_open FAIL: input_box not found (%.0fms)",
                    (time.perf_counter() - t0) * 1000,
                )
                raise PermanentError(
                    "ELEMENT_NOT_FOUND",
                    "session cache verify failed: input_box not found",
                )
            logger.info(
                "[flow:send_text] session_still_open OK (%.0fms)",
                (time.perf_counter() - t0) * 1000,
            )
        except PermanentError:
            raise
        except Exception as exc:
            logger.warning(
                "[flow:send_text] session_still_open exception: %s (%.0fms)",
                exc, (time.perf_counter() - t0) * 1000,
            )
            raise PermanentError(
                "ELEMENT_NOT_FOUND",
                f"session cache verify failed: {exc}",
            )