"""持仓归因分析深化 — 选股/择时能力、持仓时长、理由有效性分析。

功能：
1. 收益归因分解（选股 vs 择时 vs 运气）
2. 持仓时长分析（短线/中线/长线胜率）
3. 买入理由有效性验证
4. 情绪标签相关性分析
5. 对标指数超额收益拆解
"""
import datetime as dt
from typing import Dict, List, Any, Tuple
from collections import defaultdict
import numpy as np
from sqlalchemy import select, and_

from db import get_session
from models import Trade, DailyQuote, IndexDaily, StockMetric


def analyze_attribution() -> Dict[str, Any]:
    """综合归因分析"""
    with get_session() as s:
        trades = s.execute(select(Trade).order_by(Trade.date, Trade.id)).scalars().all()

    if not trades:
        return {"ok": False, "msg": "暂无交易记录"}

    stock_timing = analyze_stock_vs_timing(trades)
    hold_period = analyze_hold_period(trades)
    reason_valid = analyze_reason_validity(trades)
    emotion_corr = analyze_emotion_correlation(trades)
    excess_return = analyze_excess_return(trades)

    return {
        "ok": True,
        "stock_vs_timing": stock_timing,
        "hold_period": hold_period,
        "reason_validity": reason_valid,
        "emotion_correlation": emotion_corr,
        "excess_return": excess_return,
    }


def analyze_stock_vs_timing(trades: List[Trade]) -> Dict[str, Any]:
    """分解选股能力 vs 择时能力

    选股能力：买入后股票的整体涨幅（持有期间市场表现）
    择时能力：实际买卖点的精准度（买在低点、卖在高点）
    运气成分：市场整体波动的影响
    """
    with get_session() as s:
        stock_trades = defaultdict(list)
        for t in trades:
            stock_trades[t.code].append(t)

        results = []
        total_stock_contrib = 0.0
        total_timing_contrib = 0.0

        for code, stock_trades_list in stock_trades.items():
            dates = [t.date for t in stock_trades_list]
            start = min(dates)
            end = max(dates)

            prices = {}
            for d, close in s.execute(
                select(DailyQuote.date, DailyQuote.close)
                .where(
                    and_(
                        DailyQuote.code == code,
                        DailyQuote.date >= start,
                        DailyQuote.date <= end,
                    )
                )
                .order_by(DailyQuote.date)
            ).all():
                prices[d] = float(close)

            if not prices:
                continue

            first_price = prices[min(prices.keys())]
            last_price = prices[max(prices.keys())]
            stock_return = (last_price / first_price - 1) * 100

            buys = [t for t in stock_trades_list if t.side == "buy"]
            sells = [t for t in stock_trades_list if t.side == "sell"]

            if buys and sells:
                avg_buy = np.mean([t.price for t in buys])
                avg_sell = np.mean([t.price for t in sells])

                ideal_buy = min(prices.values())
                ideal_sell = max(prices.values())

                buy_timing = (
                    (1 - (avg_buy - ideal_buy) / (ideal_sell - ideal_buy)) * 100
                    if ideal_sell > ideal_buy
                    else 50
                )
                sell_timing = (
                    ((avg_sell - ideal_buy) / (ideal_sell - ideal_buy)) * 100
                    if ideal_sell > ideal_buy
                    else 50
                )
                timing_score = (buy_timing + sell_timing) / 2
                actual_return = (avg_sell / avg_buy - 1) * 100

                results.append(
                    {
                        "code": code,
                        "stock_return": round(stock_return, 2),
                        "timing_score": round(timing_score, 1),
                        "actual_return": round(actual_return, 2),
                    }
                )

                total_stock_contrib += stock_return
                total_timing_contrib += timing_score

    if not results:
        return {"ok": False, "msg": "数据不足"}

    avg_stock = total_stock_contrib / len(results)
    avg_timing = total_timing_contrib / len(results)

    return {
        "ok": True,
        "stock_ability": round(avg_stock, 2),
        "timing_ability": round(avg_timing, 1),
        "interpretation": {
            "stock": "正值表示选对了股票（股票整体上涨），负值表示选错了",
            "timing": "100分满分，表示买卖点的精准度，50分为平均水平",
        },
        "by_stock": results,
    }


