#!/usr/bin/env python3
"""
事件驱动舆情触发选币 v1.7.3

目标：重大消息刚发生 → 时间窗/去重/重要性评级 → 单币快速技术检查 → 飞书推送。
原则：消息只负责触发检查，技术形态决定是否推荐。
"""
import os
import re
import sys
import json
import time
import hashlib
from datetime import datetime, timedelta, timezone
from email.utils import parsedate_to_datetime
from pathlib import Path
from urllib.parse import quote_plus
import xml.etree.ElementTree as ET

import ccxt
import pandas as pd
import requests
import yaml

sys.path.insert(0, os.path.dirname(__file__))

from app.config.config_loader import load_rules, get_meta, get_strategy_direction
from app.db.altcoin_db import init_db, get_conn, create_recommendation, log_screening, log_cron_run, get_recommendation_for_push
from app.db.postgres_connection import ensure_migrations_once
from app.db.llm_insights import repair_mojibake_json, repair_mojibake_text
from app.core.opportunity_funnel import build_screening_detail
from app.services.altcoin_screener import (
    fetch_all_tickers,
    detect_volume_price_fly,
    detect_static_accumulation,
    STABLECOINS,
    WRAPPED,
    GOLD_METAL,
    EXCLUDED_BASES,
    EXCLUDED_BASE_SUFFIXES,
)
from app.services.altcoin_confirm import fetch_derivatives_context
from app.core.pa_engine import full_pa_analysis, calc_atr
from app.integrations.push_orchestrator import push_mainline_state_update

exchange = ccxt.binance({"enableRateLimit": True})

LEVEL_RANK = {"S": 4, "A": 3, "B": 2, "C": 1, "D": 0, "RISK": 5}


def _level_max(a, b):
    """返回重要性更高的级别。"""
    return a if LEVEL_RANK.get(a, 0) >= LEVEL_RANK.get(b, 0) else b


def _now():
    return datetime.now()


def _cfg():
    return load_rules(force_reload=True).get("event_driven", {})


def _parse_binance_time(ms):
    try:
        return datetime.fromtimestamp(int(ms) / 1000)
    except Exception:
        return None


def _parse_pubdate(value):
    if not value:
        return None
    try:
        dt = parsedate_to_datetime(value)
        if dt.tzinfo:
            dt = dt.astimezone().replace(tzinfo=None)
        return dt
    except Exception:
        return None


def _xml_text(node, names):
    for name in names:
        child = node.find(name)
        if child is not None and child.text:
            return child.text.strip()
    return ""


def _find_feed_items(root):
    items = root.findall(".//item")
    if items:
        return items
    return root.findall(".//{http://www.w3.org/2005/Atom}entry")


def _feed_entry_title(item):
    return _xml_text(item, ["title", "{http://www.w3.org/2005/Atom}title"])


def _feed_entry_url(item):
    link = item.find("link")
    if link is not None:
        href = link.attrib.get("href") or ""
        if href:
            return href.strip()
        if link.text:
            return link.text.strip()
    atom_link = item.find("{http://www.w3.org/2005/Atom}link")
    if atom_link is not None:
        href = atom_link.attrib.get("href") or ""
        if href:
            return href.strip()
        if atom_link.text:
            return atom_link.text.strip()
    guid = _xml_text(item, ["guid", "{http://www.w3.org/2005/Atom}id"])
    return guid


def _feed_entry_time(item):
    value = _xml_text(item, ["pubDate", "published", "updated", "{http://www.w3.org/2005/Atom}published", "{http://www.w3.org/2005/Atom}updated"])
    return _parse_pubdate(value)


def _is_recent(dt, max_hours=None):
    if not dt:
        return False
    hours = max_hours or _cfg().get("news_time_window_hours", 3)
    return (_now() - dt) <= timedelta(hours=hours) and dt <= _now() + timedelta(minutes=5)


def _event_hash(source, title, symbol):
    raw = f"{source}|{title}|{symbol}".lower().strip()
    return hashlib.sha256(raw.encode()).hexdigest()[:20]


def init_event_tables():
    ensure_migrations_once()


