monitor_web.py

"""
微信实时消息监听器 - Web UI (SSE推送 + mtime检测)

http://localhost:5678
- 30ms轮询WAL/DB文件的mtime变化（WAL是预分配固定大小，不能用size检测）
- 检测到变化后：全量解密DB + 全量WAL patch
- SSE 服务器推送
"""
import base64, hashlib, struct, os, sys, json, time, sqlite3, io, threading, queue, traceback, re
import hmac as hmac_mod
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime
from http.server import HTTPServer, BaseHTTPRequestHandler
from socketserver import ThreadingMixIn
from Crypto.Cipher import AES
import urllib.parse
import glob as glob_mod
import zstandard as zstd
from decode_image import extract_md5_from_packed_info, decrypt_dat_file, is_v2_format

_zstd_dctx = zstd.ZstdDecompressor()

PAGE_SZ = 4096
KEY_SZ = 32
SALT_SZ = 16
RESERVE_SZ = 80
SQLITE_HDR = b'SQLite format 3\x00'
WAL_HEADER_SZ = 32
WAL_FRAME_HEADER_SZ = 24

from config import load_config
from agent_runtime import AgentRuntime
from deepseek_client import DeepSeekClient
from desktop_approval import DesktopApproval
from style_profile import StyleProfile
from wechat_sender import WeChatSender

_cfg = load_config()
DB_DIR = _cfg["db_dir"]
KEYS_FILE = _cfg["keys_file"]
CONTACT_CACHE = os.path.join(_cfg["decrypted_dir"], "contact", "contact.db")
DECRYPTED_SESSION = os.path.join(_cfg["decrypted_dir"], "session", "session.db")
DECODED_IMAGE_DIR = _cfg.get("decoded_image_dir", os.path.join(os.path.dirname(os.path.abspath(__file__)), "decoded_images"))
MONITOR_CACHE_DIR = os.path.join(_cfg["decrypted_dir"], "_monitor_cache")
WECHAT_BASE_DIR = _cfg.get("wechat_base_dir", "")
IMAGE_AES_KEY = _cfg.get("image_aes_key")  # V2 格式 AES key (从微信内存提取)
IMAGE_XOR_KEY = _cfg.get("image_xor_key", 0x88)  # XOR key

POLL_MS = 30  # 高频轮询WAL/DB的mtime，30ms一次
PORT = 5678

sse_clients = []
sse_lock = threading.Lock()
messages_log = []
messages_lock = threading.Lock()
MAX_LOG = 500
_img_executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix='img')
web_db_cache = None
web_contact_names = {}
web_username_db_map = {}
agent_runtime = None
web_keys = {}


class MonitorDBCache:
    """轻量 DB 缓存，mtime 检测变化时重新解密"""

    def __init__(self, keys, tmp_dir):
        self.keys = keys
        self.tmp_dir = tmp_dir
        os.makedirs(tmp_dir, exist_ok=True)
        self._state = {}  # rel_key → (db_mtime, wal_mtime)
        self._lock = threading.Lock()

    def get(self, rel_key):
        """返回解密后的临时文件路径，mtime 变化时自动重新解密"""
        with self._lock:
            if rel_key not in self.keys:
                return None

            enc_key = bytes.fromhex(self.keys[rel_key]["enc_key"])
            rel_path = rel_key.replace('\\', os.sep)
            db_path = os.path.join(DB_DIR, rel_path)
            wal_path = db_path + "-wal"

            if not os.path.exists(db_path):
                return None

            try:
                db_mtime = os.path.getmtime(db_path)
                wal_mtime = os.path.getmtime(wal_path) if os.path.exists(wal_path) else 0
            except OSError:
                return None

            out_name = rel_key.replace('\\', '_')
            out_path = os.path.join(self.tmp_dir, out_name)

            prev = self._state.get(rel_key)

            if prev is None or db_mtime != prev[0]:
                t0 = time.perf_counter()
                full_decrypt(db_path, out_path, enc_key)
                if os.path.exists(wal_path):
                    decrypt_wal_full(wal_path, out_path, enc_key)
                ms = (time.perf_counter() - t0) * 1000
                print(f"  [cache] {rel_key} 全量解密 {ms:.0f}ms", flush=True)
                self._state[rel_key] = (db_mtime, wal_mtime)
            elif wal_mtime != prev[1]:
                t0 = time.perf_counter()
                decrypt_wal_full(wal_path, out_path, enc_key)
                ms = (time.perf_counter() - t0) * 1000
                print(f"  [cache] {rel_key} WAL patch {ms:.0f}ms", flush=True)
                self._state[rel_key] = (db_mtime, wal_mtime)

            return out_path


def _message_db_keys(keys):
    return sorted([
        k for k in keys
        if k.startswith("message\\message_") and k.endswith(".db")
        and "fts" not in k and "resource" not in k
    ])


def build_username_db_map(db_cache, keys):
    """从已解密的 Name2Id 表构建 username → [db_keys] 映射

    同一个 username 可能存在于多个 message_N.db 中,
    按 DB 文件修改时间倒序排列（最新的排前面）。
    """
    db_keys = _message_db_keys(keys)
    db_mtimes = {}
    for rel_key in db_keys:
        db_path = os.path.join(DB_DIR, rel_key.replace('\\', os.sep))
        try:
            db_mtimes[rel_key] = os.path.getmtime(db_path)
        except OSError:
            db_mtimes[rel_key] = 0

    mapping = {}  # username → [db_keys], 最新的在前
    for rel_key in db_keys:
        rel_path = rel_key.replace('\\', os.sep)
        cached_path = os.path.join(_cfg["decrypted_dir"], rel_path)
        if not os.path.exists(cached_path):
            cached_path = db_cache.get(rel_key) if db_cache else None
        if not cached_path:
            continue
        try:
            conn = sqlite3.connect(f"file:{cached_path}?mode=ro", uri=True)
            for row in conn.execute("SELECT user_name FROM Name2Id").fetchall():
                if row[0] not in mapping:
                    mapping[row[0]] = []
                if rel_key not in mapping[row[0]]:
                    mapping[row[0]].append(rel_key)
            conn.close()
        except Exception as e:
            print(f"  [WARN] Name2Id {rel_key}: {e}", flush=True)

    # 对每个 username 的 db_keys 按 mtime 倒序（最新的优先）
    for username in mapping:
        mapping[username].sort(key=lambda k: db_mtimes.get(k, 0), reverse=True)

    return mapping


def decrypt_page(enc_key, page_data, pgno):
    """解密单个加密页面"""
    iv = page_data[PAGE_SZ - RESERVE_SZ: PAGE_SZ - RESERVE_SZ + 16]
    if pgno == 1:
        encrypted = page_data[SALT_SZ: PAGE_SZ - RESERVE_SZ]
        cipher = AES.new(enc_key, AES.MODE_CBC, iv)
        decrypted = cipher.decrypt(encrypted)
        return bytearray(SQLITE_HDR + decrypted + b'\x00' * RESERVE_SZ)
    else:
        encrypted = page_data[:PAGE_SZ - RESERVE_SZ]
        cipher = AES.new(enc_key, AES.MODE_CBC, iv)
        decrypted = cipher.decrypt(encrypted)
        return decrypted + b'\x00' * RESERVE_SZ


def full_decrypt(db_path, out_path, enc_key):
    """首次全量解密"""
    t0 = time.perf_counter()
    file_size = os.path.getsize(db_path)
    total_pages = file_size // PAGE_SZ

    with open(db_path, 'rb') as fin, open(out_path, 'wb') as fout:
        for pgno in range(1, total_pages + 1):
            page = fin.read(PAGE_SZ)
            if len(page) < PAGE_SZ:
                if len(page) > 0:
                    page = page + b'\x00' * (PAGE_SZ - len(page))
                else:
                    break
            fout.write(decrypt_page(enc_key, page, pgno))

    ms = (time.perf_counter() - t0) * 1000
    return total_pages, ms


