"""
山寨币爆发监控系统 — 推荐信号跟踪 + 策略交易执行账本
趋势反转检测：1H连续阴动K、量价背离、空头加速（替代MACD/RSI）
推荐层只管理信号状态；策略交易成交、TP/SL、移动止盈由 paper_trading 独立负责。
"""

import sys, os, shutil

# ⚠️ 安全机制：启动时强制清__pycache__，防止旧版字节码残留
for cache_dir in [
    os.path.join(os.path.dirname(__file__), "__pycache__"),
    os.path.join(os.path.dirname(__file__), "..", "__pycache__"),
]:
    if os.path.exists(cache_dir):
        shutil.rmtree(cache_dir, ignore_errors=True)

import ccxt
import pandas as pd
import json
import sys
import os
from datetime import datetime
from pathlib import Path

sys.path.insert(0, os.path.dirname(__file__))
from app.db.altcoin_db import (
    init_db, get_active_recommendations, update_recommendation_tracking,
    expire_old_recommendations, get_stats, update_recommendation_action_status,
    apply_recommendation_state_transition, log_cron_run,
    update_latest_price_cache,
)
from app.db.paper_trading import sync_recommendation as sync_paper_trade
from app.core.pa_engine import (
    calc_atr, full_pa_analysis, detect_trend_exhaustion,
    analyze_entry_point,
)
from app.config.config_loader import load_rules
from app.core.opportunity_lifecycle import apply_entry_quality_gate
from app.core.trade_math import pnl_pct as side_pnl_pct, should_stop_loss, should_take_profit
from app.core.trade_direction import normalize_trade_side
from app.db.paper_trading import sync_recommendation as sync_paper_trade

exchange = ccxt.binance({"enableRateLimit": True})
REPO_ROOT = Path(__file__).resolve().parents[2]

PROVISIONAL_BUY_SIGNAL_MARKERS = (
    "可即刻入场",
    "当前价接近回踩目标",
    "回踩确认完毕",
)


def fetch_klines(symbol, timeframe, limit=200):
    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 _format_tracking_price(price):
    try:
        price = float(price)
    except Exception:
        return ""
    if price <= 0:
        return ""
    if price >= 1:
        return f"${price:.3f}"
    if price >= 0.01:
        return f"${price:.4f}"
    if price >= 0.0001:
        return f"${price:.6f}"
    return f"${price:.8f}"


def reconcile_buy_signals_after_gate(buy_signals, final_action, gated_plan, gate_reasons):
    """买点质量闸门降级后，移除临时买入文案，保留最终终端指引。"""
    if final_action == "可即刻买入" or not gate_reasons:
        return list(buy_signals or [])

    filtered = [
        str(signal)
        for signal in (buy_signals or [])
        if not any(marker in str(signal) for marker in PROVISIONAL_BUY_SIGNAL_MARKERS)
    ]
    first_reason = str(gate_reasons[0])
    if final_action == "等回踩":
        target_price = (
            (gated_plan or {}).get("rr_target_entry")
            or (gated_plan or {}).get("entry_price")
            or (gated_plan or {}).get("wait_price")
        )
        price_text = _format_tracking_price(target_price)
        if price_text:
            filtered.append(f"🟡 现价不买，等待回踩至{price_text}附近；{first_reason}")
        else:
            filtered.append(f"🟡 现价不买，继续等待回踩；{first_reason}")
    elif final_action == "观察":
        filtered.append(f"🟡 买点未达标，保持观察；{first_reason}")
    return filtered