def _symbol_from_title(title):
    """从标题里提取可能的币种，返回 AAA/USDT 列表。"""
    text = title or ""
    candidates = set()

    # XXXUSDT / XXXUSDT Perpetual
    for m in re.finditer(r"\b([A-Z0-9]{2,15})USDT\b", text):
        base = m.group(1).upper()
        candidates.add(f"{base}/USDT")

    # Binance Will List XXX (Name) / Add XXX
    patterns = [
        r"Will List\s+([A-Z0-9]{2,15})(?![A-Z0-9]*USDT)\b",
        r"Will Launch\s+([A-Z0-9]{2,15})(?![A-Z0-9]*USDT)\b",
        r"Will Add\s+([A-Z0-9]{2,15})(?![A-Z0-9]*USDT)\b",
        r"Earn\s+([A-Z0-9]{2,15})(?![A-Z0-9]*USDT)\b",
        r"Add\s+([A-Z0-9]{2,15})(?![A-Z0-9]*USDT)\b",
    ]
    for pat in patterns:
        for m in re.finditer(pat, text, flags=re.I):
            base = m.group(1).upper()
            if base.endswith("USDT"):
                continue
            candidates.add(f"{base}/USDT")

    # 括号中的 ticker
    for m in re.finditer(r"\(([A-Z0-9]{2,15})\)", text):
        base = m.group(1).upper()
        candidates.add(f"{base}/USDT")

    return [s for s in sorted(candidates) if _tradable_symbol(s)]


def _symbols_from_text(text, aliases=None):
    aliases = aliases or {}
    symbols = set(_symbol_from_title(text))
    clean = str(text or "")
    for base in re.findall(r"(?<![A-Za-z0-9])\$?([A-Z][A-Z0-9]{1,12})(?![A-Za-z0-9])", clean):
        symbol = f"{base.upper()}/USDT"
        if _tradable_symbol(symbol):
            symbols.add(symbol)
    low = clean.lower()
    for name, base in aliases.items():
        if str(name or "").lower() in low:
            symbol = f"{str(base or '').upper()}/USDT"
            if _tradable_symbol(symbol):
                symbols.add(symbol)
    return sorted(symbols)


def _tradable_symbol(symbol):
    base = symbol.split("/")[0].upper()
    if base in STABLECOINS or base in WRAPPED or base in GOLD_METAL:
        return False
    if base in EXCLUDED_BASES or base.endswith(EXCLUDED_BASE_SUFFIXES):
        return False
    if not base.isascii():
        return False
    return True


def _base_symbol(symbol):
    return (symbol or "").split("/")[0].upper()


def _theme_cfg():
    return _cfg().get("theme_expansion", {}) or {}


def _theme_definitions():
    return _theme_cfg().get("themes", {}) or {}


def _matched_themes(title="", symbol=""):
    """识别标题/命中币种所属的生态主题。"""
    if not _theme_cfg().get("enabled", False):
        return []
    low = (title or "").lower()
    base = _base_symbol(symbol)
    matched = []
    for theme_name, theme in _theme_definitions().items():
        keywords = [str(k).lower() for k in theme.get("keywords", [])]
        primary = {str(s).upper() for s in theme.get("primary_symbols", [])}
        symbols = {str(s).upper() for s in theme.get("symbols", [])}
        if any(k and k in low for k in keywords) or base in primary or base in symbols:
            matched.append((theme_name, theme))
    return matched


def _event_copy_for_symbol(event, symbol, theme_name, theme, expanded=True):
    min_level = _theme_cfg().get("min_theme_importance", "A")
    importance = _level_max(event.get("importance", "B"), min_level)
    original_title = event.get("title", "")
    return {
        **event,
        "symbol": symbol,
        "importance": importance,
        "event_type": "theme_expansion" if expanded else "theme_direct",
        "title": f"[主题扩散:{theme_name}] {original_title}",
        "raw": {
            "parent_event": event.get("raw", {}),
            "parent_symbol": event.get("symbol", ""),
            "theme": theme_name,
            "theme_symbols": theme.get("symbols", []),
            "expansion_reason": theme.get("note", "生态主题消息扩散"),
        },
    }