def analyze_hold_period(trades: List[Trade]) -> Dict[str, Any]:
    """持仓时长分析

    短线：持仓 <= 5天
    中线：持仓 6-30天
    长线：持仓 > 30天
    """
    holdings = defaultdict(list)
    closed_trades = []

    for t in trades:
        if t.side == "buy":
            holdings[t.code].append({"trade": t, "qty": t.qty})
        else:
            remaining = t.qty
            while remaining > 0 and holdings[t.code]:
                hold = holdings[t.code][0]
                sell_qty = min(remaining, hold["qty"])

                hold_days = (t.date - hold["trade"].date).days
                pnl = (t.price - hold["trade"].price) * sell_qty - t.fee * (
                    sell_qty / t.qty
                )
                pnl_pct = (t.price / hold["trade"].price - 1) * 100

                closed_trades.append(
                    {
                        "code": t.code,
                        "buy_date": hold["trade"].date,
                        "sell_date": t.date,
                        "hold_days": hold_days,
                        "buy_price": hold["trade"].price,
                        "sell_price": t.price,
                        "qty": sell_qty,
                        "pnl": pnl,
                        "pnl_pct": pnl_pct,
                    }
                )

                hold["qty"] -= sell_qty
                remaining -= sell_qty

                if hold["qty"] <= 0:
                    holdings[t.code].pop(0)

    if not closed_trades:
        return {"ok": False, "msg": "暂无已平仓交易"}

    short_term = [t for t in closed_trades if t["hold_days"] <= 5]
    mid_term = [t for t in closed_trades if 6 <= t["hold_days"] <= 30]
    long_term = [t for t in closed_trades if t["hold_days"] > 30]

    def calc_stats(trades_list):
        if not trades_list:
            return {"count": 0, "win_rate": 0, "avg_return": 0, "avg_days": 0}
        wins = sum(1 for t in trades_list if t["pnl"] > 0)
        return {
            "count": len(trades_list),
            "win_rate": round(wins / len(trades_list) * 100, 1),
            "avg_return": round(np.mean([t["pnl_pct"] for t in trades_list]), 2),
            "avg_days": round(np.mean([t["hold_days"] for t in trades_list]), 1),
            "total_pnl": round(sum(t["pnl"] for t in trades_list), 2),
        }

    return {
        "ok": True,
        "short_term": calc_stats(short_term),
        "mid_term": calc_stats(mid_term),
        "long_term": calc_stats(long_term),
        "recommendation": _recommend_hold_period(short_term, mid_term, long_term),
    }


def _recommend_hold_period(short, mid, long) -> str:
    """推荐最佳持仓周期"""
    periods = [
        ("短线（≤5天）", short),
        ("中线（6-30天）", mid),
        ("长线（>30天）", long),
    ]

    if not any(p for _, p in periods):
        return "数据不足"

    scores = []
    for name, trades_list in periods:
        if not trades_list:
            scores.append((name, 0))
            continue
        wins = sum(1 for t in trades_list if t["pnl"] > 0)
        win_rate = wins / len(trades_list)
        avg_ret = np.mean([t["pnl_pct"] for t in trades_list])
        score = win_rate * 50 + (avg_ret / 10) * 50
        scores.append((name, score))

    scores.sort(key=lambda x: x[1], reverse=True)
    best = scores[0][0]

    return f"建议重点关注{best}，该周期胜率和收益表现最佳"


def analyze_reason_validity(trades: List[Trade]) -> Dict[str, Any]:
    """买入理由有效性验证"""
    holdings = defaultdict(list)
    reason_stats = defaultdict(lambda: {"trades": [], "wins": 0, "total_pnl": 0})

    for t in trades:
        if t.side == "buy":
            holdings[t.code].append(t)
        else:
            while t.qty > 0 and holdings[t.code]:
                buy = holdings[t.code].pop(0)
                qty = min(t.qty, buy.qty)

                pnl = (t.price - buy.price) * qty
                pnl_pct = (t.price / buy.price - 1) * 100

                reason = buy.reason or "未标注"
                reason_stats[reason]["trades"].append(pnl_pct)
                reason_stats[reason]["total_pnl"] += pnl
                if pnl > 0:
                    reason_stats[reason]["wins"] += 1

                buy.qty -= qty
                t.qty -= qty
                if buy.qty > 0:
                    holdings[t.code].insert(0, buy)

    if not reason_stats:
        return {"ok": False, "msg": "暂无已平仓交易"}

    results = []
    for reason, stats in reason_stats.items():
        trades_list = stats["trades"]
        results.append(
            {
                "reason": reason,
                "count": len(trades_list),
                "win_rate": round(stats["wins"] / len(trades_list) * 100, 1),
                "avg_return": round(np.mean(trades_list), 2),
                "total_pnl": round(stats["total_pnl"], 2),
                "effectiveness": "有效"
                if stats["wins"] / len(trades_list) > 0.5
                else "无效",
            }
        )

    results.sort(key=lambda x: x["win_rate"], reverse=True)

    return {
        "ok": True,
        "by_reason": results,
        "best_reason": results[0]["reason"] if results else None,
        "worst_reason": results[-1]["reason"] if results else None,
    }


