"""
Phase 4: 个人微信 (iLink 协议 / 微信 ClawBot 插件) —— 前台用户模块
im_bot_user.py

为【平台注册用户】提供"各自绑定自己的个人微信"能力：
- 每个用户独立一条 im_bot_wechat_account 记录（按 user_id 隔离）
- 扫码登录免 AppID；消息收发走 Bearer bot_token + X-WECHAT-UIN
- 绑定后由七虎AI 大脑自动应答（复用 channels 的真实 LLM 调用）

与后台 im_bot_admin 的区别：
- 后台：平台级 IM Bot 接入中枢（飞书/企微/Telegram 等多平台、路由、统计），其个人微信
  端点仅限 user_id IS NULL 的"全局 Bot"，与用户绑定互不干扰。
- 前台：每个登录用户管理自己的个人微信，数据严格按 user_id 隔离。
"""
import base64
import json
import os
import random
import threading
import time
from datetime import datetime, timedelta, timezone
from typing import Optional
from urllib.parse import quote as _quote

import requests
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import text
from sqlalchemy.orm import Session

from ..auth import get_current_user
from ..database import SessionLocal
from ..models import User

router = APIRouter()

# 北京时间（UTC+8）。容器系统时区为 UTC，所有对外展示/持久化的时间戳必须按北京时间存储，
# 否则前台微信 Bot 对话窗会显示成 UTC（比系统时间早 8 小时）。
TZ_BEIJING = timezone(timedelta(hours=8))


def _beijing_now() -> datetime:
    """返回北京时间的 naive datetime（去掉 tzinfo 以便直接存入 MySQL DATETIME）。"""
    return datetime.now(TZ_BEIJING).replace(tzinfo=None)

# ============================================================
# iLink 协议常量（腾讯官方 iLink Bot HTTP API，直连免 AppID）
# ============================================================
ILINK_BASE = "https://ilinkai.weixin.qq.com"

# 微信/iLink 单条文本消息长度软上限。超过则分段发送，避免 iLink 返回 200
# 但用户侧静默收不到（实测 1698 字符 HTML 链接、3011 字符 Markdown 均丢失）。
WECHAT_TEXT_MAX_LEN = 1500

# 每个已连接账号一个后台接收线程，key = 账号表主键 id
_wechat_receiver_threads: dict[int, threading.Thread] = {}

# typing_ticket 缓存：{ilink_user_id: (ticket, 写入时间戳)}，24h 有效
_typing_ticket_cache: dict[str, tuple[str, float]] = {}


# ============================================================
# 通用 DB 工具
# ============================================================
def _execute_raw(db: Session, sql_text, params=None):
    result = db.execute(sql_text, params or {})
    if result.returns_rows:
        return result.fetchall()
    db.commit()
    return result


def _row_to_dict(row) -> dict:
    if row is None:
        return None
    d = {}
    for col in row._mapping.keys():
        val = row._mapping[col]
        if isinstance(val, datetime):
            val = val.isoformat()
        d[col] = val
    return d


# ============================================================
# iLink 协议请求工具
# ============================================================
def _wechat_headers(bot_token: str) -> dict:
    """iLink 协议请求头：Bearer bot_token + 随机 X-WECHAT-UIN 防重放"""
    uin = base64.b64encode(str(random.randint(0, 2 ** 32 - 1)).encode("utf-8")).decode("utf-8")
    return {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {bot_token}",
        "AuthorizationType": "ilink_bot_token",
        "X-WECHAT-UIN": uin,
    }


def _wechat_row_for_user(db: Session, user_id: str):
    rows = _execute_raw(
        db,
        text("SELECT * FROM im_bot_wechat_account WHERE user_id = :uid ORDER BY id DESC LIMIT 1"),
        {"uid": user_id},
    )
    return rows[0] if rows else None


def _wechat_mask(row) -> dict:
    d = _row_to_dict(row)
    if d.get("bot_token"):
        bt = d["bot_token"]
        d["bot_token"] = ("***" + bt[-6:]) if len(bt) > 6 else "***"
    d.pop("appid", None)
    d.pop("secret_key", None)
    return d


# ============================================================
# 七虎AI 大脑（复用 channels 的真实 LLM 调用）
# ============================================================
def _recent_history(user_id: str, limit: int = 6) -> str:
    """拼接最近若干轮对话，作为多轮上下文。"""
    db = None
    try:
        db = SessionLocal()
        rows = _execute_raw(db, text(
            "SELECT role, content FROM im_bot_chat_log "
            "WHERE user_id=:uid ORDER BY id DESC LIMIT :lim"
        ), {"uid": user_id, "lim": limit})
        pairs = []
        for r in reversed(rows):
            dd = _row_to_dict(r)
            role = "用户" if dd["role"] == "user" else "七虎AI"
            pairs.append(f"{role}：{dd['content']}")
        return "\n".join(pairs)
    except Exception:
        return ""
    finally:
        if db:
            db.close()