def expand_theme_events(events):
    """重大生态/主题事件扩散到同生态币，解决 TON/DOGS 这类联动行情漏选。"""
    if not _theme_cfg().get("enabled", False):
        return events
    expanded = list(events)
    seen = {(e.get("source"), e.get("title"), e.get("symbol")) for e in expanded}
    for e in events:
        for theme_name, theme in _matched_themes(e.get("title", ""), e.get("symbol", "")):
            direct = _event_copy_for_symbol(e, e.get("symbol"), theme_name, theme, expanded=False)
            key = (direct.get("source"), direct.get("title"), direct.get("symbol"))
            if direct.get("symbol") and key not in seen and _tradable_symbol(direct.get("symbol")):
                expanded.append(direct)
                seen.add(key)

            for base in theme.get("symbols", []):
                symbol = f"{str(base).upper()}/USDT"
                if symbol == e.get("symbol") or not _tradable_symbol(symbol):
                    continue
                child = _event_copy_for_symbol(e, symbol, theme_name, theme, expanded=True)
                key = (child.get("source"), child.get("title"), child.get("symbol"))
                if key not in seen:
                    expanded.append(child)
                    seen.add(key)
    return expanded


def classify_event(title, source=""):
    cfg = _cfg().get("importance", {})
    low = (title or "").lower()
    negs = [k.lower() for k in cfg.get("negative_keywords", [])]
    s_keys = [k.lower() for k in cfg.get("s_keywords", [])]
    a_keys = [k.lower() for k in cfg.get("a_keywords", [])]

    if any(k in low for k in negs):
        return "RISK", "risk_negative"
    if any(k in low for k in s_keys):
        return "S", "major_listing_or_contract"
    if any(k in low for k in a_keys):
        return "A", "important_catalyst"
    if "trending" in source.lower() or "coingecko" in source.lower():
        return "B", "market_heat"
    return "C", "minor_or_unknown"


def _passes_min_importance(level):
    min_level = _cfg().get("min_importance_level", "A")
    if level == "RISK":
        return True
    return LEVEL_RANK.get(level, 0) >= LEVEL_RANK.get(min_level, 3)


def fetch_binance_events(source_key, source_cfg):
    if not source_cfg.get("enabled", True):
        return []
    url = source_cfg.get("url")
    events = []
    try:
        r = requests.get(url, timeout=10, headers={"User-Agent": "Mozilla/5.0"})
        if r.status_code != 200:
            return []
        data = r.json()
        catalogs = (data.get("data") or {}).get("catalogs") or []
        for cat in catalogs:
            for a in cat.get("articles", []) or []:
                title = a.get("title", "")
                pub = _parse_binance_time(a.get("releaseDate"))
                if not _is_recent(pub, _cfg().get("news_time_window_hours", 3)):
                    continue
                symbols = _symbol_from_title(title)
                if not symbols:
                    continue
                importance, event_type = classify_event(title, source_key)
                if not _passes_min_importance(importance):
                    continue
                code = a.get("code") or ""
                link = f"https://www.binance.com/en/support/announcement/{code}" if code else ""
                for symbol in symbols:
                    events.append({
                        "source": source_key,
                        "symbol": symbol,
                        "title": title,
                        "url": link,
                        "published_at": pub,
                        "importance": importance,
                        "event_type": event_type,
                        "raw": a,
                    })
    except Exception as e:
        print(f"[event] fetch_binance_events error {source_key}: {e}")
    return events


def fetch_coingecko_trending_events():
    cfg = _cfg().get("sources", {}).get("coingecko_trending", {})
    if not cfg.get("enabled", True):
        return []
    try:
        from app.services.sentiment_monitor import fetch_trending_coins, _get_previous_trending
        trending = fetch_trending_coins()
        prev = {r["symbol"] for r in _get_previous_trending()}
        events = []
        now = _now()
        for t in trending[:10]:
            sym = (t.get("symbol") or "").upper()
            full = f"{sym}/USDT"
            if not _tradable_symbol(full):
                continue
            # Trending 只作为热度源：必须同时满足新进Top10/Top5 + 交易所可交易，且后续仍需技术确认。
            if sym not in prev or t.get("trend_rank", 99) <= 5:
                title = f"{sym}({t.get('name','')}) enters CoinGecko Trending #{t.get('trend_rank')}"
                events.append({
                    "source": "coingecko_trending",
                    "symbol": full,
                    "title": title,
                    "url": "https://www.coingecko.com/en/trending-crypto",
                    "published_at": now,
                    "importance": "B",
                    "event_type": "market_heat",
                    "raw": t,
                })
        return events
    except Exception as e:
        print(f"[event] fetch trending error: {e}")
        return []