def decrypt_wal_full(wal_path, out_path, enc_key):
    """解密WAL当前有效frame，patch到已解密的DB副本

    WAL是预分配固定大小(4MB)，包含当前有效frame和上一轮遗留的旧frame。
    通过WAL header中的salt值区分：只有frame header的salt匹配WAL header的才是有效frame。

    返回: (patched_pages, elapsed_ms)
    """
    t0 = time.perf_counter()

    if not os.path.exists(wal_path):
        return 0, 0

    wal_size = os.path.getsize(wal_path)
    if wal_size <= WAL_HEADER_SZ:
        return 0, 0

    frame_size = WAL_FRAME_HEADER_SZ + PAGE_SZ  # 24 + 4096 = 4120
    patched = 0

    with open(wal_path, 'rb') as wf, open(out_path, 'r+b') as df:
        # 读WAL header，获取当前salt值
        wal_hdr = wf.read(WAL_HEADER_SZ)
        wal_salt1 = struct.unpack('>I', wal_hdr[16:20])[0]
        wal_salt2 = struct.unpack('>I', wal_hdr[20:24])[0]

        while wf.tell() + frame_size <= wal_size:
            fh = wf.read(WAL_FRAME_HEADER_SZ)
            if len(fh) < WAL_FRAME_HEADER_SZ:
                break
            pgno = struct.unpack('>I', fh[0:4])[0]
            frame_salt1 = struct.unpack('>I', fh[8:12])[0]
            frame_salt2 = struct.unpack('>I', fh[12:16])[0]

            ep = wf.read(PAGE_SZ)
            if len(ep) < PAGE_SZ:
                break

            # 校验: pgno有效 且 salt匹配当前WAL周期
            if pgno == 0 or pgno > 1000000:
                continue
            if frame_salt1 != wal_salt1 or frame_salt2 != wal_salt2:
                continue  # 旧周期遗留的frame，跳过

            dec = decrypt_page(enc_key, ep, pgno)
            df.seek((pgno - 1) * PAGE_SZ)
            df.write(dec)
            patched += 1

    ms = (time.perf_counter() - t0) * 1000
    return patched, ms


def load_contact_names(db_cache=None):
    names = {}
    candidates = []
    if os.path.exists(CONTACT_CACHE):
        candidates.append(CONTACT_CACHE)
    if db_cache:
        cached_path = db_cache.get("contact\\contact.db")
        if cached_path and cached_path not in candidates:
            candidates.append(cached_path)

    for path in candidates:
        try:
            conn = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
            for r in conn.execute("SELECT username, nick_name, remark FROM contact").fetchall():
                names[r[0]] = r[2] if r[2] else r[1] if r[1] else r[0]
            conn.close()
            if names:
                break
        except Exception:
            names = {}

    return names


def decode_message_content(content, content_type):
    if content_type == 4 and isinstance(content, bytes):
        try:
            return _zstd_dctx.decompress(content).decode('utf-8', errors='replace')
        except Exception:
            return None

    if isinstance(content, bytes):
        try:
            return content.decode('utf-8', errors='replace')
        except Exception:
            return None

    return content


def _extract_attr_value(text, attr_name):
    if not isinstance(text, str) or not text:
        return ""
    match = re.search(rf'{re.escape(attr_name)}\s*=\s*"([^"]*)"', text)
    if not match:
        return ""
    return match.group(1).strip()


def _decode_emoji_desc(desc):
    desc = (desc or "").strip()
    if not desc:
        return ""

    raw = b""
    try:
        padded = desc + "=" * (-len(desc) % 4)
        raw = base64.b64decode(padded, validate=False)
    except Exception:
        return desc

    decoded = raw.decode("utf-8", errors="ignore")
    parts = re.findall(r"[\u4e00-\u9fffA-Za-z0-9_]{1,24}", decoded)
    parts = [part for part in parts if part.lower() not in {"default", "emoji"}]
    if parts:
        return parts[-1]

    cleaned = re.sub(r"[\x00-\x1f]+", " ", decoded).strip()
    return cleaned


def _parse_emoji_text(content):
    if not isinstance(content, str):
        return "[表情]"

    attached_text = _extract_attr_value(content, "attachedtext")
    if attached_text:
        return f"[表情:{attached_text}]"

    desc = _decode_emoji_desc(_extract_attr_value(content, "desc"))
    if desc:
        return f"[表情:{desc}]"

    return "[表情]"


def normalize_agent_message_content(local_type, content):
    if content is None:
        return ""

    text = str(content).strip()
    if not text:
        return ""

    if local_type == 47:
        return _parse_emoji_text(text)
    if local_type == 1:
        return text
    return text


def get_chat_targets():
    chats = []
    for username, db_keys in web_username_db_map.items():
        display = web_contact_names.get(username, username)
        chats.append({
            'username': username,
            'display': display,
            'is_group': '@chatroom' in username,
            'db_count': len(db_keys),
        })

    chats.sort(key=lambda item: (item['display'].casefold(), item['username'].casefold()))
    return chats


def load_chat_history(username, limit=0):
    if not web_db_cache:
        return None, "数据库缓存未初始化"
    if username not in web_username_db_map:
        return None, f"找不到 {username} 的聊天记录"

    table_name = f"Msg_{hashlib.md5(username.encode()).hexdigest()}"
    display = web_contact_names.get(username, username)
    is_group = '@chatroom' in username
    messages = []

    for rel_key in web_username_db_map.get(username, []):
        db_path = web_db_cache.get(rel_key)
        if not db_path:
            continue

        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        try:
            rows = conn.execute(f"""
                SELECT local_id, local_type, create_time, message_content,
                       WCDB_CT_message_content
                FROM [{table_name}]
                ORDER BY create_time ASC
            """).fetchall()
        except Exception:
            rows = []
        finally:
            conn.close()

        for local_id, local_type, create_time, content, content_type in rows:
            content = decode_message_content(content, content_type)
            if content is None:
                text = '(无法解码)'
                sender_name = ''
            else:
                sender_name = ''
                text = content or ''
                if is_group and isinstance(text, str) and ':\n' in text:
                    sender_id, text = text.split(':\n', 1)
                    sender_name = web_contact_names.get(sender_id, sender_id)

            if local_type == 3:
                text = '[图片]'
            elif local_type == 47:
                text = normalize_agent_message_content(local_type, text)
            elif local_type != 1:
                msg_type = format_msg_type(local_type)
                text = f"[{msg_type}] {text}" if text else f"[{msg_type}]"

            messages.append({
                'local_id': local_id,
                'timestamp': create_time,
                'time': datetime.fromtimestamp(create_time).strftime('%Y-%m-%d %H:%M:%S'),
                'type': format_msg_type(local_type),
                'type_icon': msg_type_icon(local_type),
                'sender': sender_name,
                'content': text or '(空内容)',
                'source_db': rel_key,
            })

    messages.sort(key=lambda item: (item['timestamp'], item['local_id']))
    if limit and limit > 0:
        messages = messages[-limit:]

    return {
        'username': username,
        'display': display,
        'is_group': is_group,
        'source_count': len(web_username_db_map.get(username, [])),
        'count': len(messages),
        'messages': messages,
    }, None


def get_display_name(username):
    return web_contact_names.get(username, username)


def load_text_messages(username, limit=0):
    if not web_db_cache or username not in web_username_db_map:
        return []

    table_name = f"Msg_{hashlib.md5(username.encode()).hexdigest()}"
    messages = []

    for rel_key in web_username_db_map.get(username, []):
        db_path = web_db_cache.get(rel_key)
        if not db_path:
            continue

        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        try:
            rows = conn.execute(f"""
                SELECT local_id, local_type, create_time, real_sender_id,
                       message_content, WCDB_CT_message_content
                FROM [{table_name}]
                WHERE local_type IN (1, 47)
                ORDER BY create_time ASC
            """).fetchall()
        except Exception:
            rows = []
        finally:
            conn.close()

        for local_id, local_type, create_time, sender_id, content, content_type in rows:
            decoded = decode_message_content(content, content_type)
            if decoded is None:
                continue
            text = normalize_agent_message_content(local_type, decoded)
            if not text:
                continue
            messages.append({
                'local_id': local_id,
                'local_type': local_type,
                'timestamp': create_time,
                'sender_id': sender_id,
                'content': text,
                'source_db': rel_key,
            })

    messages.sort(key=lambda item: (item['timestamp'], item['local_id']))
    if limit and limit > 0:
        messages = messages[-limit:]
    return messages


def load_exact_message(username, local_id):
    if not web_db_cache or username not in web_username_db_map:
        return None

    table_name = f"Msg_{hashlib.md5(username.encode()).hexdigest()}"
    for rel_key in web_username_db_map.get(username, []):
        db_path = web_db_cache.get(rel_key)
        if not db_path:
            continue

        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        try:
            row = conn.execute(f"""
                SELECT local_id, local_type, create_time, real_sender_id,
                       message_content, WCDB_CT_message_content
                FROM [{table_name}]
                WHERE local_id = ?
                LIMIT 1
            """, (local_id,)).fetchone()
        except Exception:
            row = None
        finally:
            conn.close()

        if row:
            decoded = decode_message_content(row[4], row[5])
            return {
                'local_id': row[0],
                'local_type': row[1],
                'timestamp': row[2],
                'sender_id': row[3],
                'content': normalize_agent_message_content(row[1], decoded),
                'source_db': rel_key,
            }

    return None