def _qihua_reply(text: str, user_id: str = None) -> str:
    """调用七虎AI 生成回复。自行创建 DB 会话，避免上层线程无可用 session。"""
    prompt = text
    if user_id:
        hist = _recent_history(user_id)
        if hist:
            prompt = (
                "以下是你与该用户最近的对话历史，请结合上下文作答：\n"
                f"{hist}\n\n"
                f"用户当前问题：{text}"
            )
    # 磁盘调试日志（不依赖 uvicorn logger）
    try:
        with open("/tmp/im_llm_debug.log", "a", encoding="utf-8") as _f:
            _f.write(_beijing_now().isoformat() + f" _qihua_reply user={user_id} prompt_len={len(prompt)} prompt={repr(prompt)[:500]}\n")
    except Exception:
        pass
    db = None
    try:
        from app.api.im_llm import _call_real_llm
        db = SessionLocal()
        result = _call_real_llm(db, None, prompt, "个人微信", user_id=user_id)
        try:
            with open("/tmp/im_llm_debug.log", "a", encoding="utf-8") as _f:
                _f.write(_beijing_now().isoformat() + f" _qihua_reply RESULT len={len(result) if result else 0} preview={repr(result)[:200]}\n")
        except Exception:
            pass
        return result
    except Exception as e:
        import traceback as _tb2
        import logging
        _log = logging.getLogger('im_bot_user')
        _log.warning(f'[_qihua_reply] 异常: {e}\n{_tb2.format_exc()[:1000]}')
        try:
            with open("/tmp/im_llm_debug.log", "a", encoding="utf-8") as _f:
                _f.write(_beijing_now().isoformat() + f" _qihua_reply EXCEPTION: {e}\n{_tb2.format_exc()[:800]}\n")
        except Exception:
            pass
        return f"（AI 回复生成失败：{e}）"
    finally:
        if db:
            db.close()


# ============================================================
# iLink 消息收发
# ============================================================
def _wechat_get_updates(baseurl: str, bot_token: str, cursor: str):
    """长轮询收消息，返回 (msgs, new_cursor)。最多 hold 35s。"""
    try:
        resp = requests.post(
            baseurl.rstrip("/") + "/ilink/bot/getupdates",
            headers=_wechat_headers(bot_token),
            json={"get_updates_buf": cursor},
            timeout=40,
        )
        if not resp.ok:
            return [], cursor
        j = resp.json() if resp.content else {}
        return j.get("msgs", []) or [], j.get("get_updates_buf", cursor)
    except Exception:
        return [], cursor


def _wechat_post_msg(baseurl: str, bot_token: str, to_user_id: str, context_token: str, item_list: list):
    """向 iLink 发送一条消息（item_list 可含文本/图片/视频等）。返回 (ok, ret, body)。
    ret=-14=会话过期需重扫；ret=-2=token 失效。"""
    payload = {
        "msg": {
            "to_user_id": to_user_id,
            "message_type": 2,
            "message_state": 2,
            "context_token": context_token,
            "item_list": item_list,
        }
    }
    last_body = {}
    # 07-30 diagnostic
    import json as _json3
    try:
        # 增强诊断：记录每条消息类型、长度、内容摘要，用于定位“iLink 200 但用户收不到”
        _item_summaries = []
        for _it in item_list:
            _t = _it.get("type")
            _txt = ""
            if _t == 1 and _it.get("text_item"):
                _txt = _it["text_item"].get("text", "")
            _item_summaries.append(f"type={_t} len={len(_txt)} text={repr(_txt[:80])}")
        with open("/tmp/wechat_send_debug.log", "a", encoding="utf-8") as _f:
            _f.write(_beijing_now().isoformat() + " SEND_DEBUG token=" + repr(bot_token[:20] if bot_token else "NULL")
                     + " to=" + repr(to_user_id[:30]) + " ctx=" + repr(context_token[:30]) + "\n")
            _f.write("  payload_keys=" + str(list(payload.get("msg", {}).keys()))
                     + " items=[" + "; ".join(_item_summaries) + "]\n")
    except Exception:
        pass

    for _ in range(2):
        try:
            resp = requests.post(
                baseurl.rstrip("/") + "/ilink/bot/sendmessage",
                headers=_wechat_headers(bot_token),
                json=payload,
                timeout=20,
            )
            try:
                body = resp.json() if resp.content else {}
            except Exception:
                body = {}
            last_body = body
            ret = body.get("ret") if isinstance(body, dict) else None
            try:
                with open("/tmp/wechat_send.log", "a", encoding="utf-8") as _f:
                    _f.write(_beijing_now().isoformat() + " SEND_HTTP=%s ret=%s body=%s\n"
                             % (resp.status_code, ret, json.dumps(body, ensure_ascii=False)[:300]))
            except Exception:
                pass
            if resp.ok and (ret is None or ret == 0 or not body):
                return True, ret, body
            if ret in (-2, -14):
                return False, ret, body  # 鉴权/会话失效，立即停止重试
        except Exception:
            pass
    return False, (last_body.get("ret") if isinstance(last_body, dict) else None), last_body