def analyze_tracking_signals(symbol, rec, current_price):
    """
    对active推荐做动态跟踪分析
    返回: {"action_status": str, "sell_signals": [...], "buy_signals": [...],
            "exhaustion": {...}, "entry_update": {...}}
    """
    sell_signals = []
    buy_signals = []
    action_status = "持有"  # 默认状态

    entry_price = rec["entry_price"]
    stop_loss = rec.get("stop_loss", entry_price * 0.95)
    tp1 = rec.get("tp1", entry_price * 1.03)
    tp2 = rec.get("tp2", entry_price * 1.05)
    entry_plan = rec.get("entry_plan") or {}
    side = normalize_trade_side(entry_plan.get("side") or rec.get("side") or rec.get("direction"))

    # ---- 拉取1H数据做趋势分析 ----
    h1_df = fetch_klines(symbol, "1h", limit=100)
    m15_df = fetch_klines(symbol, "15m", limit=100)
    h4_df = fetch_klines(symbol, "4h", limit=100)

    atr_1h = calc_atr(h1_df, 14) if h1_df is not None else 0

    # ---- 趋势衰减检测 ----
    exhaustion = {}
    if h1_df is not None and atr_1h > 0:
        exhaustion = detect_trend_exhaustion(h1_df, atr_1h)
        if exhaustion.get("exhausted"):
            for es in exhaustion.get("signals", []):
                sell_signals.append(es)
            if exhaustion["severity"] == "high":
                action_status = "衰减"
            elif exhaustion["severity"] == "medium":
                # 中度衰减，还持有但需关注
                sell_signals.append("趋势中度衰减，关注止盈")

    # ---- 止盈信号检测 ----
    pnl_pct = side_pnl_pct(side, entry_price, current_price) if entry_price > 0 else 0

    # TP/SL 是策略交易生命周期，不再写成推荐信号动作。
    if tp1 > 0 and should_take_profit(side, current_price, tp1):
        sell_signals.append(f"策略交易目标价已到达(${tp1:.4f})，执行结果以交易账本为准")

    rules = load_rules()

    if tp1 == 0 and pnl_pct >= 15:
        sell_signals.append(f"无TP保护但浮盈已达+{pnl_pct:.1f}%，仅作为信号风险提醒，是否平仓由策略交易/人工处理")

    # ---- 止损接近警告 ----
    if stop_loss > 0:
        loss_pct = ((current_price / stop_loss) - 1) * 100 if side != "short" else ((stop_loss / current_price) - 1) * 100
        if loss_pct < 3:  # 当前价离止损不到3%
            sell_signals.append(f"⚠️ 接近止损！当前${current_price:.4f}离止损${stop_loss:.4f}仅{loss_pct:.1f}%")
        if should_stop_loss(side, current_price, stop_loss):
            op = "≥" if side == "short" else "≤"
            sell_signals.append(f"🔴 策略交易止损价已触达！${current_price:.4f}{op}${stop_loss:.4f}，执行结果以交易账本为准")

    # ---- 趋势反转信号（PA行为检测，替代MACD） ----
    if h1_df is not None and len(h1_df) >= 30 and atr_1h > 0:
        pa_1h = full_pa_analysis(h1_df, "1h")
        pa_1h_candles = pa_1h.get("candles_class", [])
        recent_candles = pa_1h_candles[-6:] if len(pa_1h_candles) >= 6 else pa_1h_candles

        # 1H连续阴动K → 趋势反转
        dy_bear_count = sum(1 for c in recent_candles if c["type"] == "dynamic" and c["direction"] == -1)
        if dy_bear_count >= 3:
            sell_signals.append(f"🔴 1H连续{dy_bear_count}根阴动K(趋势反转)")
            if action_status == "持有":
                action_status = "反转"

        # 1H量价背离：放量但阴线（多头出货）
        avg_vol = float(h1_df["volume"].rolling(20).mean().iloc[-1])
        recent_3 = h1_df.tail(3)
        high_vol_bear = 0
        for _, row in recent_3.iterrows():
            vol_r = row["volume"] / avg_vol if avg_vol > 0 else 0
            if vol_r >= 2 and row["close"] < row["open"]:
                high_vol_bear += 1
        if high_vol_bear >= 2:
            sell_signals.append("🔴 1H放量阴线×2(多头出货)")

        # 1H连续K空头加速
        cont_k = pa_1h.get("continuous_k", [])
        for ck in cont_k:
            if ck["type"] == "bearish_continue" and ck["length"] >= 3:
                sell_signals.append(f"🔴 1H连续{ck['length']}K空头加速")
                if action_status == "持有":
                    action_status = "反转"

    # === 时间衰减 (v1.6.9) ===
    # 持仓>24h仍无盈利→降级衰减
    decay_cfg = rules.get("tracker", {}).get("time_decay", {})
    if decay_cfg.get("enabled", True):
        decay_hours = decay_cfg.get("decay_hours", 24)
        rec_time = rec.get("rec_time", "")
        if rec_time:
            try:
                t_rec = datetime.fromisoformat(rec_time)
                hours_held = (datetime.now() - t_rec).total_seconds() / 3600
                if hours_held > decay_hours and pnl_pct <= 0 and action_status == "持有":
                    sell_signals.append(f"⏰ 持仓{hours_held:.0f}h无盈利，降级衰减")
                    action_status = "衰减"
            except Exception:
                pass

    # ---- 动态买入指引（只允许在未触发任何止盈/止损/退出信号时执行） ----
    entry_update = {}
    current_action = entry_plan.get("entry_action", "")

    # 如果推荐状态是"等回踩"，检查是否到了回踩价位。
    # 注意：一旦本轮 action_status 已经是止盈/止损/跟踪止盈/反转/衰减，就绝不能再覆盖成“可即刻买入”。
    if action_status == "持有" and current_action in ("等回踩", "🟡等回踩") and h4_df is not None and atr_1h > 0:
        pa_4h = full_pa_analysis(h4_df, "4h")
        h4_zones = pa_4h.get("zones", [])
        direction = -1 if side == "short" else 1

        # 重新做15min入场点分析
        if m15_df is not None and len(m15_df) >= 20:
            entry_result = analyze_entry_point(
                h1_df=h1_df, m15_df=m15_df, atr_1h=atr_1h,
                zones_4h=h4_zones, direction=direction,
            )
            new_action = entry_result.get("action", "等回踩")

            if new_action == "即刻买入":
                buy_signals.append("🟢 反抽确认完毕！可开空(15min动K确认)" if side == "short" else "🟢 回踩确认完毕！可即刻入场(15min动K确认)")
                action_status = "可即刻买入"
            elif new_action == "等回踩":
                wait_price = entry_result.get("wait_price", 0)
                if wait_price > 0:
                    # 检查当前价是否接近回踩目标
                    dist_pct = ((current_price / wait_price) - 1) * 100 if side != "short" else ((wait_price / current_price) - 1) * 100
                    if abs(dist_pct) < 2:
                        buy_signals.append(f"🟢 当前价接近反抽目标！${current_price:.4f}≈${wait_price:.4f}" if side == "short" else f"🟢 当前价接近回踩目标！${current_price:.4f}≈${wait_price:.4f}")
                        action_status = "可即刻买入"

            entry_update = {
                "new_action": new_action,
                "reason": entry_result.get("reason", ""),
                "wait_price": entry_result.get("wait_price", 0),
            }

    action_status, gated_plan, gate_reasons = apply_entry_quality_gate(
        action_status=action_status,
        entry_plan=entry_plan,
        signals=rec.get("signals"),
        current_price=current_price,
        market_context=rec.get("market_context") or {},
        derivatives_context=rec.get("derivatives_context") or {},
        sector_context=rec.get("sector_context") or {},
        strategy_code=rec.get("strategy_code") or entry_plan.get("strategy_code"),
    )
    if gate_reasons:
        buy_signals = reconcile_buy_signals_after_gate(
            buy_signals,
            action_status,
            gated_plan,
            gate_reasons,
        )
        buy_signals.append("⚠️ 买点质量闸门: " + "；".join(gate_reasons[:3]))
        entry_plan.update(gated_plan)

    return {
        "action_status": action_status,
        "sell_signals": sell_signals,
        "buy_signals": buy_signals,
        "exhaustion": exhaustion,
        "entry_update": entry_update,
        "pnl_pct": round(pnl_pct, 2),
    }