def fetch_rss_events(source_key, source_cfg):
    """Fetch generic RSS/Atom sources such as WuBlockchain."""
    if not source_cfg.get("enabled", True):
        return []
    url = source_cfg.get("url")
    if not url:
        return []
    max_items = int(source_cfg.get("max_items", 30) or 30)
    default_importance = str(source_cfg.get("weight") or "B").upper()
    symbol_aliases = source_cfg.get("symbol_aliases") or {}
    events = []
    try:
        r = requests.get(url, timeout=int(source_cfg.get("timeout", 12) or 12), headers={"User-Agent": "Mozilla/5.0 AlphaX/1.0"})
        if r.status_code != 200:
            return []
        root = ET.fromstring(r.content)
        for item in _find_feed_items(root)[:max_items]:
            title = _feed_entry_title(item)
            if not title:
                continue
            pub = _feed_entry_time(item) or _now()
            if not _is_recent(pub, _cfg().get("news_time_window_hours", 3)):
                continue
            symbols = _symbols_from_text(title, symbol_aliases)
            if not symbols:
                continue
            importance, event_type = classify_event(title, source_key)
            importance = _level_max(importance, default_importance)
            if not _passes_min_importance(importance):
                continue
            raw = {
                "title": title,
                "link": _feed_entry_url(item),
                "published_at": pub.isoformat(),
                "source_label": source_cfg.get("label") or source_key,
            }
            for symbol in symbols[: int(source_cfg.get("max_symbols_per_item", 6) or 6)]:
                events.append({
                    "source": source_key,
                    "symbol": symbol,
                    "title": title,
                    "url": raw["link"],
                    "published_at": pub,
                    "importance": importance,
                    "event_type": event_type if event_type != "minor_or_unknown" else "news",
                    "raw": raw,
                })
        return events
    except Exception as e:
        print(f"[event] fetch_rss_events error {source_key}: {e}")
        return []


def collect_events():
    cfg = _cfg()
    sources = cfg.get("sources", {})
    events = []
    for key in ("binance_listing", "binance_latest"):
        if key in sources:
            events.extend(fetch_binance_events(key, sources[key]))
    for key, source_cfg in sources.items():
        if source_cfg.get("type") in ("rss", "atom"):
            events.extend(fetch_rss_events(key, source_cfg))
    events.extend(fetch_coingecko_trending_events())
    return expand_theme_events(events)


def store_events(events):
    init_event_tables()
    conn = get_conn()
    stored = []
    now = _now().isoformat()
    for e in events:
        h = _event_hash(e["source"], e["title"], e["symbol"])
        try:
            cur = conn.execute("""
            INSERT INTO event_news
            (event_hash, source, symbol, title, url, published_at, detected_at, importance, event_type, raw_json)
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            ON CONFLICT(event_hash) DO NOTHING
            RETURNING id
            """, (
                h, e["source"], e["symbol"], e["title"], e.get("url", ""),
                e["published_at"].isoformat(), now, e["importance"], e["event_type"],
                json.dumps(e.get("raw", {}), ensure_ascii=False),
            ))
            if cur.fetchone():
                e["event_hash"] = h
                stored.append(e)
        except Exception as ex:
            print(f"[event] store error {e.get('title')}: {ex}")
    conn.commit()
    conn.close()
    return stored


def _normalize_llm_symbol(value):
    text = str(value or "").strip().upper()
    if not text:
        return ""
    text = text.replace("-", "/").replace("_", "/")
    if "/" in text:
        base = text.split("/")[0]
    else:
        base = re.sub(r"USDT$", "", text)
    base = re.sub(r"[^A-Z0-9]", "", base)
    if not base:
        return ""
    symbol = f"{base}/USDT"
    return symbol if _tradable_symbol(symbol) else ""


def _llm_confidence_score(value):
    try:
        score = float(value or 0)
    except Exception:
        return 0.0
    return score * 100 if 0 < score <= 1 else score