def _wechat_send_message(baseurl: str, bot_token: str, to_user_id: str, context_token: str, text: str):
    """发送纯文本回复。长文本按 WECHAT_TEXT_MAX_LEN 分段，避免 iLink 200 但微信不显示。"""
    if not text:
        return _wechat_post_msg(baseurl, bot_token, to_user_id, context_token,
                                 [{"type": 1, "text_item": {"text": "（无内容）"}}])
    # 单条不超过软上限；保留完整段落优先在换行处切分
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + WECHAT_TEXT_MAX_LEN, len(text))
        if end < len(text):
            # 尽量在换行处切断
            _nl = text.rfind("\n", start, end)
            if _nl > start + WECHAT_TEXT_MAX_LEN // 2:
                end = _nl + 1
        chunks.append(text[start:end])
        start = end

    all_ok = True
    last_ret = None
    for idx, chunk in enumerate(chunks):
        suffix = ""
        if len(chunks) > 1:
            if idx == 0:
                suffix = "\n（内容较长，分条发送）"
            if idx == len(chunks) - 1:
                suffix = "\n（已发送完毕；完整内容请访问平台 AI 聊天的 WeXin Bot 窗口）"
        ok, ret, _ = _wechat_post_msg(
            baseurl, bot_token, to_user_id, context_token,
            [{"type": 1, "text_item": {"text": chunk + suffix}}]
        )
        if not ok:
            all_ok = False
            last_ret = ret
            # 记录失败但不中断，尽量把已切好的消息发完
            try:
                with open("/tmp/wechat_send.log", "a", encoding="utf-8") as _f:
                    _f.write(_beijing_now().isoformat() + " SEGMENT_FAIL idx=%s ret=%s\n" % (idx, ret))
            except Exception:
                pass
        # 分段之间稍作间隔，降低频率/风控影响
        if idx < len(chunks) - 1:
            time.sleep(0.5)
    return all_ok, last_ret, {}


def _wechat_get_typing_ticket(baseurl: str, bot_token: str, ilink_user_id: str, context_token: str) -> str:
    """getconfig 获取 typing_ticket（按 ilink_user_id 缓存 24h）。"""
    global _typing_ticket_cache
    _now = time.time()
    _hit = _typing_ticket_cache.get(ilink_user_id)
    if _hit and (_now - _hit[1]) < 86400:
        return _hit[0]
    try:
        resp = requests.post(
            baseurl.rstrip("/") + "/ilink/bot/getconfig",
            headers=_wechat_headers(bot_token),
            json={"ilink_user_id": ilink_user_id, "context_token": context_token},
            timeout=10,
        )
        body = resp.json() if resp.content else {}
        ticket = body.get("typing_ticket", "") if isinstance(body, dict) else ""
        if ticket:
            _typing_ticket_cache[ilink_user_id] = (ticket, _now)
        return ticket
    except Exception:
        return ""


def _wechat_send_typing(baseurl: str, bot_token: str, ilink_user_id: str, typing_ticket: str, status: int = 1) -> bool:
    """发送/取消"正在输入"状态。status=1 typing，2 cancel。失败静默（不阻塞主流程）。"""
    if not ilink_user_id or not typing_ticket:
        return False
    try:
        resp = requests.post(
            baseurl.rstrip("/") + "/ilink/bot/sendtyping",
            headers=_wechat_headers(bot_token),
            json={"ilink_user_id": ilink_user_id, "typing_ticket": typing_ticket, "status": status},
            timeout=10,
        )
        return resp.ok
    except Exception:
        return False


def _platform_relay_url(raw_url: str) -> str:
    """把 AGNES 等境外媒体 URL 改写为平台中转地址，使微信/iLink 可内联渲染。

    iLink 服务器(中国大陆)直连境外 AGNES 常被墙/超时，微信里只能看到"链接"。
    改写为平台中转地址(平台服务器经香港代理可达 AGNES)，微信即可内联显示图片/视频。
    """
    access = os.environ.get("APP_ACCESS_URL", "http://210.16.161.218:12888").rstrip("/")
    return f"{access}/app/api/chat/media/relay?url={_quote(raw_url, safe='')}"