def snapshot_latest_private_text_ids():
    baseline = {}
    for username in web_username_db_map:
        if '@chatroom' in username:
            continue
        messages = load_text_messages(username, limit=1)
        if messages:
            baseline[username] = messages[-1]['local_id']
    return baseline


def verify_sent_text_message(username, text, send_started_at):
    if not agent_runtime:
        return False

    messages = load_text_messages(username, limit=3)
    self_sender_id = agent_runtime.self_identity.get('self_sender_id')
    for item in reversed(messages):
        if item['sender_id'] != self_sender_id:
            continue
        if item['content'] != text:
            continue
        if item['timestamp'] >= send_started_at - 2:
            return True
    return False


def resolve_self_identity():
    raw_base = os.path.basename((WECHAT_BASE_DIR or os.path.dirname(DB_DIR)).rstrip('\\/'))
    stripped = raw_base
    match = re.match(r"^(.+?)_[A-Za-z0-9]+$", raw_base)
    if match:
        stripped = match.group(1)

    override = (_cfg.get('agent') or {}).get('self_username_override', '').strip()
    candidates = []
    if stripped:
        candidates.append(stripped)
    if raw_base and raw_base not in candidates:
        candidates.append(raw_base)
    if override and override not in candidates:
        candidates.append(override)

    db_keys = _message_db_keys(web_keys)
    for rel_key in db_keys:
        db_path = web_db_cache.get(rel_key) if web_db_cache else None
        if not db_path:
            continue

        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        try:
            for candidate in candidates:
                row = conn.execute(
                    "SELECT rowid, user_name FROM Name2Id WHERE user_name = ?",
                    (candidate,)
                ).fetchone()
                if row:
                    conn.close()
                    return {
                        'resolved': True,
                        'self_sender_id': row[0],
                        'self_username': row[1],
                    }

            if stripped:
                rows = conn.execute(
                    "SELECT rowid, user_name FROM Name2Id WHERE user_name LIKE ?",
                    (f"{stripped}%",)
                ).fetchall()
                if len(rows) == 1:
                    conn.close()
                    return {
                        'resolved': True,
                        'self_sender_id': rows[0][0],
                        'self_username': rows[0][1],
                    }
        except Exception:
            pass
        finally:
            conn.close()

    return {
        'resolved': False,
        'self_sender_id': None,
        'self_username': '',
    }


def format_msg_type(t):
    return {
        1: '文本', 3: '图片', 34: '语音', 42: '名片',
        43: '视频', 47: '表情', 48: '位置', 49: '链接/文件',
        50: '通话', 10000: '系统', 10002: '撤回',
    }.get(t, f'type={t}')


def msg_type_icon(t):
    return {
        1: '💬', 3: '🖼️', 34: '🎤', 42: '👤',
        43: '🎬', 47: '😀', 48: '📍', 49: '🔗',
        50: '📞', 10000: '⚙️', 10002: '↩️',
    }.get(t, '📨')


def broadcast_sse(msg_data):
    event_type = msg_data.get('event', '')
    data_line = f"data: {json.dumps(msg_data, ensure_ascii=False)}\n"
    if event_type:
        payload = f"event: {event_type}\n{data_line}\n"
    else:
        payload = f"{data_line}\n"
    with sse_lock:
        dead = []
        for q in sse_clients:
            try:
                q.put_nowait(payload)
            except:
                dead.append(q)
        for q in dead:
            sse_clients.remove(q)


# ============ 监听器 ============

