from __future__ import annotations

import html
import json
import mimetypes
import os
import urllib.error
import urllib.request
from http import HTTPStatus
from http.cookies import SimpleCookie
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any
from urllib.parse import parse_qs, urlparse

from app.auth import COOKIE_NAME, check_credentials, hash_password, is_valid_session, make_session_cookie
from app.config import Settings, get_settings
from app.db import Database, from_json, now_iso, to_json
from app.dispatcher import Dispatcher, ValidationError, build_feishu_message, normalize_alert


class AppContext:
    def __init__(self, settings: Settings):
        self.settings = settings
        self.db = Database(settings)
        self.db.migrate(settings)
        self.dispatcher = Dispatcher(self.db, settings)


def json_response(handler: BaseHTTPRequestHandler, status: int, payload: dict[str, Any] | list[Any]) -> None:
    body = json.dumps(payload, ensure_ascii=False).encode()
    handler.send_response(status)
    handler.send_header("Content-Type", "application/json; charset=utf-8")
    handler.send_header("Content-Length", str(len(body)))
    handler.end_headers()
    handler.wfile.write(body)


def redirect(handler: BaseHTTPRequestHandler, location: str) -> None:
    handler.send_response(HTTPStatus.SEE_OTHER)
    handler.send_header("Location", location)
    handler.end_headers()


def read_body(handler: BaseHTTPRequestHandler) -> bytes:
    length = int(handler.headers.get("Content-Length", "0") or "0")
    return handler.rfile.read(length)


def parse_form(handler: BaseHTTPRequestHandler) -> dict[str, str]:
    data = read_body(handler).decode()
    return {key: values[-1] for key, values in parse_qs(data).items()}


def parse_form_multi(handler: BaseHTTPRequestHandler) -> dict[str, list[str]]:
    return parse_qs(read_body(handler).decode())


def parse_json_body(handler: BaseHTTPRequestHandler) -> dict[str, Any]:
    try:
        value = json.loads(read_body(handler).decode() or "{}")
    except json.JSONDecodeError as exc:
        raise ValidationError("Request body must be valid JSON") from exc
    if not isinstance(value, dict):
        raise ValidationError("Request body must be a JSON object")
    return value


def target_select_options(
    targets: list[dict[str, Any]],
    selected_ids: list[int] | None = None,
    placeholder: bool = False,
) -> str:
    selected_ids = selected_ids or []
    options = ['<option value="">请选择飞书 Webhook</option>'] if placeholder else []
    for target in targets:
        selected = "selected" if target["id"] in selected_ids else ""
        disabled = "" if target["enabled"] else "disabled"
        suffix = "" if target["enabled"] else " (停用)"
        options.append(
            f'<option value="{target["id"]}" {selected} {disabled}>{html.escape(target["name"])}{suffix}</option>'
        )
    return "".join(options)