def _wechat_send_media(baseurl: str, bot_token: str, to_user_id: str, context_token: str,
                       media_type: str, url: str):
    """发送媒体（图片/视频）。#969 iLink CDN 内联发送

    优先走 iLink 官方 CDN 加密上传链路，实现图片/视频真正内联显示；
    失败时降级为纯文本链接（点击访问），确保会话不中断。
    """
    relay_url = _platform_relay_url(url)
    # 尝试内联发送（iLink CDN 加密上传）
    try:
        from app.api.im_ilink_media import (
            MEDIA_TYPE_IMAGE, MEDIA_TYPE_VIDEO,
            download_media_bytes, upload_media_to_wechat_cdn,
            build_image_item, build_video_item,
        )
        media_bytes = download_media_bytes(url)
        mt = MEDIA_TYPE_IMAGE if media_type == "image" else MEDIA_TYPE_VIDEO
        uploaded = upload_media_to_wechat_cdn(baseurl, bot_token, to_user_id, media_bytes, mt)
        item = build_image_item(uploaded) if media_type == "image" else build_video_item(uploaded)
        ok, ret, _ = _wechat_post_msg(baseurl, bot_token, to_user_id, context_token, [item])
        if ok:
            try:
                with open("/tmp/wechat_send_debug.log", "a", encoding="utf-8") as _f:
                    _f.write(_beijing_now().isoformat() + " MEDIA_INLINE_OK type=%s size=%d\n"
                             % (media_type, len(media_bytes)))
            except Exception:
                pass
            return True, ret, {}
        try:
            with open("/tmp/wechat_send_debug.log", "a", encoding="utf-8") as _f:
                _f.write(_beijing_now().isoformat() + " MEDIA_INLINE_FAIL ret=%s → fallback text\n" % (ret,))
        except Exception:
            pass
    except Exception as _e:
        try:
            with open("/tmp/wechat_send_debug.log", "a", encoding="utf-8") as _f:
                _f.write(_beijing_now().isoformat() + " MEDIA_INLINE_EXC %s → fallback text\n" % (_e,))
        except Exception:
            pass
    # 降级：纯文本链接
    if media_type == "image":
        caption = "🖼️ 图片已生成，点击查看：" + relay_url
    else:
        caption = "🎬 视频已生成，点击查看：" + relay_url
    return _wechat_send_message(baseurl, bot_token, to_user_id, context_token, caption)


def _wechat_extract_text(msg: dict) -> str:
    parts = []
    for it in (msg.get("item_list") or []):
        _t = it.get("type")
        if _t == 1 and it.get("text_item", {}).get("text"):
            parts.append(it["text_item"]["text"])
        elif _t == 3:
            # 语音消息：微信已自带 ASR 转文字（voice_item.text），直接复用
            voice = it.get("voice_item") or {}
            if voice.get("text"):
                parts.append("[语音] " + str(voice["text"]))
    if not parts:
        for k in ("text", "content", "message", "msg"):
            v = msg.get(k)
            if isinstance(v, str) and v.strip():
                parts.append(v)
    return "\n".join(parts)


def _extract_and_save_inbound_media(msg: dict) -> str:
    """检测入站媒体消息(图片/语音/文件/视频)，下载解密保存，返回给 LLM 的提示文本。

    无媒体或解密失败返回空字符串。图片已保存到本地，供后续 vision 模型接入。
    """
    try:
        from app.api.im_ilink_media import extract_inbound_media
        import os as _os
        for it in (msg.get("item_list") or []):
            if it.get("type") in (2, 3, 4, 5):
                kind, data = extract_inbound_media(it)
                if kind and data:
                    _dir = "/tmp/wechat_inbound_media"
                    _os.makedirs(_dir, exist_ok=True)
                    _ext = {"image": "jpg", "voice": "silk", "file": "bin", "video": "mp4"}.get(kind, "bin")
                    _path = _os.path.join(_dir, "%d_%s.%s" % (int(time.time() * 1000), kind, _ext))
                    with open(_path, "wb") as _f:
                        _f.write(data)
                    _label = {"image": "图片", "voice": "语音", "file": "文件", "video": "视频"}.get(kind, kind)
                    try:
                        with open("/tmp/wechat_inbound_media.log", "a", encoding="utf-8") as _f:
                            _f.write(_beijing_now().isoformat() + " %s saved=%s size=%d\n"
                                     % (kind, _path, len(data)))
                    except Exception:
                        pass
                    return "[用户发送了%s，已保存到 %s（%d 字节）]" % (_label, _path, len(data))
        return ""
    except Exception as _e:
        try:
            with open("/tmp/wechat_inbound_media.log", "a", encoding="utf-8") as _f:
                _f.write(_beijing_now().isoformat() + " MEDIA_EXTRACT_ERR %s\n" % (_e,))
        except Exception:
            pass
        return ""