def enqueue_llm_sentiment_candidates(analysis, source_insight_id="", min_confidence=70, max_candidates=10, cooldown_hours=6):
    """Turn LLM sentiment analysis into event candidates for the existing technical gate.

    LLM output is allowed to request a technical check, but it never creates a
    recommendation or changes scores directly.
    """
    analysis = repair_mojibake_json(analysis)
    if not isinstance(analysis, dict):
        return {"queued": 0, "skipped": 0, "symbols": []}

    candidates = []
    seen = set()
    for item in analysis.get("coin_impacts") or []:
        if not isinstance(item, dict):
            continue
        if item.get("need_technical_check") is not True:
            continue
        direction = str(item.get("direction") or "").lower()
        if direction not in ("positive", "neutral", "bullish", "利好", "正面", "中性"):
            continue
        confidence = _llm_confidence_score(item.get("confidence"))
        if confidence < float(min_confidence or 0):
            continue
        symbol = _normalize_llm_symbol(item.get("symbol"))
        if not symbol or symbol in seen:
            continue
        seen.add(symbol)
        reason = str(repair_mojibake_text(item.get("reason") or "AI 舆情分析认为需要技术检查")).strip()
        candidates.append({
            "source": "llm_sentiment",
            "symbol": symbol,
            "title": f"AI舆情候选 {symbol}: {reason[:160]}",
            "url": "",
            "published_at": _now(),
            "importance": "A",
            "event_type": "llm_sentiment_candidate",
            "raw": {
                "source_insight_id": source_insight_id,
                "direction": direction,
                "confidence": confidence,
                "reason": reason,
            },
        })
        if len(candidates) >= int(max_candidates or 10):
            break

    if not candidates:
        return {"queued": 0, "skipped": 0, "symbols": []}

    init_event_tables()
    conn = get_conn()
    queued = []
    skipped = 0
    cooldown_cutoff = (_now() - timedelta(hours=float(cooldown_hours or 6))).isoformat()
    now = _now().isoformat()
    for event in candidates:
        recent = conn.execute(
            """
            SELECT id FROM event_news
            WHERE source='llm_sentiment' AND symbol=%s AND detected_at >= %s
            LIMIT 1
            """,
            (event["symbol"], cooldown_cutoff),
        ).fetchone()
        if recent:
            skipped += 1
            continue
        h = _event_hash(event["source"], event["title"], event["symbol"])
        try:
            cur = conn.execute(
                """
                INSERT INTO event_news
                (event_hash, source, symbol, title, url, published_at, detected_at, importance, event_type, raw_json, processed)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 0)
                ON CONFLICT(event_hash) DO NOTHING
                RETURNING id
                """,
                (
                    h,
                    event["source"],
                    event["symbol"],
                    event["title"],
                    event.get("url", ""),
                    event["published_at"].isoformat(),
                    now,
                    event["importance"],
                    event["event_type"],
                    json.dumps(event.get("raw", {}), ensure_ascii=False),
                ),
            )
            if not cur.fetchone():
                skipped += 1
                continue
            queued.append(event["symbol"])
        except Exception as exc:
            print(f"[event] llm candidate enqueue error {event.get('symbol')}: {exc}")
            skipped += 1
    conn.commit()
    conn.close()
    return {"queued": len(queued), "skipped": skipped, "symbols": queued}


def fetch_klines(symbol, timeframe, limit=120):
    try:
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
        return df
    except Exception:
        return None


def _ticker_info(symbol):
    try:
        t = exchange.fetch_ticker(symbol)
        return {
            "price": float(t.get("last") or 0),
            "change_24h": float(t.get("percentage") or 0),
            "volume_24h": float(t.get("quoteVolume") or 0),
        }
    except Exception:
        return {"price": 0, "change_24h": 0, "volume_24h": 0}