class SessionMonitor:
    def __init__(self, enc_key, session_db, contact_names, db_cache=None, username_db_map=None):
        self.enc_key = enc_key
        self.session_db = session_db
        self.wal_path = session_db + "-wal"
        self.contact_names = contact_names
        self.db_cache = db_cache
        self.username_db_map = username_db_map or {}
        self.prev_state = {}
        self.decrypt_ms = 0
        self.patched_pages = 0

    def resolve_image(self, username, timestamp):
        """解密图片: username+timestamp → 解密后的图片文件名，失败返回 None"""
        if not self.db_cache or not self.username_db_map:
            return None

        # 1. 找到 username 对应的所有 message_N.db（按 mtime 倒序）
        db_keys = self.username_db_map.get(username)
        if not db_keys:
            return None

        # 2. 遍历候选 DB，找到包含该 timestamp 消息的那个
        table_name = f"Msg_{hashlib.md5(username.encode()).hexdigest()}"
        local_id = None
        for db_key in db_keys:
            msg_db_path = self.db_cache.get(db_key)
            if not msg_db_path:
                continue
            try:
                conn = sqlite3.connect(f"file:{msg_db_path}?mode=ro", uri=True)
                # 精确匹配 timestamp
                row = conn.execute(f"""
                    SELECT local_id FROM [{table_name}]
                    WHERE local_type = 3 AND create_time = ?
                """, (timestamp,)).fetchone()
                if not row:
                    # 模糊匹配（±3秒内最近的图片消息）
                    row = conn.execute(f"""
                        SELECT local_id FROM [{table_name}]
                        WHERE local_type = 3 AND ABS(create_time - ?) <= 3
                        ORDER BY ABS(create_time - ?) LIMIT 1
                    """, (timestamp, timestamp)).fetchone()
                conn.close()
                if row:
                    local_id = row[0]
                    break
            except Exception as e:
                print(f"  [img] 查询 {db_key}/{table_name} 失败: {e}", flush=True)

        if not local_id:
            print(f"  [img] 未找到 local_id: {username} t={timestamp}", flush=True)
            return None

        # 4. 查 message_resource.db 获取 MD5
        #    local_id 不全局唯一，需要同时匹配 create_time
        res_path = self.db_cache.get("message\\message_resource.db")
        if not res_path:
            return None

        file_md5 = None
        try:
            conn = sqlite3.connect(f"file:{res_path}?mode=ro", uri=True)
            row = conn.execute(
                "SELECT packed_info FROM MessageResourceInfo "
                "WHERE message_local_id = ? AND message_create_time = ? AND message_local_type = 3",
                (local_id, timestamp)
            ).fetchone()
            if not row:
                # 降级: 只用 create_time + type
                row = conn.execute(
                    "SELECT packed_info FROM MessageResourceInfo "
                    "WHERE message_create_time = ? AND message_local_type = 3",
                    (timestamp,)
                ).fetchone()
            conn.close()
            if row and row[0]:
                file_md5 = extract_md5_from_packed_info(row[0])
        except Exception as e:
            print(f"  [img] 查询 message_resource 失败: {e}", flush=True)
            return None

        if not file_md5:
            print(f"  [img] 未找到 MD5: local_id={local_id} t={timestamp}", flush=True)
            return None

        # 5. 查找 .dat 文件
        attach_dir = os.path.join(WECHAT_BASE_DIR, "msg", "attach")
        username_hash = hashlib.md5(username.encode()).hexdigest()
        search_base = os.path.join(attach_dir, username_hash)

        if not os.path.isdir(search_base):
            print(f"  [img] attach 目录不存在: {search_base}", flush=True)
            return None

        pattern = os.path.join(search_base, "*", "Img", f"{file_md5}*.dat")
        dat_files = sorted(glob_mod.glob(pattern))
        if not dat_files:
            print(f"  [img] 未找到 .dat: MD5={file_md5}", flush=True)
            return None

        # 优先原图，然后高清 _h，最后缩略图 _t
        selected = dat_files[0]
        for f in dat_files:
            fname = os.path.basename(f)
            if not fname.startswith(file_md5 + '_'):
                selected = f
                break
        for f in dat_files:
            if f.endswith('_h.dat'):
                selected = f
                break

        # 6. 解密图片
        os.makedirs(DECODED_IMAGE_DIR, exist_ok=True)
        out_base = os.path.join(DECODED_IMAGE_DIR, file_md5)

        # 已解密则跳过
        for ext in ('jpg', 'png', 'gif', 'webp', 'bmp', 'tif'):
            candidate = f"{out_base}.{ext}"
            if os.path.exists(candidate):
                return os.path.basename(candidate)

        # V2 新格式需要 AES key
        if is_v2_format(selected) and not IMAGE_AES_KEY:
            print(f"  [img] V2 格式缺少 AES key: {os.path.basename(selected)}", flush=True)
            print(f"  [img] 请运行 find_image_key.py 提取密钥", flush=True)
            return '__v2_unsupported__'

        result_path, fmt = decrypt_dat_file(selected, f"{out_base}.tmp", IMAGE_AES_KEY, IMAGE_XOR_KEY)
        if not result_path:
            print(f"  [img] 解密失败: {selected}", flush=True)
            return None

        final = f"{out_base}.{fmt}"
        if os.path.exists(final):
            os.unlink(final)
        os.rename(result_path, final)
        size_kb = os.path.getsize(final) / 1024
        print(f"  [img] 解密成功: {os.path.basename(final)} ({size_kb:.0f}KB)", flush=True)
        return os.path.basename(final)

    def _async_resolve_image(self, username, timestamp, msg_data):
        """后台线程: 解密图片并通过 SSE 推送更新"""
        for attempt in range(3):
            try:
                img_name = self.resolve_image(username, timestamp)
                if img_name == '__v2_unsupported__':
                    # V2 新加密格式，显示占位提示
                    msg_data['content'] = '[图片 - 新加密格式暂不支持预览]'
                    broadcast_sse({
                        'event': 'image_update',
                        'timestamp': timestamp,
                        'username': username,
                        'v2_unsupported': True,
                    })
                    return
                elif img_name:
                    image_url = f'/img/{img_name}'
                    msg_data['image_url'] = image_url
                    broadcast_sse({
                        'event': 'image_update',
                        'timestamp': timestamp,
                        'username': username,
                        'image_url': image_url,
                    })
                    print(f"  [img] 异步解密成功: {img_name}", flush=True)
                    return
                elif attempt < 2:
                    time.sleep(1.5)
            except Exception as e:
                print(f"  [img] 异步解密失败(attempt={attempt}): {e}", flush=True)
                if attempt < 2:
                    time.sleep(1.5)

    def query_state(self):
        """查询已解密副本的session状态"""
        conn = sqlite3.connect(f"file:{DECRYPTED_SESSION}?mode=ro", uri=True)
        state = {}
        for r in conn.execute("""
            SELECT username, unread_count, summary, last_timestamp,
                   last_msg_type, last_msg_sender, last_sender_display_name,
                   last_msg_locald_id
            FROM SessionTable WHERE last_timestamp > 0
        """).fetchall():
            state[r[0]] = {
                'unread': r[1], 'summary': r[2] or '', 'timestamp': r[3],
                'msg_type': r[4], 'sender': r[5] or '', 'sender_name': r[6] or '',
                'last_msg_local_id': r[7] or 0,
            }
        conn.close()
        return state

    def do_full_refresh(self):
        """全量解密DB + 全量WAL patch"""
        # 先解密主DB
        pages, ms = full_decrypt(self.session_db, DECRYPTED_SESSION, self.enc_key)
        total_ms = ms
        wal_patched = 0

        # 再patch所有WAL frames
        if os.path.exists(self.wal_path):
            wal_patched, ms2 = decrypt_wal_full(self.wal_path, DECRYPTED_SESSION, self.enc_key)
            total_ms += ms2

        self.decrypt_ms = total_ms
        self.patched_pages = pages + wal_patched
        return self.patched_pages

    def check_updates(self):
        global messages_log
        try:
            t0 = time.perf_counter()
            self.do_full_refresh()
            t1 = time.perf_counter()
            curr_state = self.query_state()
            t2 = time.perf_counter()
            print(f"  [perf] decrypt={self.patched_pages}页/{(t1-t0)*1000:.1f}ms, query={(t2-t1)*1000:.1f}ms", flush=True)
        except Exception as e:
            print(f"  [ERROR] check_updates: {e}", flush=True)
            return

        # 收集所有新消息，按时间排序后再推送
        new_msgs = []
        for username, curr in curr_state.items():
            prev = self.prev_state.get(username)
            if prev is None or curr['timestamp'] > prev['timestamp']:
                display = self.contact_names.get(username, username)
                is_group = '@chatroom' in username
                sender = ''
                if is_group:
                    sender = self.contact_names.get(curr['sender'], curr['sender_name'] or curr['sender'])

                summary = curr['summary']
                if isinstance(summary, bytes):
                    try:
                        summary = _zstd_dctx.decompress(summary).decode('utf-8', errors='replace')
                    except Exception:
                        summary = '(压缩内容)'
                if summary and ':\n' in summary:
                    summary = summary.split(':\n', 1)[1]

                msg_data = {
                    'time': datetime.fromtimestamp(curr['timestamp']).strftime('%H:%M:%S'),
                    'timestamp': curr['timestamp'],
                    'chat': display,
                    'username': username,
                    'is_group': is_group,
                    'sender': sender,
                    'type': format_msg_type(curr['msg_type']),
                    'type_icon': msg_type_icon(curr['msg_type']),
                    'content': summary,
                    'unread': curr['unread'],
                    'decrypt_ms': round(self.decrypt_ms, 1),
                    'pages': self.patched_pages,
                }

                if agent_runtime:
                    try:
                        agent_runtime.on_new_message({
                            'username': username,
                            'display': display,
                            'timestamp': curr['timestamp'],
                            'last_msg_local_id': curr.get('last_msg_local_id', 0),
                            'msg_type': curr['msg_type'],
                        })
                    except Exception as e:
                        print(f"  [agent] 处理消息失败: {e}", flush=True)

                new_msgs.append(msg_data)

                # 图片消息: 后台异步解密（不阻塞轮询）
                if curr['msg_type'] == 3:
                    _img_executor.submit(
                        self._async_resolve_image,
                        username, curr['timestamp'], msg_data
                    )

        # 按时间排序
        new_msgs.sort(key=lambda m: m['timestamp'])

        for msg in new_msgs:
            with messages_lock:
                messages_log.append(msg)
                if len(messages_log) > MAX_LOG:
                    messages_log = messages_log[-MAX_LOG:]

            broadcast_sse(msg)

            try:
                now = time.time()
                msg_age = now - msg['timestamp']
                tag = f"{self.patched_pages}pg/{self.decrypt_ms:.0f}ms"
                sender = msg['sender']
                now_str = datetime.fromtimestamp(now).strftime('%H:%M:%S')
                if sender:
                    print(f"[{msg['time']} 延迟={msg_age:.1f}s] [{msg['chat']}] {sender}: {msg['content']}  ({tag})", flush=True)
                else:
                    print(f"[{msg['time']} 延迟={msg_age:.1f}s] [{msg['chat']}] {msg['content']}  ({tag})", flush=True)
            except Exception:
                pass  # Windows CMD编码问题，不影响SSE推送

        self.prev_state = curr_state

def monitor_thread(enc_key, session_db, contact_names, db_cache=None, username_db_map=None):
    mon = SessionMonitor(enc_key, session_db, contact_names, db_cache, username_db_map)
    wal_path = mon.wal_path

    # 初始全量解密
    pages, ms = full_decrypt(session_db, DECRYPTED_SESSION, enc_key)
    wal_patched = 0
    wal_ms = 0
    if os.path.exists(wal_path):
        wal_patched, wal_ms = decrypt_wal_full(wal_path, DECRYPTED_SESSION, enc_key)
        print(f"[init] DB {pages}页/{ms:.0f}ms + WAL {wal_patched}页/{wal_ms:.0f}ms", flush=True)
    else:
        print(f"[init] DB {pages}页/{ms:.0f}ms", flush=True)

    mon.prev_state = mon.query_state()
    print(f"[monitor] 跟踪 {len(mon.prev_state)} 个会话", flush=True)
    print(f"[monitor] mtime轮询模式 (每{POLL_MS}ms)", flush=True)

    # mtime-based 轮询: WAL是预分配固定大小，不能用size检测
    poll_interval = POLL_MS / 1000
    prev_wal_mtime = os.path.getmtime(wal_path) if os.path.exists(wal_path) else 0
    prev_db_mtime = os.path.getmtime(session_db)

    while True:
        time.sleep(poll_interval)
        try:
            # 用mtime检测WAL和DB变化
            try:
                wal_mtime = os.path.getmtime(wal_path) if os.path.exists(wal_path) else 0
                db_mtime = os.path.getmtime(session_db)
            except OSError:
                continue

            if wal_mtime == prev_wal_mtime and db_mtime == prev_db_mtime:
                continue  # 无变化

            t_detect = time.perf_counter()
            wal_changed = wal_mtime != prev_wal_mtime
            db_changed = db_mtime != prev_db_mtime

            mon.check_updates()

            t_done = time.perf_counter()
            try:
                detect_str = datetime.now().strftime('%H:%M:%S.%f')[:-3]
                print(f"  [{detect_str}] WAL={'变' if wal_changed else '-'} DB={'变' if db_changed else '-'} 总耗时={(t_done-t_detect)*1000:.1f}ms", flush=True)
            except Exception:
                pass

            prev_wal_mtime = wal_mtime
            prev_db_mtime = db_mtime

        except Exception as e:
            print(f"[poll] 错误: {e}", flush=True)
            time.sleep(1)