def track_prices():
    """拉取所有active推荐币的实时价格，更新盈亏 + 动态跟踪信号"""
    recs = get_active_recommendations(actionable_only=False)
    if not recs:
        output = {
            "status": "no_active",
            "message": "无active推荐需要跟踪",
            "stats": get_stats(),
            "track_time": datetime.now().isoformat(),
        }
        print(json.dumps(output, ensure_ascii=False))
        return output

    results = []
    tracked_count = 0
    observed_count = 0
    failed_symbols = []
    for rec in recs:
        symbol = rec["symbol"]
        try:
            ticker = exchange.fetch_ticker(symbol)
            current_price = ticker["last"]

            # 最新价格缓存：看板读取小表 latest_price_cache，不再依赖 price_tracking 高频流水表
            update_latest_price_cache(symbol, current_price, source="tracker")

            # 基础盈亏/最大涨幅记录。未入场样本只做观察绩效，不触发 TP/SL。
            track_result = update_recommendation_tracking(rec["id"], current_price)

            if not rec.get("entry_triggered") and rec.get("display_bucket") != "position" and rec.get("execution_status") not in ("holding", "completed"):
                results.append({
                    "symbol": symbol,
                    "rec_id": rec["id"],
                    "entry_price": rec["entry_price"],
                    "current_price": current_price,
                    "pnl_pct": track_result.get("pnl_pct"),
                    "status": "observed_watch_only",
                    "action_status": rec.get("action_status"),
                    "sell_signals": [],
                    "buy_signals": [],
                    "exhaustion_severity": "low",
                })
                observed_count += 1
                print(f"  {symbol}: 观察池样本仅更新观察价格/PnL，不触发止盈止损")
                continue

            # PA增强：动态跟踪信号分析
            tracking_signals = analyze_tracking_signals(symbol, rec, current_price)

            # 统一状态迁移：tracker 只提交“候选状态 + 当前价”，最终状态由 DB 状态机统一落库。
            # 飞书推送只能消费统一状态机返回的最终状态，不能再自行判断。
            terminal_action = {
                "hit_tp2": "止盈2",
                "stopped_out": "止损",
            }.get(track_result.get("status"))
            requested_action = terminal_action or tracking_signals["action_status"]
            state_decision = apply_recommendation_state_transition(
                rec["id"],
                requested_action=requested_action,
                current_price=current_price,
                event_time=datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
                signals=tracking_signals.get("sell_signals", []) + tracking_signals.get("buy_signals", []),
            )
            final_action = state_decision.get("action_status", requested_action)
            paper_result = sync_paper_trade(
                {**rec, **state_decision, "id": rec["id"], "symbol": symbol},
                current_price,
                event_time=datetime.now().isoformat(),
            )
            if paper_result.get("opened") or paper_result.get("closed") or paper_result.get("activated") or paper_result.get("moved"):
                print(f"  {symbol}: paper trading event -> {paper_result}")

            results.append({
                "symbol": symbol,
                "rec_id": rec["id"],
                "entry_price": rec["entry_price"],
                "current_price": current_price,
                "pnl_pct": tracking_signals["pnl_pct"],
                "status": track_result["status"],
                "action_status": tracking_signals["action_status"],
                "sell_signals": tracking_signals["sell_signals"],
                "buy_signals": tracking_signals["buy_signals"],
                "exhaustion_severity": tracking_signals.get("exhaustion", {}).get("severity", "low"),
                "paper_trade": paper_result,
            })
            print(f"  {symbol}: 入场${rec['entry_price']} → 现在${current_price} "
                  f"盈亏{tracking_signals['pnl_pct']}% 状态={track_result['status']} "
                  f"操作={tracking_signals['action_status']}")
            tracked_count += 1

        except Exception as e:
            failed_symbols.append({"symbol": symbol, "error": str(e)})
            print(f"  {symbol}: 获取价格失败 - {e}")

    # 过期检查
    expire_old_recommendations()

    output = {
        "status": "tracked",
        "tracked_count": tracked_count,
        "observed_count": observed_count,
        "failed_count": len(failed_symbols),
        "failed_symbols": failed_symbols,
        "results": results,
        "stats": get_stats(),
        "track_time": datetime.now().isoformat(),
    }
    print(json.dumps(output, ensure_ascii=False, indent=2))
    return output