def quick_technical_check(event):
    symbol = event["symbol"]
    cfg = _cfg().get("technical_check", {})
    ticker = _ticker_info(symbol)
    price = ticker["price"]
    signals = [f"📢 {event['importance']}级舆情触发: {event['title']}"]
    score = 0
    decision = "ignore"
    reason = ""
    entry_plan = {}

    if price <= 0:
        return {"decision": "ignore", "reason": "交易对不可用或无价格", "score": 0, "signals": signals, "price": price}

    if event.get("importance") == "RISK":
        return {"decision": "risk", "reason": "负面重大消息，禁买/风控", "score": 0, "signals": signals, "price": price, "ticker": ticker}

    reject_gain = cfg.get("reject_if_24h_gain_gt", 30)
    warn_gain = cfg.get("warn_if_24h_gain_gt", 18)
    if ticker["change_24h"] > reject_gain:
        signals.append(f"⛔ 24h已涨{ticker['change_24h']:.1f}%>{reject_gain}%，不追高")
        return {"decision": "risk", "reason": "重大消息但已过度拉升，不追高", "score": 0, "signals": signals, "price": price, "ticker": ticker}
    elif ticker["change_24h"] > warn_gain:
        signals.append(f"⚠️ 24h已涨{ticker['change_24h']:.1f}%，追高风险升高")
        score -= 1

    h1 = fetch_klines(symbol, "1h", 100)
    h4 = fetch_klines(symbol, "4h", 100)
    if h1 is None or len(h1) < 30:
        return {"decision": "observe", "reason": "K线数据不足，仅观察", "score": 0, "signals": signals, "price": price, "ticker": ticker}

    current_triggers = [{"type": "news", "label": event.get("event_type") or "消息触发", "source": event.get("source"), "title": event.get("title"), "published_at": event.get("published_at").isoformat() if hasattr(event.get("published_at"), "isoformat") else str(event.get("published_at", ""))}]
    stale_background = []

    vp = detect_volume_price_fly(h1)
    if vp:
        if vp.get("vp_fly_count", 0) >= 1:
            score += 5
            signals.append(f"1H量价齐飞({vp.get('vp_fly_count')}根, 最大量比{vp.get('max_vol_ratio')}x)")
            current_triggers.append({"type": "technical", "label": "当前1H量价齐飞", "source": "binance_ohlcv_1h", "age_hours": vp.get("latest_vp_age_hours")})
        elif vp.get("relaxed_vp_fly_count", 0) >= 2:
            score += 4
            signals.append(f"1H连续放宽量价齐飞({vp.get('relaxed_vp_fly_count')}根)")
        elif vp.get("stale_vp_fly_count", 0):
            stale = vp.get("stale_vp_fly_details", [{}])[-1]
            signals.append(f"1H历史量价齐飞已过期({stale.get('age_hours')}小时前, 量{stale.get('vol_ratio')}x)")
            stale_background.append({"type": "technical", "label": "历史1H量价齐飞", "source": "binance_ohlcv_1h", "age_hours": stale.get("age_hours"), "vol_ratio": stale.get("vol_ratio")})
        elif vp.get("max_consecutive_3x", 0) >= 2:
            score += 2
            signals.append(f"1H连续{vp.get('max_consecutive_3x')}根3x放量")

    static_acc = detect_static_accumulation(symbol, h4) if h4 is not None and len(h4) >= 30 else None
    if static_acc:
        score += 3
        signals.append(f"4H静K蓄力({static_acc['static_count']}静K,量比{static_acc['vol_ratio']}x)")
        current_triggers.append({"type": "technical", "label": "当前4H静K蓄力", "source": "pa_engine_4h"})

        theme_bonus_cfg = _theme_cfg().get("static_accumulation_bonus", {}) or {}
        if event.get("event_type") in ("theme_expansion", "theme_direct") and theme_bonus_cfg.get("enabled", True):
            min_static = theme_bonus_cfg.get("min_static_count", 8)
            bonus = theme_bonus_cfg.get("score_bonus", 3)
            if static_acc.get("static_count", 0) >= min_static:
                score += bonus
                signals.append(f"生态主题+强静K蓄力升权(+{bonus})")

    pa1 = full_pa_analysis(h1, "1h")
    ignitions = pa1.get("ignition_points", []) if pa1 else []
    max_ig = 0
    stale_igs = []
    for ig in ignitions[-5:]:
        if ig.get("direction") != 1:
            continue
        if ig.get("age_bars", 999) <= 1:
            max_ig = max(max_ig, ig.get("strength_ratio", 0))
        else:
            stale_igs.append(ig)
    if max_ig >= 5:
        score += 3
        signals.append(f"1H静K→阳动K起爆(强度{max_ig}×)")
        current_triggers.append({"type": "technical", "label": "当前1H起爆点", "source": "pa_engine_1h", "strength": max_ig})
    elif stale_igs:
        ig = stale_igs[-1]
        signals.append(f"1H历史起爆点已过期({ig.get('age_bars')}根前, 强度{ig.get('strength_ratio')}×)")
        stale_background.append({"type": "technical", "label": "历史1H起爆点", "source": "pa_engine_1h", "age_bars": ig.get("age_bars"), "strength": ig.get("strength_ratio")})

    deriv = fetch_derivatives_context(symbol)
    funding = deriv.get("funding_rate", 0) or 0
    if funding > cfg.get("reject_if_funding_gt", 0.003):
        signals.append(f"⛔ Funding过热({funding*100:.3f}%)")
        return {"decision": "risk", "reason": "资金费率过热，不追", "score": score, "signals": signals, "price": price, "ticker": ticker, "derivatives": deriv}
    if deriv.get("top_trader_long_pct", 0) and deriv.get("top_trader_long_pct", 0) > 55:
        score += 1
        signals.append(f"大户偏多({deriv.get('top_trader_long_pct')}%)")

    atr = calc_atr(h1, 14)
    if atr and atr > 0:
        stop_loss = round(max(price * 0.92, price - 2 * atr), 6)
        tp1 = round(price * 1.05, 6)
        tp2 = round(price * 1.10, 6)
        risk = price - stop_loss
        entry_plan = {
            "entry_price": round(price, 6),
            "entry_method": "事件驱动即时技术确认",
            "entry_action": "可即刻买入" if score >= cfg.get("min_tech_score_recommend", 6) else "等技术确认",
            "stop_loss": stop_loss,
            "stop_pct": round((stop_loss / price - 1) * 100, 1) if price else 0,
            "tp1": tp1,
            "tp2": tp2,
            "rr1": round((tp1 - price) / risk, 2) if risk > 0 else 0,
            "rr2": round((tp2 - price) / risk, 2) if risk > 0 else 0,
            "current_price": round(price, 6),
            "risk_reward_ok": risk > 0,
            "trigger_context": {
                "trigger_status": "news_current" if current_triggers else "background",
                "trigger_label": "消息面触发 + 技术确认" if current_triggers else "消息背景观察",
                "current_triggers": current_triggers,
                "stale_background": stale_background,
                "event_source": event.get("source"),
                "event_title": event.get("title"),
                "event_url": event.get("url"),
                "event_importance": event.get("importance"),
                "published_at": event.get("published_at").isoformat() if hasattr(event.get("published_at"), "isoformat") else str(event.get("published_at", "")),
            },
        }

    if score >= cfg.get("min_tech_score_recommend", 6) and event.get("importance") in ("S", "A"):
        decision = "recommend"
        reason = "重大消息+技术形态确认"
    elif score >= cfg.get("min_tech_score_observe", 3):
        decision = "observe"
        reason = "消息重大但技术只到观察级"
    else:
        decision = "ignore"
        reason = "技术形态未确认"

    return {
        "decision": decision,
        "reason": reason,
        "score": score,
        "signals": signals,
        "entry_plan": entry_plan,
        "price": round(price, 6),
        "ticker": ticker,
        "derivatives": deriv,
        "static_accumulation": static_acc,
        "trigger_context": {
            "trigger_status": "news_current" if current_triggers else "background",
            "trigger_label": "消息面触发 + 技术确认" if current_triggers else "消息背景观察",
            "current_triggers": current_triggers,
            "stale_background": stale_background,
            "event_source": event.get("source"),
            "event_title": event.get("title"),
            "event_url": event.get("url"),
            "event_importance": event.get("importance"),
            "published_at": event.get("published_at").isoformat() if hasattr(event.get("published_at"), "isoformat") else str(event.get("published_at", "")),
        },
    }