# ============ Web ============

HTML_PAGE = '''<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>微信消息监听</title>
<style>
*{margin:0;padding:0;box-sizing:border-box}
body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;background:#0a0a0f;color:#e0e0e0;height:100vh;display:flex;flex-direction:column}
.header{background:linear-gradient(135deg,#1a1a2e,#16213e);padding:14px 24px;border-bottom:1px solid rgba(255,255,255,.08);display:flex;align-items:center;gap:12px;flex-shrink:0}
.header h1{font-size:18px;font-weight:600;background:linear-gradient(90deg,#4fc3f7,#81c784);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
.status{font-size:12px;padding:4px 10px;border-radius:12px;transition:all .3s}
.status.ok{background:rgba(76,175,80,.15);color:#81c784;border:1px solid rgba(76,175,80,.3)}
.status.ok::before{content:'';display:inline-block;width:6px;height:6px;border-radius:50%;background:#4caf50;margin-right:6px;animation:pulse 2s infinite}
.status.err{background:rgba(244,67,54,.15);color:#ef9a9a;border:1px solid rgba(244,67,54,.3)}
@keyframes pulse{0%,100%{opacity:1}50%{opacity:.3}}
.stats{margin-left:auto;font-size:12px;color:#666;display:flex;gap:16px}
.messages{flex:1;overflow-y:auto;padding:12px}
.msg{background:rgba(255,255,255,.03);border:1px solid rgba(255,255,255,.06);border-radius:10px;padding:10px 14px;margin-bottom:5px;transition:transform .3s ease}
.msg:hover{background:rgba(255,255,255,.05)}
.msg.hl{border-left:3px solid #4fc3f7;background:rgba(79,195,247,.05);animation:slideIn .3s cubic-bezier(.22,1,.36,1)}
@keyframes slideIn{from{opacity:0;transform:translateY(-20px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}
.msg-header{display:flex;align-items:center;gap:8px;margin-bottom:3px}
.msg-time{font-size:11px;color:#555;font-family:"SF Mono",Monaco,monospace;min-width:55px}
.msg-chat{font-weight:600;color:#4fc3f7;font-size:13px;max-width:280px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.msg-chat.grp{color:#ce93d8}
.msg-sender{font-size:12px;color:#999}
.msg-r{margin-left:auto;display:flex;gap:6px;align-items:center}
.msg-type{font-size:10px;padding:2px 5px;border-radius:3px;background:rgba(255,255,255,.06);color:#777}
.msg-unread{font-size:10px;padding:1px 6px;border-radius:8px;background:rgba(244,67,54,.2);color:#ef9a9a;font-weight:600}
.msg-perf{font-size:9px;color:#333}
.msg-content{font-size:13px;line-height:1.4;color:#bbb;word-break:break-all;padding-left:63px}
.msg-img{max-width:300px;max-height:200px;border-radius:8px;cursor:pointer;margin-top:4px;transition:transform .2s}
.msg-img:hover{transform:scale(1.02)}
.empty{text-align:center;padding:80px 20px;color:#444}
.empty .icon{font-size:48px;margin-bottom:12px}
::-webkit-scrollbar{width:4px}
::-webkit-scrollbar-thumb{background:rgba(255,255,255,.08);border-radius:2px}
</style>
</head>
<body>
<div class="header">
<h1>WeChat Monitor</h1>
<div class="status ok" id="st">SSE 实时</div>
<div class="stats"><span id="cnt">0 消息</span><span id="perf"></span></div>
</div>
<div class="messages" id="msgs">
<div class="empty" id="empty"><div class="icon">📡</div><p>等待新消息...</p><p style="margin-top:6px;font-size:11px;color:#333">WAL增量解密 · SSE推送</p></div>
</div>
<script>
let n=0;
const M=document.getElementById('msgs'), S=document.getElementById('st');
const seen = new Set();  // 去重: timestamp+username
let sseReady = false;

function esc(s){const d=document.createElement('div');d.textContent=s;return d.innerHTML}

function addMsg(m, animate){
  // 去重
  const key = m.timestamp + '|' + (m.username||m.chat);
  if(seen.has(key)) return;
  seen.add(key);

  const x=document.getElementById('empty');
  if(x) x.remove();

  n++;
  document.getElementById('cnt').textContent=n+' 消息';
  if(m.decrypt_ms!=null) document.getElementById('perf').textContent=m.pages+'页/'+m.decrypt_ms+'ms';

  const d=document.createElement('div');
  d.className = animate ? 'msg hl' : 'msg';

  const sn=m.sender?`<span class="msg-sender">${esc(m.sender)}</span>`:'';
  const ur=m.unread>0?`<span class="msg-unread">${m.unread}</span>`:'';
  const cc=m.is_group?'msg-chat grp':'msg-chat';

  let contentHtml = esc(m.content||'');
  if(m.image_url){
    contentHtml = `<img class="msg-img" src="${m.image_url}" onclick="window.open('${m.image_url}','_blank')" onerror="this.style.display='none';this.nextElementSibling.style.display='inline'" /><span style="display:none">${esc(m.content||'')}</span>`;
  }

  const dk=m.timestamp+'|'+(m.username||m.chat);
  d.innerHTML=`<div class="msg-header"><span class="msg-time">${m.time}</span><span class="${cc}">${esc(m.chat)}</span>${sn}<div class="msg-r"><span class="msg-type">${m.type_icon} ${m.type}</span>${ur}</div></div><div class="msg-content" data-key="${dk}">${contentHtml}</div>`;

  M.insertBefore(d, M.firstChild);

  if(animate){
    setTimeout(()=>d.classList.remove('hl'), 3000);
    document.title='('+n+') 微信监听';
  }

  // 限制最多200条
  while(M.children.length>200) M.removeChild(M.lastChild);
}

function connectSSE(){
  const es=new EventSource('/stream');
  es.onopen=()=>{
    S.textContent='SSE 实时';
    S.className='status ok';
    sseReady=true;
  };
  es.onmessage=ev=>{
    addMsg(JSON.parse(ev.data), true);  // 新消息有动画
  };
  es.addEventListener('image_update', ev=>{
    const d=JSON.parse(ev.data);
    const key=d.timestamp+'|'+(d.username||'');
    const msgs=M.querySelectorAll('.msg');
    for(const el of msgs){
      const ct=el.querySelector('.msg-content');
      if(ct && ct.dataset.key===key){
        if(d.v2_unsupported){
          ct.innerHTML='<span style="color:#999;font-style:italic">[图片 - 新加密格式暂不支持预览]</span>';
        } else if(d.image_url){
          ct.innerHTML=`<img class="msg-img" src="${d.image_url}" onclick="window.open('${d.image_url}','_blank')" onerror="this.style.display='none'" />`;
        }
        break;
      }
    }
  });
  es.onerror=()=>{
    S.textContent='重连...';
    S.className='status err';
    sseReady=false;
    es.close();
    setTimeout(connectSSE, 2000);  // 重连不清页面
  };
}

// 启动: 加载历史(无动画) → 连接SSE(有动画)
fetch('/api/history').then(r=>r.json()).then(ms=>{
  ms.sort((a,b)=>a.timestamp-b.timestamp);
  ms.forEach(m=>addMsg(m, false));  // 历史消息无动画
  connectSSE();
});
</script>
</body>
</html>'''