def _wechat_sender_id(m: dict) -> str:
    """从入站消息中提取发送者 id（兼容多套字段名）。"""
    for k in ("from_user_id", "from_user_name", "from_username", "user_id",
             "sender_id", "wxid", "from_wxid", "username"):
        v = m.get(k)
        if v:
            return str(v)
    return ""


def _wechat_context_token(m: dict) -> str:
    """提取 context_token（回复必须回带，否则不关联到对话窗口）。"""
    for k in ("context_token", "ctx_token", "conversation_id", "conv_id",
             "msg_id", "context_id", "session_id"):
        v = m.get(k)
        if v:
            return str(v)
    return ""


def _log_chat(user_id, platform, from_user, context_token, role, content):
    """持久化 IM Bot 对话历史，便于平台内查阅。"""
    db = None
    try:
        db = SessionLocal()
        _execute_raw(db, text(
            "INSERT INTO im_bot_chat_log "
            "(user_id, platform, from_user, context_token, role, content, created_at) "
            "VALUES (:uid, :platform, :fu, :ctx, :role, :content, :created)"
        ), {
            "uid": user_id, "platform": platform, "fu": from_user,
            "ctx": context_token, "role": role, "content": content,
            "created": _beijing_now(),
        })
    except Exception:
        pass
    finally:
        if db:
            db.close()


# ============================================================
# 镜像到 AI 聊天（标准 conversations/messages）
# 个人微信对话作为一个独立会话窗（默认名 "WeXin Bot"）出现在 AI 聊天中，
# 从而复用 AI 聊天模块的全部功能（滚动翻阅、重命名、置顶、删除等）。
# ============================================================
WECHAT_CONV_TITLE = "WeXin Bot"


def _get_or_create_wechat_conv(db: Session, user_id: str) -> str:
    """按 user_id 找/建 source='wechat_bot' 的会话，返回会话 id。"""
    rows = _execute_raw(db, text(
        "SELECT id FROM conversations WHERE user_id=:uid AND source='wechat_bot' "
        "AND status<>'archived' ORDER BY updated_at DESC LIMIT 1"
    ), {"uid": user_id})
    if rows:
        return _row_to_dict(rows[0])["id"]
    cid = str(_uuid.uuid4())
    now = _beijing_now()
    _execute_raw(db, text(
        "INSERT INTO conversations "
        "(id, user_id, title, status, pinned, knowledge_graph_count, source, created_at, updated_at) "
        "VALUES (:id, :uid, :title, 'active', 0, 0, 'wechat_bot', :c, :u)"
    ), {"id": cid, "uid": user_id, "title": WECHAT_CONV_TITLE, "c": now, "u": now})
    return cid


def _append_ai_message(db: Session, conv_id: str, role: str, content: str, created=None):
    _execute_raw(db, text(
        "INSERT INTO messages (id, conversation_id, role, content, token_used, created_at) "
        "VALUES (:id, :cid, :role, :content, 0, :c)"
    ), {
        "id": str(_uuid.uuid4()), "cid": conv_id, "role": role,
        "content": content, "c": created or _beijing_now(),
    })


def _mirror_to_ai_chat(user_id: str, user_content: str, assistant_content: str):
    """把一轮微信问答写入用户的 WeXin Bot AI 聊天会话。"""
    if not user_id:
        return
    db = None
    try:
        db = SessionLocal()
        cid = _get_or_create_wechat_conv(db, user_id)
        now = _beijing_now()
        _append_ai_message(db, cid, "user", user_content, created=now)
        # assistant 比 user 晚 50ms，保证排序严格递增，避免同秒时 ORDER BY 乱序
        _append_ai_message(db, cid, "assistant", assistant_content,
                            created=now + timedelta(milliseconds=50))
        _execute_raw(db, text("UPDATE conversations SET updated_at=:u WHERE id=:id"),
                     {"u": _beijing_now(), "id": cid})
    except Exception:
        pass
    finally:
        if db:
            db.close()