def analyze_emotion_correlation(trades: List[Trade]) -> Dict[str, Any]:
    """情绪标签相关性分析"""
    holdings = defaultdict(list)
    emotion_stats = defaultdict(lambda: {"trades": [], "wins": 0, "total_pnl": 0})

    for t in trades:
        if t.side == "buy":
            holdings[t.code].append(t)
        else:
            while t.qty > 0 and holdings[t.code]:
                buy = holdings[t.code].pop(0)
                qty = min(t.qty, buy.qty)

                pnl = (t.price - buy.price) * qty
                pnl_pct = (t.price / buy.price - 1) * 100

                emotion = buy.emotion or "未标注"
                emotion_stats[emotion]["trades"].append(pnl_pct)
                emotion_stats[emotion]["total_pnl"] += pnl
                if pnl > 0:
                    emotion_stats[emotion]["wins"] += 1

                buy.qty -= qty
                t.qty -= qty
                if buy.qty > 0:
                    holdings[t.code].insert(0, buy)

    if not emotion_stats:
        return {"ok": False, "msg": "暂无已平仓交易"}

    results = []
    for emotion, stats in emotion_stats.items():
        trades_list = stats["trades"]
        results.append(
            {
                "emotion": emotion,
                "count": len(trades_list),
                "win_rate": round(stats["wins"] / len(trades_list) * 100, 1),
                "avg_return": round(np.mean(trades_list), 2),
                "total_pnl": round(stats["total_pnl"], 2),
            }
        )

    results.sort(key=lambda x: x["avg_return"], reverse=True)

    return {
        "ok": True,
        "by_emotion": results,
        "advice": _generate_emotion_advice(results),
    }


def _generate_emotion_advice(results: List[Dict]) -> str:
    """生成情绪建议"""
    if not results:
        return "数据不足"

    best = results[0]
    worst = results[-1]

    advice = (
        f"最佳情绪状态：{best['emotion']}（胜率{best['win_rate']}%，"
        f"平均收益{best['avg_return']}%）\n"
    )
    advice += (
        f"最差情绪状态：{worst['emotion']}（胜率{worst['win_rate']}%，"
        f"平均收益{worst['avg_return']}%）\n"
    )
    advice += "\n建议：保持理性和纪律，避免在贪婪或恐慌时做决策"

    return advice


def analyze_excess_return(trades: List[Trade]) -> Dict[str, Any]:
    """对标指数超额收益拆解"""
    if not trades:
        return {"ok": False, "msg": "暂无交易记录"}

    start_date = min(t.date for t in trades)
    end_date = max(t.date for t in trades)

    with get_session() as s:
        index_data = s.execute(
            select(IndexDaily.date, IndexDaily.close)
            .where(
                and_(
                    IndexDaily.code == "sh000300",
                    IndexDaily.date >= start_date,
                    IndexDaily.date <= end_date,
                )
            )
            .order_by(IndexDaily.date)
        ).all()

    if not index_data:
        return {"ok": False, "msg": "缺少指数数据"}

    index_start = float(index_data[0][1])
    index_end = float(index_data[-1][1])
    index_return = (index_end / index_start - 1) * 100

    holdings = defaultdict(lambda: {"qty": 0, "cost": 0.0})
    realized_pnl = 0.0
    total_cost = 0.0

    for t in trades:
        p = holdings[t.code]
        if t.side == "buy":
            p["cost"] += t.price * t.qty + t.fee
            p["qty"] += t.qty
            total_cost += t.price * t.qty + t.fee
        else:
            if p["qty"] > 0:
                avg = p["cost"] / p["qty"]
                qty = min(t.qty, p["qty"])
                pnl = (t.price - avg) * qty - t.fee
                realized_pnl += pnl
                p["cost"] -= avg * qty
                p["qty"] -= qty

    portfolio_return = (realized_pnl / total_cost * 100) if total_cost > 0 else 0
    excess_return = portfolio_return - index_return

    if excess_return > 0:
        source = "选股能力贡献"
        interpretation = "组合表现优于大盘，说明选股和择时能力较好"
    elif excess_return < -5:
        source = "选股/择时失误"
        interpretation = "组合表现明显弱于大盘，建议反思选股逻辑和买卖时机"
    else:
        source = "与大盘持平"
        interpretation = "组合表现与大盘接近，可考虑增强选股策略"

    return {
        "ok": True,
        "portfolio_return": round(portfolio_return, 2),
        "index_return": round(index_return, 2),
        "excess_return": round(excess_return, 2),
        "source": source,
        "interpretation": interpretation,
        "period": f"{start_date} ~ {end_date}",
    }