CHAT_BROWSER_PAGE = '''<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>微信聊天记录</title>
<style>
*{margin:0;padding:0;box-sizing:border-box}
body{font-family:"Segoe UI",sans-serif;background:#f4f7fb;color:#1f2937}
a{text-decoration:none}
.top{position:sticky;top:0;z-index:10;background:linear-gradient(135deg,#0f172a,#1d4ed8);color:#fff;padding:16px 18px;box-shadow:0 8px 24px rgba(15,23,42,.18)}
.top-row{display:flex;align-items:center;gap:12px;flex-wrap:wrap}
.back{color:#dbeafe;font-size:13px}
.title{font-size:20px;font-weight:700}
.sub{margin-top:6px;font-size:12px;color:#bfdbfe}
.search-wrap{margin-top:12px}
.search{width:100%;max-width:520px;padding:11px 14px;border:none;border-radius:12px;background:rgba(255,255,255,.14);color:#fff;outline:none}
.search::placeholder{color:#dbeafe}
.wrap{max-width:1120px;margin:0 auto;padding:18px}
.panel{background:#fff;border:1px solid #dbe3f0;border-radius:16px;box-shadow:0 14px 36px rgba(15,23,42,.08)}
.list{display:grid;gap:10px;padding:12px}
.card{display:block;padding:14px 16px;border:1px solid #e5e7eb;border-radius:14px;color:#111827;background:#fff;transition:transform .15s ease,border-color .15s ease,box-shadow .15s ease}
.card:hover{transform:translateY(-1px);border-color:#60a5fa;box-shadow:0 10px 20px rgba(96,165,250,.16)}
.card-head{display:flex;align-items:center;gap:10px}
.badge{font-size:11px;font-weight:700;padding:2px 8px;border-radius:999px;background:#dbeafe;color:#1d4ed8}
.badge.grp{background:#ede9fe;color:#6d28d9}
.name{font-size:15px;font-weight:700;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.meta{margin-top:6px;font-size:12px;color:#6b7280;word-break:break-all}
.state{padding:36px 18px;text-align:center;color:#6b7280}
.state.err{color:#b91c1c}
.chat-head{padding:16px 18px;border-bottom:1px solid #e5e7eb}
.chat-title{font-size:18px;font-weight:700}
.chat-meta{margin-top:6px;font-size:12px;color:#6b7280}
.msgs{padding:12px;display:grid;gap:10px}
.msg{padding:12px 14px;border:1px solid #e5e7eb;border-radius:14px;background:#f8fafc}
.msg-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
.msg-time{font-size:12px;color:#475569;font-family:"Consolas",monospace}
.msg-sender{font-size:12px;font-weight:700;color:#1d4ed8}
.msg-type{font-size:11px;padding:2px 8px;border-radius:999px;background:#e2e8f0;color:#334155}
.msg-db{margin-left:auto;font-size:11px;color:#94a3b8}
.msg-body{margin-top:8px;font-size:14px;line-height:1.55;white-space:pre-wrap;word-break:break-word}
@media (max-width:700px){
  .wrap{padding:12px}
  .top{padding:14px}
  .msg-db{margin-left:0;width:100%}
}
</style>
</head>
<body>
<div class="top">
  <div class="top-row">
    <a class="back" href="/">返回实时监听</a>
    <div class="title" id="pageTitle">聊天记录</div>
  </div>
  <div class="sub" id="pageSub">按联系人查看已存储的全部聊天记录</div>
  <div class="search-wrap" id="searchWrap">
    <input id="searchInput" class="search" type="search" placeholder="搜索联系人 / 群聊 / wxid">
  </div>
</div>
<div class="wrap">
  <div class="panel" id="panel">
    <div class="state" id="state">加载中...</div>
  </div>
</div>
<script>
const panel = document.getElementById('panel');
const state = document.getElementById('state');
const pageTitle = document.getElementById('pageTitle');
const pageSub = document.getElementById('pageSub');
const searchWrap = document.getElementById('searchWrap');
const searchInput = document.getElementById('searchInput');
const params = new URLSearchParams(location.search);
const username = params.get('u');
let allChats = [];

function esc(s){
  const d = document.createElement('div');
  d.textContent = s == null ? '' : String(s);
  return d.innerHTML;
}

function showState(text, isError){
  panel.innerHTML = '<div class="state' + (isError ? ' err' : '') + '">' + esc(text) + '</div>';
}

function renderChats(items){
  if(!items.length){
    showState('没有找到可查看聊天记录的联系人', false);
    return;
  }

  const html = items.map(item => {
    const badge = item.is_group ? '<span class="badge grp">群聊</span>' : '<span class="badge">私聊</span>';
    const href = '/records?u=' + encodeURIComponent(item.username);
    const meta = '用户名: ' + esc(item.username) + ' · 来源DB: ' + item.db_count;
    return '<a class="card" href="' + href + '">'
      + '<div class="card-head">' + badge + '<div class="name">' + esc(item.display) + '</div></div>'
      + '<div class="meta">' + meta + '</div>'
      + '</a>';
  }).join('');

  panel.innerHTML = '<div class="list">' + html + '</div>';
}

function filterChats(){
  const q = searchInput.value.trim().toLowerCase();
  if(!q){
    renderChats(allChats);
    return;
  }
  const filtered = allChats.filter(item =>
    item.display.toLowerCase().includes(q) || item.username.toLowerCase().includes(q)
  );
  renderChats(filtered);
}

function renderChat(data){
  pageTitle.textContent = data.display;
  pageSub.textContent = '共 ' + data.count + ' 条记录 · 来源DB ' + data.source_count + ' 个';
  searchWrap.style.display = 'none';
  document.title = data.display + ' - 微信聊天记录';

  const msgs = data.messages.map(msg => {
    const sender = msg.sender ? '<span class="msg-sender">' + esc(msg.sender) + '</span>' : '';
    return '<div class="msg">'
      + '<div class="msg-head">'
      + '<span class="msg-time">' + esc(msg.time) + '</span>'
      + sender
      + '<span class="msg-type">' + esc(msg.type_icon + ' ' + msg.type) + '</span>'
      + '<span class="msg-db">' + esc(msg.source_db) + '</span>'
      + '</div>'
      + '<div class="msg-body">' + esc(msg.content) + '</div>'
      + '</div>';
  }).join('');

  panel.innerHTML = '<div class="chat-head"><div class="chat-title">' + esc(data.display)
    + '</div><div class="chat-meta">用户名: ' + esc(data.username)
    + (data.is_group ? ' · 群聊' : ' · 私聊')
    + '</div></div><div class="msgs">' + msgs + '</div>';
}

async function loadChatList(){
  pageTitle.textContent = '聊天记录';
  pageSub.textContent = '按联系人查看已存储的全部聊天记录';
  try{
    const resp = await fetch('/api/chats');
    const data = await resp.json();
    if(!resp.ok){
      throw new Error(data.error || '加载联系人失败');
    }
    allChats = data.chats || [];
    renderChats(allChats);
    searchInput.addEventListener('input', filterChats);
  }catch(err){
    showState(err.message || '加载失败', true);
  }
}

async function loadChatHistory(target){
  pageTitle.textContent = '聊天记录';
  pageSub.textContent = '正在读取历史消息...';
  try{
    const resp = await fetch('/api/chat_history?u=' + encodeURIComponent(target));
    const data = await resp.json();
    if(!resp.ok || !data.ok){
      throw new Error(data.error || '读取聊天记录失败');
    }
    renderChat(data);
  }catch(err){
    pageSub.textContent = '读取失败';
    showState(err.message || '读取失败', true);
  }
}

if(username){
  loadChatHistory(username);
}else{
  loadChatList();
}
</script>
</body>
</html>'''