# ============================================================
# 后台接收线程（每用户独立）
# ============================================================
def _mark_wechat_expired(account_id: int):
    """发送会话失效（ret=-14/-2）：标记账号需重扫，清除失效 token，并记录告警日志。"""
    db = None
    try:
        db = SessionLocal()
        _execute_raw(db, text(
            "UPDATE im_bot_wechat_account SET status='expired', bot_token=NULL, "
            "updated_at=:ts WHERE id=:aid"
        ), {"aid": account_id, "ts": _beijing_now()})
        # Session Guard：记录账号信息，供前台提示用户重扫
        row = _execute_raw(db, text("SELECT user_id, username FROM im_bot_wechat_account WHERE id=:aid"), {"aid": account_id})
        _uid = row[0][0] if row else "?"
        try:
            with open("/tmp/wechat_session_expired.log", "a", encoding="utf-8") as _f:
                _f.write(_beijing_now().isoformat() + " SESSION_EXPIRED account_id=%s user_id=%s\n" % (account_id, _uid))
        except Exception:
            pass
    except Exception:
        pass
    finally:
        if db:
            db.close()


def _wechat_receiver_loop(account_id: int):
    """长轮询个人微信消息 → 七虎AI 回复 → 发送。"""
    cursor = ""
    while True:
        db = SessionLocal()
        try:
            row = _execute_raw(
                db,
                text("SELECT * FROM im_bot_wechat_account WHERE id = :aid"),
                {"aid": account_id},
            )
            if not row:
                return
            d = _row_to_dict(row[0])
            if d.get("status") != "connected" or not d.get("bot_token"):
                return
            bot_token = d["bot_token"]
            baseurl = d.get("baseurl") or ILINK_BASE
            msgs, cursor = _wechat_get_updates(baseurl, bot_token, cursor)
            owner_uid = d.get("user_id")
            for m in msgs:
                if m.get("message_type") == 2:
                    continue  # 仅跳过 bot 自己发出的回声，其余（含后续追问）均尝试处理
                content = _wechat_extract_text(m)
                if not content:
                    # 入站媒体（图片/语音/文件/视频）：下载解密保存，供 LLM 感知
                    content = _extract_and_save_inbound_media(m)
                    if not content:
                        continue
                sender = _wechat_sender_id(m)
                ctx = _wechat_context_token(m)
                # 诊断：记录原始入站消息，定位字段名 / 第二轮不回复
                try:
                    with open("/tmp/wechat_inbound.log", "a", encoding="utf-8") as _f:
                        _f.write(_beijing_now().isoformat() + " sender=" + repr(sender)
                                 + " ctx=" + repr(ctx) + " raw=" + json.dumps(m, ensure_ascii=False) + "\n")
                except Exception:
                    pass
                # 发送"正在输入"状态（尽力而为，失败静默）
                try:
                    _bot_id = m.get("to_user_id") or d.get("ilink_bot_id") or ""
                    _ticket = _wechat_get_typing_ticket(baseurl, bot_token, _bot_id, ctx)
                    if _bot_id and _ticket:
                        _wechat_send_typing(baseurl, bot_token, _bot_id, _ticket, 1)
                except Exception:
                    pass
                # 先生成回复（此时历史尚未包含本条，避免重复）
                import logging as _lrx, inspect as _insp
                _lrx.warning(f'[receiver] calling _qihua_reply({repr(content)}, {repr(owner_uid)})')
                # 验证使用的 _call_real_llm 版本
                from app.api.im_llm import _call_real_llm as _crl
                _src = _insp.getsource(_crl)
                _lrx.warning(f'[receiver] _call_real_llm source len={len(_src)}, has _try_models={"_try_models" in _src}')
                reply = _qihua_reply(content, owner_uid)
                _lrx.warning(f'[receiver] reply ({type(reply).__name__}): {repr(reply)[:200]}')
                # 媒体结构化返回：_call_real_llm 生成图片/视频时返回
                # {"__media__": True, "media_type": "image"/"video", "url": "..."}
                if isinstance(reply, dict) and reply.get("__media__"):
                    media_type = reply.get("media_type") or "image"
                    media_url = reply.get("url") or ""
                    ok, ret, _ = _wechat_send_media(baseurl, bot_token, sender, ctx, media_type, media_url)
                    # 对话历史里存可渲染的媒体标签（经平台中转，AI 聊天 WeXin Bot 窗与历史页均可内联显示）
                    relay_url = _platform_relay_url(media_url)
                    reply_for_log = (
                        f'<img src="{relay_url}" alt="生成图片"/>'
                        if media_type == "image"
                        else f'<video src="{relay_url}" controls></video>'
                    )
                else:
                    reply_text = reply if isinstance(reply, str) else str(reply)
                    ok, ret, _ = _wechat_send_message(baseurl, bot_token, sender, ctx, reply_text)
                    reply_for_log = reply_text
                if ok:
                    # 仅发送成功才写对话历史（避免“发了但没收到”的误导记录）
                    if owner_uid:
                        _log_chat(owner_uid, "personal_wechat", sender, ctx, "user", content)
                        _log_chat(owner_uid, "personal_wechat", sender, ctx, "assistant", reply_for_log)
                        # 同步镜像到 AI 聊天的 WeXin Bot 会话窗
                        _mirror_to_ai_chat(owner_uid, content, reply_for_log)
                else:
                    try:
                        with open("/tmp/wechat_send.log", "a", encoding="utf-8") as _f:
                            _f.write(_beijing_now().isoformat() + " SEND_FAIL ret=%s sender=%s\n"
                                     % (ret, repr(sender)))
                    except Exception:
                        pass
                    if ret == -14:
                        # -14=会话过期，需重扫
                        _mark_wechat_expired(d["id"])
                    elif ret == -2:
                        # -2=参数错误（如媒体消息格式不被 iLink 接受），并非 token 失效。
                        # 标记 expired 会导致连接假性断开，后续消息全部丢失，故仅记录。
                        pass
            time.sleep(1)
        except Exception:
            # 2026-07-31 修复：此前裸 except 静默吞掉所有异常，导致接收器出错时毫无日志、
            # 完全无法排查。改为记录异常堆栈到磁盘，便于定位。
            import traceback as _tb
            try:
                with open("/tmp/wechat_receiver_err.log", "a", encoding="utf-8") as _f:
                    _f.write(_beijing_now().isoformat() + " RECEIVER EXCEPTION:\n" + _tb.format_exc() + "\n")
            except Exception:
                pass
            time.sleep(5)
        finally:
            db.close()