def main():
    started_at = datetime.now()
    try:
        init_db()
        output = track_prices()
    except Exception as e:
        finished_at = datetime.now()
        log_cron_run(
            job_name="跟踪",
            script_name="price_tracker.py",
            run_status="error",
            result_status="exception",
            started_at=started_at.isoformat(),
            finished_at=finished_at.isoformat(),
            duration_ms=int((finished_at - started_at).total_seconds() * 1000),
            summary={},
            error_message=str(e),
        )
        raise
    else:
        finished_at = datetime.now()
        summary = {
            "tracked_count": output.get("tracked_count", 0),
            "observed_count": output.get("observed_count", 0),
            "failed_count": output.get("failed_count", 0),
            "active_count": output.get("stats", {}).get("active_count", 0),
        }
        log_cron_run(
            job_name="跟踪",
            script_name="price_tracker.py",
            run_status="success",
            result_status=output.get("status", "completed"),
            started_at=started_at.isoformat(),
            finished_at=finished_at.isoformat(),
            duration_ms=int((finished_at - started_at).total_seconds() * 1000),
            summary=summary,
            error_message="",
        )


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="AlphaX Agent 价格跟踪任务")
    parser.add_argument("--once", action="store_true", default=True, help="执行单轮跟踪并输出结果")
    parser.parse_args()
    main()