AGENT_PAGE = '''<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>微信分身 Agent</title>
<style>
*{margin:0;padding:0;box-sizing:border-box}
body{font-family:"Segoe UI",sans-serif;background:#eef2ff;color:#111827}
button,input{font:inherit}
.hero{background:linear-gradient(135deg,#111827,#1d4ed8);color:#fff;padding:18px 20px}
.hero a{color:#bfdbfe;text-decoration:none;font-size:13px}
.hero h1{margin-top:8px;font-size:22px}
.hero p{margin-top:6px;font-size:13px;color:#dbeafe}
.wrap{max-width:1180px;margin:18px auto;padding:0 16px;display:grid;grid-template-columns:1.2fr .9fr;gap:16px}
.card{background:#fff;border:1px solid #dbe3f0;border-radius:16px;box-shadow:0 14px 36px rgba(15,23,42,.08)}
.card h2{padding:14px 16px;border-bottom:1px solid #e5e7eb;font-size:16px}
.section{padding:14px 16px}
.row{display:flex;align-items:center;gap:12px;flex-wrap:wrap}
.status{font-size:13px;padding:4px 10px;border-radius:999px;background:#dbeafe;color:#1d4ed8;font-weight:700}
.status.off{background:#fee2e2;color:#b91c1c}
.status.warn{background:#fef3c7;color:#92400e}
.btn{border:none;border-radius:10px;padding:10px 14px;font-weight:700;cursor:pointer}
.btn.primary{background:#1d4ed8;color:#fff}
.btn.soft{background:#e5e7eb;color:#111827}
.btn:disabled{opacity:.5;cursor:not-allowed}
.help{margin-top:8px;font-size:12px;color:#6b7280}
.search{width:100%;margin-bottom:12px;padding:10px 12px;border:1px solid #d1d5db;border-radius:10px}
.chat-list{max-height:420px;overflow:auto;display:grid;gap:8px}
.item{display:flex;align-items:center;gap:10px;padding:10px 12px;border:1px solid #e5e7eb;border-radius:12px}
.item.disabled{opacity:.55;background:#f9fafb}
.item label{flex:1;display:flex;justify-content:space-between;gap:8px;cursor:pointer}
.meta{font-size:12px;color:#6b7280}
.preview{display:grid;gap:10px}
.preview-item{padding:10px 12px;border:1px solid #e5e7eb;border-radius:12px;background:#f8fafc}
.preview-item .title{font-weight:700}
.preview-item .meta{margin-top:5px;line-height:1.5}
.warn{margin-top:10px;padding:10px 12px;border-radius:12px;background:#fef3c7;color:#92400e;font-size:13px}
.logs{max-height:540px;overflow:auto;font-family:"Consolas",monospace;font-size:12px;padding:14px 16px;display:grid;gap:8px}
.log{padding:9px 10px;border-radius:10px;background:#111827;color:#e5e7eb}
.log .ts{color:#93c5fd}
.log .evt{color:#fde68a}
.empty{padding:18px;color:#6b7280;font-size:13px}
@media (max-width:980px){.wrap{grid-template-columns:1fr}}
</style>
</head>
<body>
<div class="hero">
  <a href="/">返回实时监听</a>
  <h1>微信分身 Agent</h1>
  <p>选择最多 2 个聊天作为语气来源，只处理新的私聊文本消息。收到新消息后静默 10 秒，并基于最近 30 条（已过滤超长消息）自动发送回复。</p>
</div>
<div class="wrap">
  <div>
    <div class="card">
      <h2>控制台</h2>
      <div class="section">
        <div class="row">
          <span id="agentStatus" class="status off">未启用</span>
          <button id="toggleBtn" class="btn primary">启用 Agent</button>
          <button id="saveBtn" class="btn soft">保存风格来源</button>
        </div>
        <div class="help" id="stateHelp">正在读取状态...</div>
      </div>
    </div>
    <div class="card" style="margin-top:16px">
      <h2>风格来源（最多 2 人）</h2>
      <div class="section">
        <input id="searchInput" class="search" type="search" placeholder="搜索联系人 / wxid">
        <div id="chatList" class="chat-list"><div class="empty">加载中...</div></div>
      </div>
    </div>
    <div class="card" style="margin-top:16px">
      <h2>风格预览</h2>
      <div class="section">
        <div id="preview" class="preview"><div class="empty">暂无风格样本</div></div>
      </div>
    </div>
  </div>
  <div class="card">
    <h2>运行日志</h2>
    <div id="logs" class="logs"><div class="empty">暂无日志</div></div>
  </div>
</div>
<script>
let chats = [];
let checked = new Set();
let stateData = null;

function esc(s){
  const d = document.createElement('div');
  d.textContent = s == null ? '' : String(s);
  return d.innerHTML;
}

function selectedUsernames(){
  return Array.from(checked);
}

function renderState(){
  const status = document.getElementById('agentStatus');
  const btn = document.getElementById('toggleBtn');
  const help = document.getElementById('stateHelp');
  if(!stateData){
    status.textContent = '未知';
    status.className = 'status warn';
    btn.disabled = true;
    return;
  }
  const configured = stateData.model && stateData.model.configured;
  const resolved = stateData.self_username_resolved;
  const enabled = !!stateData.enabled;
  status.textContent = enabled ? '已启用' : '未启用';
  status.className = 'status ' + (enabled ? '' : 'off');
  if(!resolved || !configured){
    status.className = 'status warn';
  }
  btn.textContent = enabled ? '停用 Agent' : '启用 Agent';
  btn.disabled = false;
  const lines = [];
  lines.push('自己账号: ' + (resolved ? esc(stateData.self_username) : '未识别'));
  lines.push('DeepSeek: ' + (configured ? '已配置' : '未配置'));
  lines.push('风格来源: ' + (stateData.style_source_usernames || []).length + ' / ' + stateData.style_limits.max_contacts);
  help.innerHTML = lines.join(' · ');
}

function renderChats(){
  const q = document.getElementById('searchInput').value.trim().toLowerCase();
  const list = document.getElementById('chatList');
  const valid = new Set(chats.filter(item => !item.is_group).map(item => item.username));
  checked = new Set(Array.from(checked).filter(username => valid.has(username)));
  const filtered = chats.filter(item => {
    if(item.is_group) return false;
    if(!q) return true;
    return item.display.toLowerCase().includes(q) || item.username.toLowerCase().includes(q);
  });
  if(!filtered.length){
    list.innerHTML = '<div class="empty">没有匹配的私聊联系人</div>';
    return;
  }
  list.innerHTML = filtered.map(item => {
    const selected = checked.has(item.username);
    const disable = !selected && checked.size >= 2;
    return '<div class="item' + (disable ? ' disabled' : '') + '">'
      + '<input type="checkbox" ' + (selected ? 'checked' : '') + ' ' + (disable ? 'disabled' : '') + ' data-u="' + esc(item.username) + '">'
      + '<label><span>' + esc(item.display) + '</span><span class="meta">' + esc(item.username) + '</span></label>'
      + '</div>';
  }).join('');
  list.querySelectorAll('input[type=checkbox]').forEach(box => {
    box.addEventListener('change', ev => {
      const username = ev.target.dataset.u;
      if(ev.target.checked){
        if(checked.size >= 2){
          ev.target.checked = false;
          return;
        }
        checked.add(username);
      }else{
        checked.delete(username);
      }
      renderChats();
    });
  });
}

function renderPreview(data){
  const root = document.getElementById('preview');
  const sources = data.sources || [];
  if(!sources.length){
    root.innerHTML = '<div class="empty">暂无风格样本</div>';
    return;
  }
  let html = sources.map(item => {
    const phrases = (item.top_self_phrases || []).join('、') || '无';
    return '<div class="preview-item">'
      + '<div class="title">' + esc(item.display) + '</div>'
      + '<div class="meta">采样 ' + item.sample_count + ' 条 · 我发 ' + item.self_message_count
      + ' 条 · 平均 ' + item.avg_self_length + ' 字</div>'
      + '<div class="meta">高频词: ' + esc(phrases) + '</div>'
      + '</div>';
  }).join('');
  if(data.warning){
    html += '<div class="warn">' + esc(data.warning) + '</div>';
  }
  root.innerHTML = html;
}

function renderLogs(data){
  const root = document.getElementById('logs');
  const logs = data.logs || [];
  if(!logs.length){
    root.innerHTML = '<div class="empty">暂无日志</div>';
    return;
  }
  root.innerHTML = logs.slice().reverse().map(item => {
    const dt = new Date((item.ts || 0) * 1000);
    const ts = dt.toLocaleTimeString();
    const who = item.display || item.username || '-';
    return '<div class="log"><span class="ts">[' + esc(ts) + ']</span> '
      + '<span class="evt">' + esc(item.event) + '</span> '
      + esc(who)
      + (item.detail ? '<div style="margin-top:4px;color:#cbd5e1">' + esc(item.detail) + '</div>' : '')
      + '</div>';
  }).join('');
}

async function loadState(){
  const resp = await fetch('/api/agent/state');
  const data = await resp.json();
  if(!resp.ok || data.ok === false){
    throw new Error(data.error || '读取状态失败');
  }
  stateData = data;
  checked = new Set(data.style_source_usernames || []);
  renderState();
  renderChats();
}

async function loadChats(){
  const resp = await fetch('/api/chats');
  const data = await resp.json();
  chats = (data.chats || []).filter(item => !item.is_group);
  renderChats();
}

async function loadPreview(){
  const resp = await fetch('/api/agent/style-preview');
  const data = await resp.json();
  renderPreview(data);
}

async function loadLogs(){
  const resp = await fetch('/api/agent/logs');
  const data = await resp.json();
  renderLogs(data);
}

async function saveState(enabled){
  const payload = {
    enabled: enabled,
    style_source_usernames: selectedUsernames(),
  };
  const resp = await fetch('/api/agent/state', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify(payload),
  });
  const data = await resp.json();
  if(!resp.ok || data.ok === false){
    throw new Error(data.error || '保存失败');
  }
  stateData = data;
  checked = new Set(data.style_source_usernames || []);
  renderState();
  renderChats();
  await loadPreview();
}

document.getElementById('searchInput').addEventListener('input', renderChats);
document.getElementById('saveBtn').addEventListener('click', async () => {
  try{
    await saveState(!!(stateData && stateData.enabled));
  }catch(err){
    alert(err.message || '保存失败');
  }
});
document.getElementById('toggleBtn').addEventListener('click', async () => {
  try{
    const next = !(stateData && stateData.enabled);
    await saveState(next);
  }catch(err){
    alert(err.message || '状态更新失败');
  }
});

Promise.all([loadChats(), loadState(), loadPreview(), loadLogs()]).catch(err => {
  document.getElementById('stateHelp').textContent = err.message || '初始化失败';
});
setInterval(loadLogs, 2000);
</script>
</body>
</html>'''