def _start_wechat_receiver(account_id: int):
    if account_id in _wechat_receiver_threads and _wechat_receiver_threads[account_id].is_alive():
        return
    t = threading.Thread(target=_wechat_receiver_loop, args=(account_id,), daemon=True)
    t.start()
    _wechat_receiver_threads[account_id] = t


# ============================================================
# 前台用户接口（按 user_id 隔离）
# ============================================================
@router.get("/status")
async def wechat_status(user: User = Depends(get_current_user)):
    """当前登录用户的个人微信连接状态"""
    db = SessionLocal()
    try:
        row = _wechat_row_for_user(db, user.id)
        if not row:
            return {"success": True, "data": {"connected": False, "configured": False}}
        d = _row_to_dict(row)
        return {"success": True, "data": {
            "connected": d.get("status") == "connected",
            "status": d.get("status"),
            "configured": True,
            "baseurl": d.get("baseurl"),
            "ilink_bot_id": d.get("ilink_bot_id"),
            "username": d.get("username"),
            "connected_at": str(d.get("connected_at")) if d.get("connected_at") else None,
        }}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.post("/qrcode")
async def wechat_qrcode(user: User = Depends(get_current_user)):
    """获取个人微信扫码登录二维码（iLink 协议，免 AppID）"""
    try:
        resp = requests.get(
            ILINK_BASE + "/ilink/bot/get_bot_qrcode",
            params={"bot_type": 3},
            timeout=20,
        )
        if not resp.ok:
            return {"success": False, "error": f"获取二维码失败 HTTP {resp.status_code}"}
        j = resp.json() if resp.content else {}
        qr_url = j.get("qrcode_img_content") or ""
        qr_img = None
        try:
            import io as _io
            import qrcode as _qrcode
            _buf = _io.BytesIO()
            _q = _qrcode.QRCode(box_size=10, border=2)
            _q.add_data(qr_url)
            _q.make(fit=True)
            _img = _q.make_image(fill_color="black", back_color="white")
            _img.save(_buf, format="PNG")
            qr_img = "data:image/png;base64," + base64.b64encode(_buf.getvalue()).decode()
        except Exception:
            qr_img = None
        return {"success": True, "data": {
            "qrcode": j.get("qrcode"),
            "qrcode_img_content": qr_url,
            "qrcode_img": qr_img,
        }}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/qrcode/status")
