buffer_platform/app/api/trade_review.py

"""
交易复盘接口 - 提供交易记录导入、查询、汇总、统计等功能
"""
import logging
from typing import Optional

from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
from pydantic import BaseModel
from sqlalchemy.orm import Session

from app.analysis_db import get_analysis_db
from app.analysis_models import TradeRecord, TradeImportBatch
from app.services.trade_parser import (
    parse_settlement_file,
    save_to_db,
    calc_daily_summary,
    calc_variety_summary,
    calc_overall_statistics,
    get_trade_pairs,
)
from app.services.trade_pairing_engine import (
    auto_pair_trades,
    get_daily_trades_with_pairs,
    create_manual_pair,
    delete_pair,
)
from app.services.reflection_ai_analysis import (
    analyze_with_reflection,
    get_analysis_history,
    get_latest_analysis,
    save_suggestion_as_experience,
)

logger = logging.getLogger(__name__)
router = APIRouter(prefix="/trade-review", tags=["交易复盘"])


# ==================== 文件导入 ====================

@router.post("/import")
async def import_settlement(
    file: UploadFile = File(...),
    db: Session = Depends(get_analysis_db),
):
    """上传并解析期货结算单文件，导入交易记录（含逐条去重校验）"""
    if not file.filename.endswith(('.xls', '.xlsx')):
        raise HTTPException(status_code=400, detail="仅支持 .xls/.xlsx 格式的结算单文件")

    try:
        content = await file.read()
        df_futures, df_options = parse_settlement_file(content, file.filename)

        if df_futures.empty and df_options.empty:
            return {"success": False, "message": "文件中未找到有效的交易记录（请确认是期货公司导出的结算单）"}

        result = save_to_db(db, df_futures, df_options, file.filename)

        total_skipped = result['futures_skipped'] + result['options_skipped']
        total_new = result['futures_count'] + result['options_count']
        total_parsed = result['futures_parsed'] + result['options_parsed']

        if total_new == 0 and total_skipped > 0:
            skipped_details = result.get('skipped_details', [])
            return {
                "success": True,
                "message": f"全部跳过：共解析 {total_parsed} 条记录，均已存在（去重规则：交易日+品种+时间+价格），未导入任何新数据",
                "data": result,
                "skipped_details": skipped_details,
            }

        msg_parts = [f"导入成功：期货 {result['futures_count']} 条，期权 {result['options_count']} 条"]
        if total_skipped > 0:
            msg_parts.append(f"跳过重复 {total_skipped} 条")
        msg_parts.append(f"交易日期: {result['trade_dates']}")

        return {
            "success": True,
            "message": "，".join(msg_parts),
            "data": result,
            "skipped_details": result.get('skipped_details', []),
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.exception("导入结算单失败")
        raise HTTPException(status_code=500, detail=f"导入失败: {str(e)}")


@router.post("/batch-import")
async def batch_import_settlement(
    files: list[UploadFile] = File(...),
    db: Session = Depends(get_analysis_db),
):
    """批量上传并解析期货结算单文件，导入交易记录（含逐条去重校验）"""
    if not files:
        raise HTTPException(status_code=400, detail="请选择至少一个结算单文件")

    results = []
    total_futures = 0
    total_options = 0
    total_skipped_all = 0
    processed_count = 0
    failed_count = 0
    # 维护跨文件的去重键集合，用于文件间去重
    batch_existing_keys = set()

    for file in files:
        if not file.filename.endswith(('.xls', '.xlsx')):
            results.append({
                "filename": file.filename,
                "success": False,
                "message": "文件格式不支持，仅支持 .xls/.xlsx",
            })
            failed_count += 1
            continue

        try:
            content = await file.read()
            df_futures, df_options = parse_settlement_file(content, file.filename)

            if df_futures.empty and df_options.empty:
                results.append({
                    "filename": file.filename,
                    "success": False,
                    "message": "文件中未找到有效的交易记录",
                })
                failed_count += 1
                continue

            # 传入已处理文件的去重键，实现文件间去重
            result = save_to_db(db, df_futures, df_options, file.filename, batch_existing_keys)

            # 将本次导入的新记录去重键加入集合，供后续文件去重使用
            if 'new_keys' in result:
                batch_existing_keys.update(result['new_keys'])

            file_new = result['futures_count'] + result['options_count']
            file_skipped = result['futures_skipped'] + result['options_skipped']
            total_futures += result['futures_count']
            total_options += result['options_count']
            total_skipped_all += file_skipped
            processed_count += 1

            msg_parts = []
            if file_new > 0:
                msg_parts.append(f"新导入 {file_new} 条（期货 {result['futures_count']}，期权 {result['options_count']}）")
            if file_skipped > 0:
                msg_parts.append(f"跳过重复 {file_skipped} 条")
            if not msg_parts:
                msg_parts.append("无有效记录")

            results.append({
                "filename": file.filename,
                "success": True,
                "message": "，".join(msg_parts),
                "new_count": file_new,
                "skipped_count": file_skipped,
                "skipped_details": result.get('skipped_details', []),
                "trade_dates": result['trade_dates'],
                "batch_id": result['batch_id'],
            })
        except Exception as e:
            logger.exception(f"批量导入文件失败: {file.filename}")
            results.append({
                "filename": file.filename,
                "success": False,
                "message": f"导入失败: {str(e)}",
            })
            failed_count += 1

    summary = (
        f"批量导入完成：共 {len(files)} 个文件，"
        f"处理 {processed_count} 个，失败 {failed_count} 个，"
        f"合计新导入期货 {total_futures} 条、期权 {total_options} 条，跳过重复 {total_skipped_all} 条"
    )

    return {
        "success": True,
        "message": summary,
        "data": {
            "total_files": len(files),
            "processed_count": processed_count,
            "failed_count": failed_count,
            "total_futures": total_futures,
            "total_options": total_options,
            "total_skipped": total_skipped_all,
            "details": results,
        },
    }


# ==================== 交易记录查询 ====================

@router.get("/records")
def get_records(
    start_date: Optional[str] = Query(None, description="开始日期 YYYY-MM-DD"),
    end_date: Optional[str] = Query(None, description="结束日期 YYYY-MM-DD"),
    symbol: Optional[str] = Query(None, description="合约代码"),
    variety: Optional[str] = Query(None, description="品种代码"),
    trade_type: Optional[str] = Query(None, description="类型: 期货/期权"),
    page: int = Query(1, ge=1),
    page_size: int = Query(50, ge=1, le=200),
    db: Session = Depends(get_analysis_db),
):
    """查询交易记录（支持筛选和分页）"""
    query = db.query(TradeRecord)

    if start_date:
        query = query.filter(TradeRecord.trade_date >= start_date)
    if end_date:
        query = query.filter(TradeRecord.trade_date <= end_date)
    if symbol:
        query = query.filter(TradeRecord.symbol == symbol)
    if variety:
        query = query.filter(TradeRecord.variety == variety)
    if trade_type:
        query = query.filter(TradeRecord.trade_type == trade_type)

    total = query.count()
    records = query.order_by(
        TradeRecord.trade_date.desc(),
        TradeRecord.trade_time.desc(),
    ).offset((page - 1) * page_size).limit(page_size).all()

    return {
        "success": True,
        "data": {
            "total": total,
            "page": page,
            "page_size": page_size,
            "records": [{
                "id": r.id,
                "trade_type": r.trade_type,
                "symbol": r.symbol,
                "variety": r.variety,
                "symbol_name": r.symbol_name,
                "direction": r.direction,
                "offset": r.offset,
                "price": r.price,
                "volume": r.volume,
                "amount": r.amount,
                "close_pnl": r.close_pnl,
                "commission": r.commission,
                "trade_date": r.trade_date,
                "trade_time": r.trade_time,
                "import_batch": r.import_batch,
                "source_file": r.source_file,
            } for r in records],
        },
    }


# ==================== 批次管理 ====================

@router.get("/batches")
def get_batches(
    db: Session = Depends(get_analysis_db),
):
    """查询导入批次列表"""
    batches = db.query(TradeImportBatch).order_by(
        TradeImportBatch.created_at.desc()
    ).all()

    return {
        "success": True,
        "data": [{
            "id": b.id,
            "batch_id": b.batch_id,
            "source_file": b.source_file,
            "futures_count": b.futures_count,
            "options_count": b.options_count,
            "trade_dates": b.trade_dates,
            "created_at": b.created_at.strftime('%Y-%m-%d %H:%M:%S') if b.created_at else '',
        } for b in batches],
    }


@router.delete("/records/{batch_id}")
def delete_batch_records(
    batch_id: str,
    db: Session = Depends(get_analysis_db),
):
    """按批次删除交易记录"""
    count = db.query(TradeRecord).filter(TradeRecord.import_batch == batch_id).count()
    if count == 0:
        raise HTTPException(status_code=404, detail="未找到该批次的交易记录")

    db.query(TradeRecord).filter(TradeRecord.import_batch == batch_id).delete()
    db.query(TradeImportBatch).filter(TradeImportBatch.batch_id == batch_id).delete()
    db.commit()

    return {"success": True, "message": f"已删除 {count} 条交易记录"}


# ==================== 汇总统计 ====================

@router.get("/latest-trade-date")
def get_latest_trade_date(
    db: Session = Depends(get_analysis_db),
):
    """获取最后一个有交易记录的交易日"""
    from datetime import date
    latest = db.query(TradeRecord.trade_date).filter(
        TradeRecord.trade_date.isnot(None),
        TradeRecord.trade_date != '',
    ).distinct().order_by(TradeRecord.trade_date.desc()).first()

    if latest:
        return {"success": True, "data": {"trade_date": latest[0]}}
    else:
        return {"success": True, "data": {"trade_date": date.today().strftime('%Y-%m-%d')}}


@router.delete("/records-by-date/{trade_date}")
def delete_records_by_date(
    trade_date: str,
    db: Session = Depends(get_analysis_db),
):
    """删除指定交易日的所有交易记录"""
    count = db.query(TradeRecord).filter(TradeRecord.trade_date == trade_date).count()
    if count == 0:
        raise HTTPException(status_code=404, detail=f"未找到 {trade_date} 的交易记录")

    db.query(TradeRecord).filter(TradeRecord.trade_date == trade_date).delete()
    db.commit()

    return {"success": True, "message": f"已删除 {trade_date} 的 {count} 条交易记录"}


@router.get("/daily-summary")
def get_daily_summary(
    start_date: Optional[str] = Query(None),
    end_date: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """获取每日交易盈亏汇总"""
    data = calc_daily_summary(db, start_date, end_date)
    return {"success": True, "data": data}


@router.get("/variety-summary")
def get_variety_summary(
    start_date: Optional[str] = Query(None),
    end_date: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """获取品种交易盈亏汇总"""
    data = calc_variety_summary(db, start_date, end_date)
    return {"success": True, "data": data}


@router.get("/statistics")
def get_statistics(
    start_date: Optional[str] = Query(None),
    end_date: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """获取整体交易统计"""
    data = calc_overall_statistics(db, start_date, end_date)
    return {"success": True, "data": data}


@router.get("/trade-pairs")
def get_trade_pairs_api(
    start_date: Optional[str] = Query(None),
    end_date: Optional[str] = Query(None),
    symbol: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """获取开平仓配对后的逐笔交易"""
    pairs = get_trade_pairs(db, start_date, end_date)
    if symbol:
        pairs = [p for p in pairs if p["symbol"] == symbol]
    return {"success": True, "data": pairs}


# ==================== K线 + 交易标记 ====================


@router.get("/kline-with-trades/{symbol}")
def get_kline_with_trades(
    symbol: str,
    period: str = Query("daily", description="K线周期: daily/60min/15min/5min"),
    start_date: Optional[str] = Query(None),
    end_date: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """获取K线数据 + 该品种的交易标记（买卖点）。symbol 可以是完整合约代码(AG2608)或品种代码(AG)"""
    import json
    import re
    from app.database import SessionLocal as MainSessionLocal
    from app.models import MarketData

    logger.info(f"[K线查询] 请求参数: symbol={symbol}, period={period}, start_date={start_date}, end_date={end_date}")

    # 判断是品种代码还是完整合约代码
    variety_code = symbol.upper()
    if re.match(r'^[A-Za-z]+\d', symbol):
        # 完整合约代码如 AG2608
        variety_code = re.match(r'^([A-Za-z]+)', symbol).group(1).upper()
        kline_symbol = symbol
    else:
        # 品种代码如 AG，从配置中查找当前合约
        kline_symbol = _resolve_symbol_from_config(variety_code)

    logger.info(f"[K线查询] 解析结果: variety_code={variety_code}, kline_symbol={kline_symbol}")

    main_db = MainSessionLocal()
    try:
        # 尝试精确匹配（先尝试原始symbol，再尝试小写）
        market_data = main_db.query(MarketData).filter(
            MarketData.symbol == kline_symbol,
            MarketData.period == period,
        ).first()

        logger.info(f"[K线查询] 精确匹配查询: symbol={kline_symbol}, period={period}, found={market_data is not None}")

        if not market_data or not market_data.candles_json:
            # 尝试小写匹配
            market_data = main_db.query(MarketData).filter(
                MarketData.symbol == kline_symbol.lower(),
                MarketData.period == period,
            ).first()
            logger.info(f"[K线查询] 小写匹配查询: symbol={kline_symbol.lower()}, period={period}, found={market_data is not None}")

        if not market_data or not market_data.candles_json:
            # 尝试模糊匹配：查找以该品种代码开头的合约（不区分大小写）
            market_data = main_db.query(MarketData).filter(
                MarketData.symbol.like(f'{variety_code}%'),
                MarketData.period == period,
            ).first()
            logger.info(f"[K线查询] 模糊匹配查询: like '{variety_code}%', period={period}, found={market_data is not None}")
            if market_data:
                logger.info(f"[K线查询] 模糊匹配找到: symbol={market_data.symbol}")

        if not market_data or not market_data.candles_json:
            # 尝试小写模糊匹配
            market_data = main_db.query(MarketData).filter(
                MarketData.symbol.like(f'{variety_code.lower()}%'),
                MarketData.period == period,
            ).first()
            logger.info(f"[K线查询] 小写模糊匹配查询: like '{variety_code.lower()}%', period={period}, found={market_data is not None}")
            if market_data:
                logger.info(f"[K线查询] 小写模糊匹配找到: symbol={market_data.symbol}")

        if not market_data or not market_data.candles_json:
            logger.warning(f"[K线查询] 未找到K线数据: {kline_symbol} {period}")
            return {"success": False, "message": f"未找到 {kline_symbol} 的 {period} K线数据"}

        candles = json.loads(market_data.candles_json)
        # 将字典格式K线转换为前端期望的数组格式 [date, open, close, low, high, volume]
        if candles and isinstance(candles[0], dict):
            # 根据周期决定是否保留时间部分
            is_daily = period == 'daily'
            candles = [
                [
                    c.get("time", "")[:10] if is_daily else c.get("time", ""),  # 日线只保留日期，分钟线保留完整时间
                    c.get("open", 0),
                    c.get("close", 0),
                    c.get("low", 0),
                    c.get("high", 0),
                    c.get("volume", 0),
                ]
                for c in candles
            ]
        kline_symbol = market_data.symbol
        logger.info(f"[K线查询] 成功获取K线数据: symbol={kline_symbol}, candles_count={len(candles)}")
    finally:
        main_db.close()

    # 获取该品种的交易记录
    logger.info(f"[K线查询] 开始查询交易记录: variety={variety_code}, start_date={start_date}, end_date={end_date}")
    query = db.query(TradeRecord).filter(TradeRecord.variety == variety_code)
    if start_date:
        query = query.filter(TradeRecord.trade_date >= start_date)
    if end_date:
        query = query.filter(TradeRecord.trade_date <= end_date)
    trades = query.order_by(TradeRecord.trade_date, TradeRecord.trade_time).all()

    logger.info(f"[K线查询] 交易记录查询完成: 找到 {len(trades)} 条记录")
    if len(trades) > 0:
        logger.info(f"[K线查询] 交易记录示例: {[{'symbol': t.symbol, 'variety': t.variety, 'date': t.trade_date, 'direction': t.direction} for t in trades[:3]]}")

    trade_markers = []
    for t in trades:
        trade_markers.append({
            "date": t.trade_date,
            "time": t.trade_time,
            "symbol": t.symbol,
            "direction": t.direction,
            "offset": t.offset,
            "price": t.price,
            "volume": t.volume,
            "close_pnl": t.close_pnl,
            "commission": t.commission,
        })

    logger.info(f"[K线查询] 返回数据: symbol={kline_symbol}, period={period}, candles={len(candles)}, markers={len(trade_markers)}")

    return {
        "success": True,
        "data": {
            "symbol": kline_symbol,
            "period": period,
            "candles": candles,
            "trade_markers": trade_markers,
        },
    }


def _resolve_symbol_from_config(variety_code: str) -> str:
    """从品种配置中查找品种代码对应的当前合约"""
    from app.config_store import get_config_store
    config = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
    for name, contract in config.get("futures", {}).items():
        if contract.upper().startswith(variety_code.upper()):
            return contract
    return variety_code


# ==================== AI 逐笔交易分析 ====================

class AnalyzeTradeRequest(BaseModel):
    symbol: str
    open_date: str
    open_time: Optional[str] = None
    close_date: Optional[str] = None
    close_time: Optional[str] = None
    direction: str  # 多/空
    open_price: Optional[float] = None
    close_price: Optional[float] = None


@router.post("/analyze-trade")
async def analyze_trade(
    req: AnalyzeTradeRequest,
    db: Session = Depends(get_analysis_db),
):
    """AI 分析单笔交易（结合多周期K线数据）"""
    # 收集多周期K线数据
    from app.database import SessionLocal as MainSessionLocal
    from app.models import MarketData
    import json

    periods = ["daily", "60min", "15min", "5min"]
    kline_context = {}

    main_db = MainSessionLocal()
    try:
        for period in periods:
            market_data = main_db.query(MarketData).filter(
                MarketData.symbol == req.symbol,
                MarketData.period == period,
            ).first()
            if market_data and market_data.candles_json:
                candles = json.loads(market_data.candles_json)
                # 将字典格式K线转换为数组格式 [date, open, close, low, high, volume]
                if candles and isinstance(candles[0], dict):
                    candles = [
                        [c.get("time", "")[:10], c.get("open", 0), c.get("close", 0),
                         c.get("low", 0), c.get("high", 0), c.get("volume", 0)]
                        for c in candles
                    ]
                kline_context[period] = candles[-50:] if len(candles) > 50 else candles
    finally:
        main_db.close()

    if not kline_context:
        return {"success": False, "message": f"未找到 {req.symbol} 的K线数据，无法分析"}

    # 构建分析提示
    prompt = f"""请分析以下期货交易交易的优缺点：

交易信息：
- 品种：{req.symbol}
- 方向：{req.direction}
- 开仓时间：{req.open_date} {req.open_time or ''}
- 开仓价格：{req.open_price or '未知'}
- 平仓时间：{req.close_date or '未知'} {req.close_time or ''}
- 平仓价格：{req.close_price or '未知'}

各周期K线数据（格式：[日期, 开盘, 收盘, 最低, 最高, 成交量]）：
"""
    for period, candles in kline_context.items():
        prompt += f"\n{period} 周期（最近{len(candles)}根K线）：\n"
        for c in candles[-10:]:
            prompt += f"  {c[0]}: 开{c[1]} 收{c[2]} 低{c[3]} 高{c[4]} 量{c[5]}\n"

    prompt += """
请从以下维度分析这笔交易：
1. 入场时机分析：入场时各周期的趋势如何，入场点是否合理
2. 出场时机分析：出场时的市场状态，是否过早/过晚出场
3. 持仓期间分析：持仓期间市场走势，是否有更好的操作机会
4. 综合评价：这笔交易的主要优点和不足之处
5. 改进建议：类似行情下如何优化操作
"""

    try:
        # 使用 AIFuturesAnalyzer 的模型配置和调用能力
        from app.services.ai_analysis import AIFuturesAnalyzer
        analyzer = AIFuturesAnalyzer(db)
        model = analyzer.get_active_model()
        if not model:
            return {"success": False, "message": "未配置AI模型或模型未激活，请先在AI配置页面设置"}

        response = analyzer.call_ai_model(prompt, model)
        if not response:
            return {"success": False, "message": "AI模型返回空响应，请稍后重试"}

        return {"success": True, "data": {"analysis": response, "symbol": req.symbol}}
    except Exception as e:
        logger.exception("AI分析交易失败")
        return {"success": False, "message": f"AI分析失败: {str(e)}"}


# ==================== 交易反思系统 API ====================

from app.analysis_models import (
    TradePair, TradeReflection, DailyReflection,
    TradeTag, TradeRecordTag, TradeExperience,
)
from pydantic import BaseModel


# --- 按天交易视图 ---

@router.get("/daily-trades/{trade_date}")
def api_get_daily_trades(
    trade_date: str,
    db: Session = Depends(get_analysis_db),
):
    """获取指定日期的交易+配对+反思状态"""
    # 先执行自动配对
    auto_pair_trades(db, trade_date)
    db.commit()

    data = get_daily_trades_with_pairs(db, trade_date)
    return {"success": True, "data": data}


# --- 手动配对 ---

class ManualPairRequest(BaseModel):
    open_record_ids: list[int]
    close_record_ids: list[int]


@router.post("/trade-pairs")
def api_create_manual_pair(
    req: ManualPairRequest,
    db: Session = Depends(get_analysis_db),
):
    """手动创建交易配对"""
    try:
        pair = create_manual_pair(db, req.open_record_ids, req.close_record_ids)
        db.commit()
        return {"success": True, "data": {"id": pair.id}}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        db.rollback()
        logger.exception("创建配对失败")
        raise HTTPException(status_code=500, detail=f"创建配对失败: {str(e)}")


@router.delete("/trade-pairs/{pair_id}")
def api_delete_pair(
    pair_id: int,
    db: Session = Depends(get_analysis_db),
):
    """删除交易配对"""
    success = delete_pair(db, pair_id)
    if not success:
        raise HTTPException(status_code=404, detail="配对不存在")
    db.commit()
    return {"success": True, "message": "配对已删除"}


# --- 反思 CRUD ---

class ReflectionRequest(BaseModel):
    trade_pair_id: int
    trade_date: str
    entry_reason: Optional[str] = None
    entry_timing: Optional[str] = None
    position_management: Optional[str] = None
    exit_reason: Optional[str] = None
    exit_timing: Optional[str] = None
    discipline_score: Optional[int] = None
    free_reflection: Optional[str] = None


@router.post("/reflections")
def api_create_reflection(
    req: ReflectionRequest,
    db: Session = Depends(get_analysis_db),
):
    """创建交易反思"""
    # 检查是否已存在
    existing = db.query(TradeReflection).filter(
        TradeReflection.trade_pair_id == req.trade_pair_id
    ).first()
    if existing:
        raise HTTPException(status_code=400, detail="该交易已有反思，请使用更新接口")

    reflection = TradeReflection(
        trade_pair_id=req.trade_pair_id,
        trade_date=req.trade_date,
        entry_reason=req.entry_reason,
        entry_timing=req.entry_timing,
        position_management=req.position_management,
        exit_reason=req.exit_reason,
        exit_timing=req.exit_timing,
        discipline_score=req.discipline_score,
        free_reflection=req.free_reflection,
    )
    db.add(reflection)
    db.commit()
    return {"success": True, "data": {"id": reflection.id}}


@router.put("/reflections/{reflection_id}")
def api_update_reflection(
    reflection_id: int,
    req: ReflectionRequest,
    db: Session = Depends(get_analysis_db),
):
    """更新交易反思"""
    reflection = db.query(TradeReflection).filter(TradeReflection.id == reflection_id).first()
    if not reflection:
        raise HTTPException(status_code=404, detail="反思不存在")

    # 更新字段
    for field in ['entry_reason', 'entry_timing', 'position_management',
                  'exit_reason', 'exit_timing', 'discipline_score', 'free_reflection']:
        val = getattr(req, field)
        if val is not None:
            setattr(reflection, field, val)

    # 重新保存时重置 AI 分析状态（因为内容变了）
    reflection.ai_analyzed = False
    reflection.ai_version = None

    db.commit()
    return {"success": True, "message": "反思已更新"}


@router.get("/reflections")
def api_get_reflections(
    trade_pair_id: Optional[int] = Query(None),
    trade_date: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """查询反思列表"""
    query = db.query(TradeReflection)
    if trade_pair_id:
        query = query.filter(TradeReflection.trade_pair_id == trade_pair_id)
    if trade_date:
        query = query.filter(TradeReflection.trade_date == trade_date)

    reflections = query.order_by(TradeReflection.created_at.desc()).all()
    return {"success": True, "data": [{
        "id": r.id,
        "trade_pair_id": r.trade_pair_id,
        "trade_date": r.trade_date,
        "entry_reason": r.entry_reason,
        "entry_timing": r.entry_timing,
        "position_management": r.position_management,
        "exit_reason": r.exit_reason,
        "exit_timing": r.exit_timing,
        "discipline_score": r.discipline_score,
        "free_reflection": r.free_reflection,
        "ai_analyzed": r.ai_analyzed,
        "ai_version": r.ai_version,
        "created_at": r.created_at.strftime('%Y-%m-%d %H:%M:%S') if r.created_at else None,
        "updated_at": r.updated_at.strftime('%Y-%m-%d %H:%M:%S') if r.updated_at else None,
    } for r in reflections]}


# --- 当日反思 CRUD ---

class DailyReflectionRequest(BaseModel):
    reflection_date: str
    emotion_state: Optional[str] = None
    market_judgment: Optional[str] = None
    discipline_score: Optional[int] = None
    overall_rating: Optional[int] = None
    summary: Optional[str] = None
    improvements: Optional[str] = None


@router.post("/daily-reflections")
def api_create_daily_reflection(
    req: DailyReflectionRequest,
    db: Session = Depends(get_analysis_db),
):
    """创建或更新当日反思"""
    existing = db.query(DailyReflection).filter(
        DailyReflection.reflection_date == req.reflection_date
    ).first()

    if existing:
        # 更新
        for field in ['emotion_state', 'market_judgment', 'discipline_score',
                      'overall_rating', 'summary', 'improvements']:
            val = getattr(req, field)
            if val is not None:
                setattr(existing, field, val)
        db.commit()
        return {"success": True, "data": {"id": existing.id, "action": "updated"}}
    else:
        # 创建
        dr = DailyReflection(
            reflection_date=req.reflection_date,
            emotion_state=req.emotion_state,
            market_judgment=req.market_judgment,
            discipline_score=req.discipline_score,
            overall_rating=req.overall_rating,
            summary=req.summary,
            improvements=req.improvements,
        )
        db.add(dr)
        db.commit()
        return {"success": True, "data": {"id": dr.id, "action": "created"}}


@router.get("/daily-reflections/{reflection_date}")
def api_get_daily_reflection(
    reflection_date: str,
    db: Session = Depends(get_analysis_db),
):
    """获取当日反思"""
    dr = db.query(DailyReflection).filter(
        DailyReflection.reflection_date == reflection_date
    ).first()

    if not dr:
        return {"success": True, "data": None}

    return {"success": True, "data": {
        "id": dr.id,
        "reflection_date": dr.reflection_date,
        "emotion_state": dr.emotion_state,
        "market_judgment": dr.market_judgment,
        "discipline_score": dr.discipline_score,
        "overall_rating": dr.overall_rating,
        "summary": dr.summary,
        "improvements": dr.improvements,
    }}


# --- 标签系统 ---

class TagRequest(BaseModel):
    name: str
    category: str = "custom"


@router.get("/tags")
def api_get_tags(
    category: Optional[str] = Query(None),
    db: Session = Depends(get_analysis_db),
):
    """获取所有标签"""
    query = db.query(TradeTag)
    if category:
        query = query.filter(TradeTag.category == category)

    tags = query.order_by(TradeTag.is_preset.desc(), TradeTag.name).all()
    return {"success": True, "data": [{
        "id": t.id,
        "name": t.name,
        "category": t.category,
        "is_preset": t.is_preset,
    } for t in tags]}


@router.post("/tags")
def api_create_tag(
    req: TagRequest,
    db: Session = Depends(get_analysis_db),
):
    """创建自定义标签（含去重）"""
    existing = db.query(TradeTag).filter(TradeTag.name == req.name).first()
    if existing:
        return {"success": True, "data": {"id": existing.id, "action": "exists"}}

    tag = TradeTag(name=req.name, category=req.category, is_preset=False)
    db.add(tag)
    db.commit()
    return {"success": True, "data": {"id": tag.id, "action": "created"}}


@router.post("/trade-pairs/{pair_id}/tags")
def api_add_tag_to_trade(
    pair_id: int,
    tag_id: int,
    db: Session = Depends(get_analysis_db),
):
    """给交易打标签"""
    # 检查是否已存在
    existing = db.query(TradeRecordTag).filter(
        TradeRecordTag.trade_pair_id == pair_id,
        TradeRecordTag.tag_id == tag_id,
    ).first()
    if existing:
        return {"success": True, "message": "标签已存在"}

    relation = TradeRecordTag(trade_pair_id=pair_id, tag_id=tag_id)
    db.add(relation)
    db.commit()
    return {"success": True, "message": "标签已添加"}


@router.delete("/trade-pairs/{pair_id}/tags/{tag_id}")
def api_remove_tag_from_trade(
    pair_id: int,
    tag_id: int,
    db: Session = Depends(get_analysis_db),
):
    """移除交易标签"""
    db.query(TradeRecordTag).filter(
        TradeRecordTag.trade_pair_id == pair_id,
        TradeRecordTag.tag_id == tag_id,
    ).delete()
    db.commit()
    return {"success": True, "message": "标签已移除"}


@router.get("/trade-pairs/{pair_id}/tags")
def api_get_trade_tags(
    pair_id: int,
    db: Session = Depends(get_analysis_db),
):
    """获取交易的标签列表"""
    relations = db.query(TradeRecordTag).filter(
        TradeRecordTag.trade_pair_id == pair_id
    ).all()

    tag_ids = [r.tag_id for r in relations]
    tags = db.query(TradeTag).filter(TradeTag.id.in_(tag_ids)).all()

    return {"success": True, "data": [{
        "id": t.id,
        "name": t.name,
        "category": t.category,
    } for t in tags]}


# --- 经验库 ---

class ExperienceRequest(BaseModel):
    title: str
    content: str
    exp_type: str  # lesson/tip/warning
    source_pair_id: Optional[int] = None
    source_date: Optional[str] = None
    tags: Optional[list[str]] = None


@router.get("/experiences")
def api_get_experiences(
    exp_type: Optional[str] = Query(None),
    tag: Optional[str] = Query(None),
    keyword: Optional[str] = Query(None),
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_analysis_db),
):
    """获取经验列表（支持筛选和分页）"""
    query = db.query(TradeExperience)
    if exp_type:
        query = query.filter(TradeExperience.exp_type == exp_type)
    if tag:
        query = query.filter(TradeExperience.tags.contains([tag]))
    if keyword:
        query = query.filter(
            (TradeExperience.title.contains(keyword)) |
            (TradeExperience.content.contains(keyword))
        )

    total = query.count()
    experiences = query.order_by(
        TradeExperience.created_at.desc()
    ).offset((page - 1) * page_size).limit(page_size).all()

    return {"success": True, "data": {
        "total": total,
        "page": page,
        "page_size": page_size,
        "items": [{
            "id": e.id,
            "title": e.title,
            "content": e.content,
            "exp_type": e.exp_type,
            "source_pair_id": e.source_pair_id,
            "source_date": e.source_date,
            "tags": e.tags or [],
            "created_at": e.created_at.strftime('%Y-%m-%d %H:%M:%S') if e.created_at else None,
        } for e in experiences],
    }}


@router.post("/experiences")
def api_create_experience(
    req: ExperienceRequest,
    db: Session = Depends(get_analysis_db),
):
    """创建经验"""
    exp = TradeExperience(
        title=req.title,
        content=req.content,
        exp_type=req.exp_type,
        source_pair_id=req.source_pair_id,
        source_date=req.source_date,
        tags=req.tags or [],
    )
    db.add(exp)
    db.commit()
    return {"success": True, "data": {"id": exp.id}}


@router.put("/experiences/{exp_id}")
def api_update_experience(
    exp_id: int,
    req: ExperienceRequest,
    db: Session = Depends(get_analysis_db),
):
    """更新经验"""
    exp = db.query(TradeExperience).filter(TradeExperience.id == exp_id).first()
    if not exp:
        raise HTTPException(status_code=404, detail="经验不存在")

    for field in ['title', 'content', 'exp_type', 'source_pair_id', 'source_date', 'tags']:
        val = getattr(req, field)
        if val is not None:
            setattr(exp, field, val)

    db.commit()
    return {"success": True, "message": "经验已更新"}


@router.delete("/experiences/{exp_id}")
def api_delete_experience(
    exp_id: int,
    db: Session = Depends(get_analysis_db),
):
    """删除经验"""
    exp = db.query(TradeExperience).filter(TradeExperience.id == exp_id).first()
    if not exp:
        raise HTTPException(status_code=404, detail="经验不存在")

    db.delete(exp)
    db.commit()
    return {"success": True, "message": "经验已删除"}


@router.get("/experiences/tag-stats")
def api_get_experience_tag_stats(
    db: Session = Depends(get_analysis_db),
):
    """按标签统计经验数量"""
    from collections import Counter

    experiences = db.query(TradeExperience).all()
    tag_counter = Counter()
    for exp in experiences:
        for tag in (exp.tags or []):
            tag_counter[tag] += 1

    # 同时返回所有标签的定义信息
    tags = db.query(TradeTag).all()
    tag_map = {t.name: {"id": t.id, "category": t.category, "is_preset": t.is_preset} for t in tags}

    data = []
    for name, count in tag_counter.most_common():
        info = tag_map.get(name, {})
        data.append({
            "name": name,
            "count": count,
            "tag_id": info.get("id"),
            "category": info.get("category", "custom"),
            "is_preset": info.get("is_preset", False),
        })

    return {"success": True, "data": data}


# ==================== AI 重新分析 ====================

class ReanalyzeRequest(BaseModel):
    trade_pair_id: int


@router.post("/reanalyze")
async def api_reanalyze_trade(
    req: ReanalyzeRequest,
    db: Session = Depends(get_analysis_db),
):
    """基于反思内容重新 AI 分析交易"""
    result = analyze_with_reflection(db, req.trade_pair_id)
    if not result.get("success"):
        raise HTTPException(status_code=400, detail=result.get("message", "分析失败"))
    return result


@router.get("/reanalyze/{trade_pair_id}/history")
def api_get_analysis_history(
    trade_pair_id: int,
    db: Session = Depends(get_analysis_db),
):
    """获取交易的 AI 分析历史版本"""
    history = get_analysis_history(db, trade_pair_id)
    return {"success": True, "data": history}


@router.get("/reanalyze/{trade_pair_id}/latest")
def api_get_latest_analysis(
    trade_pair_id: int,
    db: Session = Depends(get_analysis_db),
):
    """获取交易最新 AI 分析结果"""
    analysis = get_latest_analysis(db, trade_pair_id)
    return {"success": True, "data": analysis}


class SaveSuggestionRequest(BaseModel):
    title: Optional[str] = None
    content: Optional[str] = None
    tags: Optional[list[str]] = None


@router.post("/ai-analysis/{analysis_id}/save-experience")
def api_save_suggestion_as_experience(
    analysis_id: int,
    req: SaveSuggestionRequest,
    db: Session = Depends(get_analysis_db),
):
    """将 AI 分析建议保存到经验库"""
    result = save_suggestion_as_experience(
        db, analysis_id,
        title=req.title,
        content=req.content,
        tags=req.tags,
    )
    if not result.get("success"):
        raise HTTPException(status_code=400, detail=result.get("message", "保存失败"))
    return result