class Handler(BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def handle(self):
        try:
            super().handle()
        except (ConnectionAbortedError, ConnectionResetError, BrokenPipeError, OSError):
            pass  # 浏览器关闭连接，正常

    def _send_html(self, html):
        self.send_response(200)
        self.send_header('Content-Type', 'text/html; charset=utf-8')
        self.end_headers()
        self.wfile.write(html.encode('utf-8'))

    def _send_json(self, payload, status=200):
        self.send_response(status)
        self.send_header('Content-Type', 'application/json; charset=utf-8')
        self.end_headers()
        self.wfile.write(json.dumps(payload, ensure_ascii=False).encode('utf-8'))

    def _read_json_body(self):
        try:
            length = int(self.headers.get('Content-Length') or '0')
        except ValueError:
            length = 0
        raw = self.rfile.read(length) if length > 0 else b'{}'
        return json.loads(raw.decode('utf-8'))

    def do_GET(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path
        query = urllib.parse.parse_qs(parsed.query)

        if path in ('/', '/index.html'):
            self._send_html(HTML_PAGE)

        elif path == '/agent':
            self._send_html(AGENT_PAGE)

        elif path == '/records':
            self._send_html(CHAT_BROWSER_PAGE)

        elif path == '/api/history':
            with messages_lock:
                data = sorted(messages_log, key=lambda m: m.get('timestamp', 0))
            self._send_json(data)

        elif path == '/api/chats':
            self._send_json({'ok': True, 'chats': get_chat_targets()})

        elif path == '/api/agent/state':
            if not agent_runtime:
                self._send_json({'ok': False, 'error': 'Agent 未初始化'}, status=503)
                return
            self._send_json(agent_runtime.get_state_payload())

        elif path == '/api/agent/style-preview':
            if not agent_runtime:
                self._send_json({'sources': [], 'total_self_messages': 0, 'warning': 'Agent 未初始化'})
                return
            self._send_json(agent_runtime.get_style_preview())

        elif path == '/api/agent/logs':
            if not agent_runtime:
                self._send_json({'logs': []})
                return
            self._send_json(agent_runtime.get_logs())

        elif path == '/api/chat_history':
            username = (query.get('u') or [''])[0]
            if not username:
                self._send_json({'ok': False, 'error': '缺少参数 u'}, status=400)
                return
            try:
                limit = int((query.get('limit') or ['0'])[0] or '0')
            except ValueError:
                limit = 0
            if limit < 0:
                limit = 0

            data, error = load_chat_history(username, limit)
            if error:
                self._send_json({'ok': False, 'error': error}, status=404)
                return

            payload = {'ok': True}
            payload.update(data)
            self._send_json(payload)

        elif path.startswith('/img/'):
            filename = urllib.parse.unquote(path[5:])
            # 安全: 防目录穿越
            if '/' in filename or '\\' in filename or '..' in filename:
                self.send_error(403)
                return
            filepath = os.path.join(DECODED_IMAGE_DIR, filename)
            if not os.path.isfile(filepath):
                self.send_error(404)
                return
            ext = os.path.splitext(filename)[1].lower()
            ct = {
                '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
                '.png': 'image/png', '.gif': 'image/gif',
                '.webp': 'image/webp', '.bmp': 'image/bmp',
                '.tif': 'image/tiff',
            }.get(ext, 'application/octet-stream')
            with open(filepath, 'rb') as f:
                data = f.read()
            self.send_response(200)
            self.send_header('Content-Type', ct)
            self.send_header('Content-Length', str(len(data)))
            self.send_header('Cache-Control', 'public, max-age=86400')
            self.end_headers()
            self.wfile.write(data)

        elif path == '/stream':
            self.send_response(200)
            self.send_header('Content-Type', 'text/event-stream')
            self.send_header('Cache-Control', 'no-cache')
            self.send_header('Connection', 'keep-alive')
            self.end_headers()

            q = queue.Queue()
            with sse_lock:
                sse_clients.append(q)
            try:
                while True:
                    try:
                        payload = q.get(timeout=15)
                        self.wfile.write(payload.encode('utf-8'))
                        self.wfile.flush()
                    except queue.Empty:
                        self.wfile.write(b': hb\n\n')
                        self.wfile.flush()
            except:
                pass
            finally:
                with sse_lock:
                    if q in sse_clients:
                        sse_clients.remove(q)
        else:
            self.send_error(404)

    def do_POST(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path

        if path == '/api/agent/state':
            if not agent_runtime:
                self._send_json({'ok': False, 'error': 'Agent 未初始化'}, status=503)
                return
            try:
                payload = self._read_json_body()
                state = agent_runtime.update_state(payload)
                self._send_json(state)
            except ValueError as e:
                self._send_json({'ok': False, 'error': str(e)}, status=400)
            except Exception as e:
                self._send_json({'ok': False, 'error': str(e)}, status=500)
            return

        self.send_error(404)


class ThreadedServer(ThreadingMixIn, HTTPServer):
    daemon_threads = True


def main():
    global web_db_cache, web_contact_names, web_username_db_map, agent_runtime, web_keys

    print("=" * 60, flush=True)
    print("  微信实时监听 (WAL增量 + SSE推送)", flush=True)
    print("=" * 60, flush=True)

    with open(KEYS_FILE) as f:
        keys = json.load(f)
    web_keys = keys

    enc_key = bytes.fromhex(keys["session\\session.db"]["enc_key"])
    session_db = os.path.join(DB_DIR, "session", "session.db")
    db_cache = MonitorDBCache(keys, MONITOR_CACHE_DIR)

    print("加载联系人...", flush=True)
    contact_names = load_contact_names(db_cache)
    print(f"已加载 {len(contact_names)} 个联系人", flush=True)

    print("构建 username→DB 映射...", flush=True)
    username_db_map = build_username_db_map(db_cache, keys)
    print(f"已映射 {len(username_db_map)} 个用户名", flush=True)

    web_db_cache = db_cache
    web_contact_names = contact_names
    web_username_db_map = username_db_map

    self_identity = resolve_self_identity()
    if self_identity['resolved']:
        print(f"识别到自己账号: {self_identity['self_username']} (sender_id={self_identity['self_sender_id']})", flush=True)
    else:
        print("[WARN] 无法识别自己账号，Agent 不能启用", flush=True)

    agent_cfg = _cfg.get('agent', {})
    agent_runtime = AgentRuntime(
        agent_cfg=agent_cfg,
        state_file=_cfg["agent_state_file"],
        state_default=_cfg["agent_state_default"],
        style_profile=StyleProfile(
            max_contacts=agent_cfg["style_max_contacts"],
            max_messages_per_contact=agent_cfg["style_max_messages_per_contact"],
        ),
        llm_client=DeepSeekClient(
            base_url=agent_cfg["base_url"],
            api_key=agent_cfg["api_key"],
            model=agent_cfg["model"],
        ),
        approval=DesktopApproval(timeout_sec=agent_cfg["popup_timeout_sec"]),
        sender=WeChatSender(
            input_click_ratio_x=agent_cfg["input_click_ratio_x"],
            input_click_ratio_y=agent_cfg["input_click_ratio_y"],
        ),
        fetch_exact_message=load_exact_message,
        fetch_text_history=load_text_messages,
        snapshot_latest_private_text_ids=snapshot_latest_private_text_ids,
        display_name_getter=get_display_name,
        verify_sent_message=verify_sent_text_message,
        self_identity=self_identity,
        is_valid_style_source=lambda username: username in username_db_map and '@chatroom' not in username,
    )

    # 后台预热 message_resource.db（图片解密必需）
    def _warmup():
        t0 = time.perf_counter()
        db_cache.get("message\\message_resource.db")
        print(f"[warmup] message_resource.db 预热完成 {(time.perf_counter()-t0)*1000:.0f}ms", flush=True)
    threading.Thread(target=_warmup, daemon=True).start()

    t = threading.Thread(target=monitor_thread, args=(enc_key, session_db, contact_names, db_cache, username_db_map), daemon=True)
    t.start()

    server = ThreadedServer(('0.0.0.0', PORT), Handler)
    print(f"\n=> http://localhost:{PORT}", flush=True)
    print(f"=> http://localhost:{PORT}/agent", flush=True)
    print(f"=> http://localhost:{PORT}/records", flush=True)
    print("Ctrl+C 停止\n", flush=True)

    try:
        os.system(f'cmd.exe /c start http://localhost:{PORT}')
    except:
        pass

    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\n已停止")


if __name__ == '__main__':
    main()