async def wechat_qrcode_status(
    qrcode: str = Query(...),
    user: User = Depends(get_current_user),
):
    """轮询扫码状态；confirmed 时保存该用户的 bot_token 并启动接收线程"""
    try:
        resp = requests.get(
            ILINK_BASE + "/ilink/bot/get_qrcode_status",
            params={"qrcode": qrcode},
            timeout=40,
        )
        if not resp.ok:
            return {"success": False, "error": f"查询状态失败 HTTP {resp.status_code}"}
        j = resp.json() if resp.content else {}
        data = j.get("data", j) if isinstance(j, dict) else j
        status = data.get("status")
        if status == "confirmed":
            # 07-30 diagnostic: log full iLink confirm response
            import json as _json
            try:
                with open("/tmp/wechat_confirm.log", "a", encoding="utf-8") as _f:
                    _f.write(_beijing_now().isoformat() + " CONFIRM_RAW=" + _json.dumps(j, ensure_ascii=False)[:2000] + "\n")
            except Exception:
                pass
            creds = data.get("credentials", {}) or {}
            bot_token = data.get("bot_token") or creds.get("bot_token")
            baseurl = data.get("baseurl") or creds.get("baseurl") or ILINK_BASE
            ilink_bot_id = data.get("ilink_bot_id") or creds.get("ilink_bot_id")
            db = SessionLocal()
            try:
                row = _wechat_row_for_user(db, user.id)
                if not row:
                    _execute_raw(db, text("""INSERT INTO im_bot_wechat_account
                        (user_id, username, bot_token, ilink_bot_id, baseurl, status,
                         connected_at, created_at, updated_at)
                        VALUES (:user_id, :username, :bot_token, :ilink_bot_id, :baseurl,
                                'connected', :connected_at, :created_at, :updated_at)"""),
                        {
                            "user_id": user.id, "username": user.username,
                            "bot_token": bot_token, "ilink_bot_id": ilink_bot_id,
                            "baseurl": baseurl,
                            # 统一按北京时间存储，避免容器 UTC 导致显示偏差
                            "connected_at": _beijing_now(),
                            "created_at": _beijing_now(), "updated_at": _beijing_now(),
                        })
                else:
                    _execute_raw(db, text("""UPDATE im_bot_wechat_account SET
                        user_id=:user_id, username=:username, bot_token=:bot_token,
                        ilink_bot_id=:ilink_bot_id, baseurl=:baseurl,
                        status='connected', connected_at=:connected_at, updated_at=:updated_at
                        WHERE id=:id"""),
                        {
                            "user_id": user.id, "username": user.username,
                            "bot_token": bot_token, "ilink_bot_id": ilink_bot_id,
                            "baseurl": baseurl,
                        "connected_at": _beijing_now(),
                        "updated_at": _beijing_now(), "id": _row_to_dict(row)["id"],
                        })
                row = _wechat_row_for_user(db, user.id)
                saved = _row_to_dict(row) if row else {}
                import json as _json2
                try:
                    with open("/tmp/wechat_confirm.log", "a", encoding="utf-8") as _f:
                        _f.write(_beijing_now().isoformat() + " SAVED bot_token=" + repr(saved.get("bot_token", "NULL")[:20]) 
                                 + " ilink_bot_id=" + repr(saved.get("ilink_bot_id")) + "\n")
                except Exception:
                    pass
                aid = saved.get("id", 1)
                _start_wechat_receiver(aid)
            finally:
                db.close()
            return {"success": True, "data": {"status": "confirmed", "connected": True}}
        return {"success": True, "data": {"status": status, "connected": False}}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/disconnect")
async def wechat_disconnect(user: User = Depends(get_current_user)):
    """断开当前用户的个人微信连接（清除 bot_token）"""
    db = SessionLocal()
    try:
        row = _wechat_row_for_user(db, user.id)
        if row:
            _execute_raw(db, text(
                "UPDATE im_bot_wechat_account SET bot_token=NULL, status='disconnected', "
                "updated_at=:updated_at WHERE id=:id"
            ), {"updated_at": _beijing_now(), "id": _row_to_dict(row)["id"]})
        return {"success": True, "message": "已断开个人微信连接"}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


# ============================================================
# 启动恢复：为所有已连接用户账号拉起接收线程
# ============================================================
@router.get("/history")
async def wechat_history(
    user: User = Depends(get_current_user),
    limit: int = Query(200),
):
    """查询当前用户通过个人微信与七虎AI 的对话历史"""
    db = SessionLocal()
    try:
        rows = _execute_raw(
            db,
            text("SELECT id, role, content, platform, from_user, created_at "
                 "FROM im_bot_chat_log WHERE user_id=:uid ORDER BY id DESC LIMIT :lim"),
            {"uid": user.id, "lim": min(int(limit), 500)},
        )
        items = [_row_to_dict(r) for r in rows]
        items.reverse()
        return {"success": True, "data": {"messages": items, "total": len(items)}}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


def start_all_wechat_receivers():
    """在应用启动时调用，恢复此前已连接用户的个人微信接收线程。"""
    db = SessionLocal()
    try:
        rows = _execute_raw(
            db,
            text("SELECT id FROM im_bot_wechat_account WHERE status='connected' AND user_id IS NOT NULL"),
        )
        for r in rows:
            _start_wechat_receiver(r._mapping["id"])
        if rows:
            import logging
            logging.getLogger("aiflow").info(f"[IM个人微信] 已恢复 {len(rows)} 个用户微信接收线程")
    except Exception as e:
        import logging
        logging.getLogger("aiflow").warning(f"[IM个人微信] 启动恢复失败(不影响服务): {e}")
    finally:
        db.close()