def process_event(event):
    result = quick_technical_check(event)
    rec_id = 0
    pushed = False
    symbol = event["symbol"]
    decision = result["decision"]
    signals = result.get("signals", [])
    price = result.get("price", 0)

    log_screening(
        layer="舆情触发",
        symbol=symbol,
        state="爆发" if decision == "recommend" else "蓄力" if decision == "observe" else "风险" if decision == "risk" else "过期",
        score=result.get("score", 0),
        price=price or 0,
        signals=signals,
        sector="",
        leader_status=event.get("source", ""),
        is_meme=0,
        change_24h=(result.get("ticker") or {}).get("change_24h", 0),
        funding_rate=(result.get("derivatives") or {}).get("funding_rate", 0),
        detail=build_screening_detail(
            layer="舆情触发",
            state="爆发" if decision == "recommend" else "蓄力" if decision == "observe" else "风险" if decision == "risk" else "过期",
            signals=signals,
            detail={
                "candidate_stage": "discovery_candidate",
                "decision": decision,
                "reason": result.get("reason", ""),
                "event_source": event.get("source"),
                "event_title": event.get("title"),
                "event_importance": event.get("importance"),
                "trigger_context": result.get("trigger_context") or {},
                "signal_codes": [],
            },
        ),
    )

    if decision == "recommend":
        ep = result.get("entry_plan") or {}
        rec_id = create_recommendation(
            symbol=symbol,
            rec_state="爆发",
            rec_score=result.get("score", 0),
            entry_price=price,
            stop_loss=ep.get("stop_loss", 0),
            tp1=ep.get("tp1", 0),
            tp2=ep.get("tp2", 0),
            sector="事件驱动",
            signals=signals,
            is_meme=0,
            entry_plan=ep,
            direction=get_strategy_direction(),
            force_reason="重大舆情触发",
            base_state="舆情触发",
            sector_signal_count=0,
            market_context={"event_source": event.get("source"), "trigger_context": result.get("trigger_context", {}), **(result.get("ticker") or {})},
            derivatives_context=result.get("derivatives") or {},
            sector_context={"event_title": event.get("title"), "event_url": event.get("url"), "event_source": event.get("source"), "event_importance": event.get("importance"), "trigger_context": result.get("trigger_context", {})},
        )

    # 飞书只是通知层：事件脚本不再直接推 observe/risk，也不允许 rec_id=0 的事件旁路进通知。
    # 只有 decision=recommend 且已创建主推荐记录后，消费主链路派生状态进行通知。
    if decision == "recommend" and rec_id and _cfg().get("push", {}).get(decision, True):
        mainline_item = get_recommendation_for_push(rec_id)
        pushed = push_mainline_state_update(
            symbol,
            rec_id,
            mainline_item,
            title_prefix="事件触发机会",
            entry_push_type="event_entry",
            watch_push_type="event_watch_pool",
        )
    elif decision in ("observe", "risk"):
        print(f"[event] skip push {symbol}: decision={decision} is not a主链路推荐通知")

    conn = get_conn()
    conn.execute("""
    UPDATE event_news SET processed=1, decision=%s, tech_score=%s, rec_id=%s, pushed=%s
    WHERE event_hash=%s
    """, (decision, result.get("score", 0), rec_id, int(pushed), event.get("event_hash")))
    conn.commit()
    conn.close()
    return {"event": event, "result": result, "rec_id": rec_id, "pushed": pushed}