class Handler(BaseHTTPRequestHandler):
    context: AppContext

    def log_message(self, format: str, *args: Any) -> None:
        print("%s - - [%s] %s" % (self.address_string(), self.log_date_time_string(), format % args))

    def do_GET(self) -> None:
        parsed = urlparse(self.path)
        if parsed.path == "/health":
            json_response(self, 200, {"ok": True})
            return
        if parsed.path == "/login":
            self.render_login()
            return
        if parsed.path.startswith("/static/"):
            self.serve_static(parsed.path)
            return
        if not self.require_auth():
            return
        if parsed.path in ("/", "/dashboard"):
            self.render_dashboard()
        elif parsed.path == "/targets":
            self.render_targets()
        elif parsed.path == "/targets/delete":
            self.render_target_delete(parsed)
        elif parsed.path == "/rules":
            self.render_rules()
        elif parsed.path == "/rules/new":
            self.render_rule_new()
        elif parsed.path == "/rules/edit":
            self.render_rule_edit(parsed)
        elif parsed.path == "/rules/delete":
            self.render_rule_delete(parsed)
        elif parsed.path == "/logs":
            self.render_logs()
        elif parsed.path == "/test":
            self.render_test()
        elif parsed.path == "/account":
            self.render_account()
        elif parsed.path == "/api/targets":
            json_response(self, 200, self.list_targets())
        elif parsed.path == "/api/rules":
            json_response(self, 200, self.list_rules())
        elif parsed.path == "/api/logs":
            json_response(self, 200, self.list_logs())
        else:
            self.send_error(404)

    def do_POST(self) -> None:
        parsed = urlparse(self.path)
        if parsed.path == "/webhook/tradingview":
            self.handle_tradingview_webhook()
            return
        if parsed.path == "/login":
            self.handle_login()
            return
        if not self.require_auth():
            return
        routes = {
            "/targets/create": self.create_target,
            "/targets/update": self.update_target,
            "/targets/delete": self.delete_target,
            "/targets/test": self.test_target,
            "/rules/create": self.create_rule,
            "/rules/update": self.update_rule,
            "/rules/delete": self.delete_rule,
            "/rules/preview": self.preview_rule,
            "/test/send": self.send_test,
            "/account/password": self.change_password,
            "/deliveries/retry": self.retry_deliveries,
            "/logout": self.logout,
        }
        handler = routes.get(parsed.path)
        if not handler:
            self.send_error(404)
            return
        handler()

    def require_auth(self) -> bool:
        if is_valid_session(self.context.settings, self.headers.get("Cookie")):
            return True
        redirect(self, "/login")
        return False

    def layout(self, title: str, body: str) -> bytes:
        nav = [
            ("/dashboard", "概览"),
            ("/rules", "路由规则"),
            ("/targets", "飞书 Webhook"),
            ("/logs", "日志"),
            ("/test", "测试发送"),
            ("/account", "账号安全"),
        ]
        items = "".join(f'<a href="{href}">{label}</a>' for href, label in nav)
        return f"""<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{html.escape(title)}</title>
  <link rel="stylesheet" href="/static/styles.css">
  <script src="/static/app.js" defer></script>
</head>
<body>
  <aside class="sidebar">
    <div class="brand">TV Dispatch</div>
    <nav>{items}</nav>
    <form method="post" action="/logout"><button class="ghost" type="submit">退出</button></form>
  </aside>
  <main class="shell">{body}</main>
</body>
</html>""".encode()

    def send_html(self, title: str, body: str) -> None:
        content = self.layout(title, body)
        self.send_response(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(content)))
        self.end_headers()
        self.wfile.write(content)

    def render_login(self) -> None:
        content = """<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Login</title>
  <link rel="stylesheet" href="/static/styles.css">
</head>
<body class="login-page">
  <form class="login-card" method="post" action="/login">
    <h1>TV Dispatch</h1>
    <p>TradingView alert routing console</p>
    <label>用户名<input name="username" autocomplete="username" required></label>
    <label>密码<input name="password" type="password" autocomplete="current-password" required></label>
    <button type="submit">登录</button>
  </form>
</body>
</html>""".encode()
        self.send_response(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(content)))
        self.end_headers()
        self.wfile.write(content)

    def handle_login(self) -> None:
        form = parse_form(self)
        if not check_credentials(
            self.context.settings,
            form.get("username", ""),
            form.get("password", ""),
            self.get_admin_password_hash(),
        ):
            redirect(self, "/login")
            return
        cookie = SimpleCookie()
        cookie[COOKIE_NAME] = make_session_cookie(self.context.settings)
        cookie[COOKIE_NAME]["path"] = "/"
        cookie[COOKIE_NAME]["httponly"] = True
        cookie[COOKIE_NAME]["samesite"] = "Lax"
        self.send_response(HTTPStatus.SEE_OTHER)
        self.send_header("Location", "/dashboard")
        self.send_header("Set-Cookie", cookie.output(header="").strip())
        self.end_headers()

    def get_admin_password_hash(self) -> str:
        with self.context.db.connect() as conn:
            row = conn.execute("SELECT password_hash FROM admin_settings WHERE id = 1").fetchone()
        return row["password_hash"]

    def logout(self) -> None:
        self.send_response(HTTPStatus.SEE_OTHER)
        self.send_header("Location", "/login")
        self.send_header("Set-Cookie", f"{COOKIE_NAME}=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax")
        self.end_headers()

    def serve_static(self, path: str) -> None:
        local_path = os.path.join(os.path.dirname(__file__), "static", os.path.basename(path))
        if not os.path.exists(local_path):
            self.send_error(404)
            return
        with open(local_path, "rb") as file:
            content = file.read()
        self.send_response(200)
        self.send_header("Content-Type", mimetypes.guess_type(local_path)[0] or "application/octet-stream")
        self.send_header("Content-Length", str(len(content)))
        self.end_headers()
        self.wfile.write(content)

    def handle_tradingview_webhook(self) -> None:
        if self.context.settings.webhook_token:
            query = parse_qs(urlparse(self.path).query)
            token = self.headers.get("X-Webhook-Token") or query.get("token", [""])[-1]
            if token != self.context.settings.webhook_token:
                json_response(self, 401, {"error": "Invalid webhook token"})
                return
        try:
            payload = parse_json_body(self)
            result = self.context.dispatcher.receive_alert(payload)
            json_response(self, 202, result)
        except ValidationError as exc:
            json_response(self, 400, {"error": str(exc)})

    def list_targets(self) -> list[dict[str, Any]]:
        with self.context.db.connect() as conn:
            rows = conn.execute("SELECT * FROM webhook_targets ORDER BY id DESC").fetchall()
        return [dict(row) for row in rows]

    def list_rules(self) -> list[dict[str, Any]]:
        with self.context.db.connect() as conn:
            rows = conn.execute("SELECT * FROM routing_rules ORDER BY priority ASC, id DESC").fetchall()
        rules = []
        for row in rows:
            item = dict(row)
            item["target_ids"] = from_json(item["target_ids"], [])
            rules.append(item)
        return rules

    def list_logs(self) -> dict[str, list[dict[str, Any]]]:
        with self.context.db.connect() as conn:
            alerts = conn.execute("SELECT * FROM alerts ORDER BY id DESC LIMIT 100").fetchall()
            deliveries = conn.execute("SELECT * FROM deliveries ORDER BY id DESC LIMIT 200").fetchall()
        return {"alerts": [dict(row) for row in alerts], "deliveries": [dict(row) for row in deliveries]}

    def render_dashboard(self) -> None:
        host = self.headers.get("Host", f"localhost:{self.context.settings.port}")
        scheme = self.headers.get("X-Forwarded-Proto", "http")
        base_url = f"{scheme}://{host}"
        webhook_url = f"{base_url}/webhook/tradingview"
        token = self.context.settings.webhook_token
        webhook_url_with_token = f"{webhook_url}?token={token}" if token else webhook_url
        token_block = (
            f"""<div class="copy-row"><span>Webhook Token</span><code>{html.escape(token)}</code><button type="button" data-copy="{html.escape(token)}">复制</button></div>
<div class="copy-row"><span>Header 方式</span><code>X-Webhook-Token: {html.escape(token)}</code><button type="button" data-copy="X-Webhook-Token: {html.escape(token)}">复制</button></div>"""
            if token
            else """<p class="warning">当前未设置 WEBHOOK_TOKEN，任何知道地址的人都可以提交 alert。生产环境建议设置。</p>"""
        )
        webhook_panel = f"""<section class="panel">
<h2>TradingView Webhook 配置</h2>
<div class="copy-row"><span>Webhook URL</span><code>{html.escape(webhook_url_with_token)}</code><button type="button" data-copy="{html.escape(webhook_url_with_token)}">复制</button></div>
<div class="copy-row"><span>纯 URL</span><code>{html.escape(webhook_url)}</code><button type="button" data-copy="{html.escape(webhook_url)}">复制</button></div>
{token_block}
</section>"""
        with self.context.db.connect() as conn:
            counts = {
                "alerts": conn.execute("SELECT COUNT(*) AS c FROM alerts").fetchone()["c"],
                "rules": conn.execute("SELECT COUNT(*) AS c FROM routing_rules").fetchone()["c"],
                "targets": conn.execute("SELECT COUNT(*) AS c FROM webhook_targets").fetchone()["c"],
                "pending": conn.execute("SELECT COUNT(*) AS c FROM deliveries WHERE status IN ('pending','retry')").fetchone()["c"],
            }
            recent = conn.execute("SELECT * FROM alerts ORDER BY id DESC LIMIT 8").fetchall()
        cards = "".join(f'<div class="metric"><span>{label}</span><strong>{value}</strong></div>' for label, value in [
            ("Alerts", counts["alerts"]),
            ("Rules", counts["rules"]),
            ("Targets", counts["targets"]),
            ("Pending", counts["pending"]),
        ])
        rows = "".join(
            f"<tr><td>{row['id']}</td><td>{html.escape(row['symbol'])}</td><td>{html.escape(row['timeframe'])}</td><td>{html.escape(row['strategy'])}</td><td><span class='status'>{html.escape(row['status'])}</span></td><td>{row['created_at']}</td></tr>"
            for row in recent
        )
        self.send_html("概览", f"<header><h1>概览</h1><p>结构化 alert 分发、飞书转发和重试状态。</p></header>{webhook_panel}<section class='metrics'>{cards}</section><section><h2>最近 Alert</h2><table><thead><tr><th>ID</th><th>品种</th><th>周期</th><th>策略</th><th>状态</th><th>时间</th></tr></thead><tbody>{rows}</tbody></table></section>")

    def render_targets(self) -> None:
        targets = self.list_targets()
        rows = "".join(
            f"""<tr>
<td>{target['id']}<input form="target-update-{target['id']}" type="hidden" name="id" value="{target['id']}"></td>
<td><input form="target-update-{target['id']}" name="name" value="{html.escape(target['name'])}" required></td>
<td class="url"><input form="target-update-{target['id']}" name="webhook_url" value="{html.escape(target['webhook_url'])}" type="url" required></td>
<td><label class="check"><input form="target-update-{target['id']}" name="enabled" type="checkbox" {'checked' if target['enabled'] else ''}> 启用</label></td>
<td><form id="target-update-{target['id']}" class="inline" method="post" action="/targets/update"></form><button form="target-update-{target['id']}" type="submit">更新</button>
  <form class="inline" method="post" action="/targets/test"><input type="hidden" name="id" value="{target['id']}"><button type="submit">测试</button></form>
  <a class="button-link danger-link" href="/targets/delete?id={target['id']}">删除</a>
</td></tr>"""
            for target in targets
        )
        form = """<form class="panel" method="post" action="/targets/create">
<h2>新增飞书 Webhook</h2>
<label>名称<input name="name" required></label>
<label>Webhook URL<input name="webhook_url" type="url" required></label>
<label class="check"><input name="enabled" type="checkbox" checked> 启用</label>
<button type="submit">保存目标</button>
</form>"""
        notice = getattr(self, "_target_notice", "")
        self.send_html("飞书 Webhook", f"<header><h1>飞书 Webhook</h1><p>维护所有可分发的飞书机器人地址。</p></header>{notice}{form}<table><thead><tr><th>ID</th><th>名称</th><th>URL</th><th>状态</th><th>操作</th></tr></thead><tbody>{rows}</tbody></table>")

    def render_target_delete(self, parsed: Any) -> None:
        target_id = parse_qs(parsed.query).get("id", [""])[-1]
        with self.context.db.connect() as conn:
            target = conn.execute("SELECT * FROM webhook_targets WHERE id = ?", (target_id,)).fetchone()
        if not target:
            self.send_error(404)
            return
        body = f"""<header><h1>删除飞书 Webhook</h1><p>请确认是否删除这个飞书目标。</p></header>
<section class="panel narrow">
<h2>{html.escape(target['name'])}</h2>
<p class="url">{html.escape(target['webhook_url'])}</p>
<form method="post" action="/targets/delete" class="actions">
<input type="hidden" name="id" value="{target['id']}">
<button class="danger" type="submit">确认删除</button>
<a class="button-link secondary" href="/targets">取消</a>
</form>
</section>"""
        self.send_html("删除飞书 Webhook", body)

    def render_rules(self) -> None:
        targets = self.list_targets()
        rules = self.list_rules()
        target_names = {target["id"]: target["name"] for target in targets}
        rows = ""
        for rule in rules:
            conditions = [
                f"周期={html.escape(rule['timeframe'])}" if rule["timeframe"] else "",
                f"品种={html.escape(rule['symbol'])}" if rule["symbol"] else "",
                f"策略={html.escape(rule['strategy'])}" if rule["strategy"] else "",
            ]
            target_name = target_names.get(rule["target_ids"][0], "-") if rule["target_ids"] else "-"
            rows += f"""<tr>
<td>{rule['id']}</td>
<td>{html.escape(rule['name'])}</td>
<td>{'<br>'.join(item for item in conditions if item) or '-'}</td>
<td>{rule['priority']}</td>
<td>{html.escape(target_name)}</td>
<td><span class="status">{'启用' if rule['enabled'] else '停用'}</span></td>
<td><a class="button-link" href="/rules/edit?id={rule['id']}">编辑</a><a class="button-link danger-link" href="/rules/delete?id={rule['id']}">删除</a></td>
</tr>"""
        header = """<header class="page-header"><div><h1>路由规则</h1><p>周期、品种、策略至少填写一个；空字段表示不限。消息统一用飞书卡片发送。</p></div><a class="button-link" href="/rules/new">新增规则</a></header>"""
        self.send_html("路由规则", f"{header}<table><thead><tr><th>ID</th><th>名称</th><th>匹配条件</th><th>优先级</th><th>发送到</th><th>状态</th><th>操作</th></tr></thead><tbody>{rows}</tbody></table>")

    def render_rule_form(
        self,
        title: str,
        action: str,
        rule: dict[str, Any] | None = None,
        preview_html: str = "",
        sample_payload: str | None = None,
    ) -> None:
        targets = self.list_targets()
        rule = rule or {
            "id": "",
            "name": "",
            "timeframe": "",
            "symbol": "",
            "strategy": "",
            "priority": 100,
            "card_title_template": "TradingView {{symbol}} {{action}}",
            "card_body_template": "**品种**: {{symbol}}\n**周期**: {{timeframe}}\n**策略**: {{strategy}}\n**动作**: {{action}}\n**价格**: {{price}}",
            "target_ids": [],
            "enabled": 1,
        }
        selected_targets = target_select_options(targets, rule.get("target_ids", []), placeholder=True)
        hidden_id = f'<input type="hidden" name="id" value="{rule["id"]}">' if rule.get("id") else ""
        button_text = "保存修改" if rule.get("id") else "创建规则"
        sample_payload = sample_payload or json.dumps(
            {"timeframe": "5m", "symbol": "BTCUSDT", "strategy": "breakout", "action": "buy", "price": 68000},
            ensure_ascii=False,
            indent=2,
        )
        body = f"""<header><h1>{html.escape(title)}</h1><p>消息统一使用飞书卡片。周期、品种、策略至少填写一个，空字段表示不限。</p></header>
<form class="panel rule-form" method="post" action="{action}">
{hidden_id}
<div class="grid">
<label>规则名<input name="name" value="{html.escape(str(rule['name']))}" required></label>
<label>周期<input name="timeframe" value="{html.escape(str(rule['timeframe']))}" placeholder="5m，空=不限"></label>
<label>品种<input name="symbol" value="{html.escape(str(rule['symbol']))}" placeholder="BTCUSDT，空=不限"></label>
<label>策略<input name="strategy" value="{html.escape(str(rule['strategy']))}" placeholder="breakout，空=不限"></label>
<label>优先级<input name="priority" type="number" value="{rule['priority']}" required></label>
</div>
<label>卡片标题模板<input name="card_title_template" value="{html.escape(str(rule['card_title_template']))}" required></label>
<label>卡片正文模板<textarea name="card_body_template" rows="6">{html.escape(str(rule['card_body_template']))}</textarea></label>
<label class="field-target">发送到<select class="select-target" name="target_ids" required>{selected_targets}</select></label>
<label class="check"><input name="enabled" type="checkbox" {'checked' if rule.get('enabled') else ''}> 启用</label>
<h2>规则命中与卡片预览</h2>
<input type="hidden" name="source_action" value="{html.escape(action)}">
<label>样例 Alert JSON<textarea name="sample_payload" rows="9">{html.escape(sample_payload)}</textarea></label>
<div class="actions"><button type="submit">{button_text}</button><button type="submit" formaction="/rules/preview">预览命中和卡片</button><a class="button-link secondary" href="/rules">返回列表</a></div>
</form>{preview_html}"""
        self.send_html(title, body)

    def render_rule_new(self) -> None:
        self.render_rule_form("新增路由规则", "/rules/create")

    def render_rule_edit(self, parsed: Any) -> None:
        query = parse_qs(parsed.query)
        rule_id = query.get("id", [""])[-1]
        with self.context.db.connect() as conn:
            rule = conn.execute("SELECT * FROM routing_rules WHERE id = ?", (rule_id,)).fetchone()
        if not rule:
            self.send_error(404)
            return
        rule_dict = dict(rule)
        rule_dict["target_ids"] = from_json(rule_dict["target_ids"], [])
        self.render_rule_form("编辑路由规则", "/rules/update", rule_dict)

    def render_rule_delete(self, parsed: Any) -> None:
        rule_id = parse_qs(parsed.query).get("id", [""])[-1]
        with self.context.db.connect() as conn:
            rule = conn.execute("SELECT * FROM routing_rules WHERE id = ?", (rule_id,)).fetchone()
        if not rule:
            self.send_error(404)
            return
        body = f"""<header><h1>删除路由规则</h1><p>请确认是否删除这条规则。</p></header>
<section class="panel narrow">
<h2>{html.escape(rule['name'])}</h2>
<p>删除后不会再匹配对应 alert，已有日志不受影响。</p>
<form method="post" action="/rules/delete" class="actions">
<input type="hidden" name="id" value="{rule['id']}">
<button class="danger" type="submit">确认删除</button>
<a class="button-link secondary" href="/rules">取消</a>
</form>
</section>"""
        self.send_html("删除路由规则", body)

    def build_rule_from_form(self, form: dict[str, list[str]]) -> dict[str, Any]:
        return {
            "id": form.get("id", [""])[-1],
            "name": form.get("name", [""])[-1].strip(),
            "timeframe": form.get("timeframe", [""])[-1].strip(),
            "symbol": form.get("symbol", [""])[-1].strip().upper(),
            "strategy": form.get("strategy", [""])[-1].strip(),
            "priority": int(form.get("priority", ["100"])[-1] or 100),
            "card_title_template": form.get("card_title_template", ["TradingView {{symbol}} {{action}}"])[-1].strip(),
            "card_body_template": form.get("card_body_template", [""])[-1].strip(),
            "target_ids": [int(value) for value in form.get("target_ids", []) if value],
            "enabled": 1 if form.get("enabled", [""])[-1] == "on" else 0,
        }

    def preview_rule(self) -> None:
        form = parse_form_multi(self)
        rule = self.build_rule_from_form(form)
        sample_payload = form.get("sample_payload", ["{}"])[-1]
        source_action = form.get("source_action", ["/rules/create"])[-1]
        title = "编辑路由规则" if rule.get("id") else "新增路由规则"
        try:
            alert = normalize_alert(json.loads(sample_payload))
            message = build_feishu_message(alert, rule)
            matched = self.context.dispatcher.find_matching_rule(alert)
            current_matches = self.rule_matches_alert(rule, alert)
            preview_html = self.render_preview_result(rule, message, matched, current_matches)
        except (json.JSONDecodeError, ValidationError, ValueError) as exc:
            preview_html = f"""<section class="result-panel error"><h2>预览失败</h2><p>{html.escape(str(exc))}</p></section>"""
        self.render_rule_form(title, source_action, rule, preview_html, sample_payload)

    def rule_matches_alert(self, rule: dict[str, Any], alert: dict[str, Any]) -> bool:
        if not any((rule.get("timeframe"), rule.get("symbol"), rule.get("strategy"))):
            return False
        if rule.get("timeframe") and rule["timeframe"] != alert.get("timeframe"):
            return False
        if rule.get("symbol") and rule["symbol"].upper() != alert.get("symbol"):
            return False
        if rule.get("strategy") and rule["strategy"] != alert.get("strategy"):
            return False
        return True

    def render_preview_result(
        self,
        rule: dict[str, Any],
        message: dict[str, Any],
        matched: dict[str, Any] | None,
        current_matches: bool,
    ) -> str:
        title = message["card"]["header"]["title"]["content"]
        content = message["card"]["elements"][0]["text"]["content"]
        matched_text = f"当前已保存规则 #{matched['id']} {matched['name']}" if matched else "没有已保存规则会命中"
        current_text = "当前表单会匹配样例 Alert" if current_matches else "当前表单不会匹配样例 Alert"
        return f"""<section class="result-panel success">
<h2>预览结果</h2>
<div class="result-grid">
<div><span>当前表单</span><strong>{html.escape(current_text)}</strong></div>
<div><span>系统实际命中</span><strong>{html.escape(matched_text)}</strong></div>
<div><span>规则优先级</span><strong>{rule.get('priority')}</strong></div>
<div><span>消息类型</span><strong>飞书卡片</strong></div>
</div>
<div class="feishu-preview">
<div class="feishu-preview-header">{html.escape(title)}</div>
<pre>{html.escape(content)}</pre>
</div>
</section>"""

    def render_logs(self) -> None:
        logs = self.list_logs()
        alert_rows = ""
        for row in logs["alerts"]:
            try:
                raw_payload = json.dumps(json.loads(row["payload"]), ensure_ascii=False, indent=2)
            except Exception:
                raw_payload = row["payload"] or ""
            alert_rows += f"""<tr>
<td>{row['id']}</td>
<td>{html.escape(row['symbol'])}</td>
<td>{html.escape(row['timeframe'])}</td>
<td>{html.escape(row['strategy'])}</td>
<td><span class='status'>{html.escape(row['status'])}</span></td>
<td>{html.escape(row['error'] or '')}</td>
<td>{row['created_at']}</td>
<td><details class="payload-details"><summary>查看</summary><pre>{html.escape(raw_payload)}</pre></details></td>
</tr>"""
        delivery_rows = "".join(
            f"<tr><td>{row['id']}</td><td>{row['alert_id']}</td><td>{html.escape(row['target_name'])}</td><td><span class='status'>{html.escape(row['status'])}</span></td><td>{row['attempts']}</td><td>{html.escape(str(row['response_code'] or ''))}</td><td>{html.escape(row['error'] or '')}</td><td>{html.escape(row['next_attempt_at'] or '')}</td></tr>"
            for row in logs["deliveries"]
        )
        body = f"""<header><h1>日志</h1><p>最近 100 条 alert 和 200 条分发任务。</p></header>
<form method="post" action="/deliveries/retry"><button type="submit">处理到期重试</button></form>
<section><h2>Alert 日志</h2><table><thead><tr><th>ID</th><th>品种</th><th>周期</th><th>策略</th><th>状态</th><th>错误</th><th>时间</th><th>原始 Alert</th></tr></thead><tbody>{alert_rows}</tbody></table></section>
<section><h2>Delivery 日志</h2><table><thead><tr><th>ID</th><th>Alert</th><th>目标</th><th>状态</th><th>次数</th><th>HTTP</th><th>错误</th><th>下次重试</th></tr></thead><tbody>{delivery_rows}</tbody></table></section>"""
        self.send_html("日志", body)

    def render_test(self) -> None:
        sample = html.escape(json.dumps({"timeframe": "5m", "symbol": "BTCUSDT", "strategy": "breakout", "action": "buy", "price": 68000}, indent=2))
        result = getattr(self, "_test_result_html", "")
        body = f"""<header><h1>测试发送</h1><p>提交一条模拟 TradingView alert，走完整匹配和飞书转发流程。</p></header>
<form class="panel" method="post" action="/test/send">
<label>Alert JSON<textarea name="payload" rows="12">{sample}</textarea></label>
<button type="submit">发送测试 Alert</button>
</form>"""
        if result:
            body += result
        self.send_html("测试发送", body)

    def render_account(self) -> None:
        body = """<header><h1>账号安全</h1><p>修改当前管理员密码，修改成功后会退出登录。</p></header>
<form class="panel narrow" method="post" action="/account/password">
<h2>修改密码</h2>
<label>当前密码<input name="current_password" type="password" autocomplete="current-password" required></label>
<label>新密码<input name="new_password" type="password" autocomplete="new-password" minlength="8" required></label>
<label>确认新密码<input name="confirm_password" type="password" autocomplete="new-password" minlength="8" required></label>
<button type="submit">更新密码</button>
</form>"""
        self.send_html("账号安全", body)

    def create_target(self) -> None:
        form = parse_form(self)
        now = now_iso()
        with self.context.db.connect() as conn:
            conn.execute(
                "INSERT INTO webhook_targets (name, webhook_url, enabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
                (form["name"].strip(), form["webhook_url"].strip(), 1 if form.get("enabled") == "on" else 0, now, now),
            )
        redirect(self, "/targets")

    def update_target(self) -> None:
        form = parse_form(self)
        with self.context.db.connect() as conn:
            conn.execute(
                "UPDATE webhook_targets SET name = ?, webhook_url = ?, enabled = ?, updated_at = ? WHERE id = ?",
                (form["name"].strip(), form["webhook_url"].strip(), 1 if form.get("enabled") == "on" else 0, now_iso(), form["id"]),
            )
        redirect(self, "/targets")

    def delete_target(self) -> None:
        form = parse_form(self)
        with self.context.db.connect() as conn:
            conn.execute("DELETE FROM webhook_targets WHERE id = ?", (form["id"],))
        redirect(self, "/targets")

    def test_target(self) -> None:
        form = parse_form(self)
        with self.context.db.connect() as conn:
            target = conn.execute("SELECT * FROM webhook_targets WHERE id = ?", (form.get("id"),)).fetchone()
        if not target:
            self.send_error(404)
            return
        message = build_feishu_message(
            {"symbol": "TEST", "timeframe": "5m", "strategy": "webhook-test", "action": "test"},
            {
                "card_title_template": "TV Dispatch 测试消息",
                "card_body_template": "**目标**: {{symbol}}\n**动作**: {{action}}\n这是一条飞书 Webhook 连通性测试。",
            },
        )
        try:
            data = json.dumps(message, ensure_ascii=False).encode()
            request = urllib.request.Request(
                target["webhook_url"],
                data=data,
                headers={"Content-Type": "application/json"},
                method="POST",
            )
            with urllib.request.urlopen(request, timeout=self.context.settings.feishu_timeout_seconds) as response:
                status = response.getcode()
            self.render_targets_with_notice(f"测试消息已发送到 {html.escape(target['name'])}，HTTP {status}", success=True)
        except urllib.error.HTTPError as exc:
            self.render_targets_with_notice(f"测试发送失败：HTTP {exc.code}", success=False)
        except Exception as exc:
            self.render_targets_with_notice(f"测试发送失败：{html.escape(str(exc))}", success=False)

    def render_targets_with_notice(self, message: str, success: bool) -> None:
        self._target_notice = f"""<section class="result-panel {'success' if success else 'error'}"><h2>Webhook 测试</h2><p>{message}</p></section>"""
        self.render_targets()

    def create_rule(self) -> None:
        form = parse_form_multi(self)
        target_ids = [int(value) for value in form.get("target_ids", [])]
        timeframe = form.get("timeframe", [""])[-1].strip()
        symbol = form.get("symbol", [""])[-1].strip().upper()
        strategy = form.get("strategy", [""])[-1].strip()
        if not any((timeframe, symbol, strategy)):
            self.send_error(400, "周期、品种、策略至少填写一个")
            return
        now = now_iso()
        with self.context.db.connect() as conn:
            conn.execute(
                """
                INSERT INTO routing_rules (
                    name, timeframe, symbol, strategy, priority, message_type,
                    card_title_template, card_body_template, enabled, target_ids,
                    created_at, updated_at
                )
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    form.get("name", [""])[-1].strip(),
                    timeframe,
                    symbol,
                    strategy,
                    int(form.get("priority", ["100"])[-1]),
                    "card",
                    form.get("card_title_template", ["TradingView {{symbol}} {{action}}"])[-1].strip(),
                    form.get("card_body_template", [""])[-1].strip(),
                    1 if form.get("enabled", [""])[-1] == "on" else 0,
                    to_json(target_ids),
                    now,
                    now,
                ),
            )
        redirect(self, "/rules")

    def delete_rule(self) -> None:
        form = parse_form(self)
        with self.context.db.connect() as conn:
            conn.execute("DELETE FROM routing_rules WHERE id = ?", (form["id"],))
        redirect(self, "/rules")

    def update_rule(self) -> None:
        form = parse_form_multi(self)
        target_ids = [int(value) for value in form.get("target_ids", [])]
        timeframe = form.get("timeframe", [""])[-1].strip()
        symbol = form.get("symbol", [""])[-1].strip().upper()
        strategy = form.get("strategy", [""])[-1].strip()
        if not any((timeframe, symbol, strategy)):
            self.send_error(400, "周期、品种、策略至少填写一个")
            return
        with self.context.db.connect() as conn:
            conn.execute(
                """
                UPDATE routing_rules
                SET name = ?, timeframe = ?, symbol = ?, strategy = ?, priority = ?,
                    message_type = ?, card_title_template = ?, card_body_template = ?,
                    enabled = ?, target_ids = ?, updated_at = ?
                WHERE id = ?
                """,
                (
                    form.get("name", [""])[-1].strip(),
                    timeframe,
                    symbol,
                    strategy,
                    int(form.get("priority", ["100"])[-1]),
                    "card",
                    form.get("card_title_template", ["TradingView {{symbol}} {{action}}"])[-1].strip(),
                    form.get("card_body_template", [""])[-1].strip(),
                    1 if form.get("enabled", [""])[-1] == "on" else 0,
                    to_json(target_ids),
                    now_iso(),
                    form.get("id", [""])[-1],
                ),
            )
        redirect(self, "/rules")

    def send_test(self) -> None:
        form = parse_form(self)
        payload_text = form.get("payload", "{}")
        try:
            payload = json.loads(payload_text)
            result = self.context.dispatcher.receive_alert(payload)
            delivery_text = ", ".join(str(item) for item in result.get("delivery_ids", [])) or "-"
            self._test_result_html = f"""<section class="result-panel success">
<h2>测试结果</h2>
<div class="result-grid">
<div><span>Alert ID</span><strong>{result.get("alert_id")}</strong></div>
<div><span>状态</span><strong>{html.escape(str(result.get("status")))}</strong></div>
<div><span>命中规则</span><strong>{html.escape(str(result.get("matched_rule_id") or "-"))}</strong></div>
<div><span>Delivery</span><strong>{html.escape(delivery_text)}</strong></div>
</div>
<details><summary>查看响应 JSON</summary><pre>{html.escape(json.dumps(result, ensure_ascii=False, indent=2))}</pre></details>
</section>"""
            self.render_test()
        except (json.JSONDecodeError, ValidationError) as exc:
            self._test_result_html = f"""<section class="result-panel error">
<h2>测试失败</h2>
<p>{html.escape(str(exc))}</p>
</section>"""
            self.render_test()

    def change_password(self) -> None:
        form = parse_form(self)
        current_password = form.get("current_password", "")
        new_password = form.get("new_password", "")
        confirm_password = form.get("confirm_password", "")
        if not check_credentials(
            self.context.settings,
            self.context.settings.admin_username,
            current_password,
            self.get_admin_password_hash(),
        ):
            json_response(self, 400, {"error": "当前密码不正确"})
            return
        if len(new_password) < 8:
            json_response(self, 400, {"error": "新密码至少需要 8 位"})
            return
        if new_password != confirm_password:
            json_response(self, 400, {"error": "两次输入的新密码不一致"})
            return
        with self.context.db.connect() as conn:
            conn.execute(
                "UPDATE admin_settings SET password_hash = ?, updated_at = ? WHERE id = 1",
                (hash_password(new_password), now_iso()),
            )
        self.logout()

    def retry_deliveries(self) -> None:
        self.context.dispatcher.process_due_deliveries(limit=100)
        redirect(self, "/logs")


def make_handler(context: AppContext) -> type[Handler]:
    class BoundHandler(Handler):
        pass

    BoundHandler.context = context
    return BoundHandler


def run() -> None:
    settings = get_settings()
    context = AppContext(settings)
    context.db.cleanup_old_logs(settings.retention_days)
    server = ThreadingHTTPServer((settings.host, settings.port), make_handler(context))
    print(f"Serving {settings.app_name} on http://{settings.host}:{settings.port}")
    server.serve_forever()


if __name__ == "__main__":
    run()