def load_unprocessed_events(limit=20):
    init_event_tables()
    conn = get_conn()
    cutoff = (_now() - timedelta(hours=_cfg().get("max_event_age_hours", 6))).isoformat()
    rows = conn.execute("""
        SELECT * FROM event_news
        WHERE processed=0 AND published_at >= %s
        ORDER BY published_at DESC LIMIT %s
    """, (cutoff, limit)).fetchall()
    conn.close()
    events = []
    for r in rows:
        d = dict(r)
        d["published_at"] = datetime.fromisoformat(d["published_at"])
        d["raw"] = json.loads(d.get("raw_json") or "{}")
        events.append(d)
    return events


def run_once(process_existing=True):
    started = _now()
    init_db()
    init_event_tables()
    collected = collect_events()
    stored = store_events(collected)
    to_process = stored if stored else (load_unprocessed_events() if process_existing else [])
    processed = []
    for e in to_process:
        if isinstance(e.get("published_at"), str):
            e["published_at"] = datetime.fromisoformat(e["published_at"])
        processed.append(process_event(e))

    output = {
        "status": "processed" if processed else "no_new_events",
        "collected_count": len(collected),
        "stored_count": len(stored),
        "processed_count": len(processed),
        "decisions": {k: sum(1 for p in processed if p["result"]["decision"] == k) for k in ["recommend", "observe", "risk", "ignore"]},
        "events": [
            {
                "symbol": p["event"].get("symbol"),
                "importance": p["event"].get("importance"),
                "title": p["event"].get("title"),
                "decision": p["result"].get("decision"),
                "score": p["result"].get("score"),
                "reason": p["result"].get("reason"),
                "rec_id": p.get("rec_id"),
                "pushed": p.get("pushed"),
            }
            for p in processed
        ],
        "check_time": _now().isoformat(),
    }
    log_cron_run(
        job_name="事件舆情",
        script_name="event_driven_screener.py",
        run_status="success",
        result_status=output["status"],
        started_at=started.isoformat(),
        finished_at=_now().isoformat(),
        duration_ms=int((_now() - started).total_seconds() * 1000),
        summary={"stored_count": len(stored), "processed_count": len(processed), "decisions": output["decisions"]},
        error_message="",
    )
    return output


def main():
    import argparse
    parser = argparse.ArgumentParser(description="事件驱动舆情触发选币")
    parser.add_argument("--once", action="store_true")
    parser.add_argument("--no-process-existing", action="store_true")
    args = parser.parse_args()
    out = run_once(process_existing=not args.no_process_existing)
    print(json.dumps(out, ensure_ascii=False, indent=2, default=str))


if __name__ == "__main__":
    main()