auto-stock/backend/app/api/endpoints/trades.py

"""
주문/체결 API 엔드포인트

- GET /: 거래 이력 조회 (손익 포함)
- GET /stats/summary: 거래 통계
- DELETE /pending: PENDING/FAILED 거래 정리
"""
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from typing import List, Optional
from datetime import datetime, timedelta
from decimal import Decimal
import logging
import re

from app.core.database import get_db
from app.models.models import TradeHistory
from pydantic import BaseModel
from app.core.timeutil import now_kst

router = APIRouter()
logger = logging.getLogger(__name__)


class TradeHistoryResponse(BaseModel):
    id: int
    rule_id: Optional[int]
    stock_code: str
    stock_name: Optional[str]
    order_type: str
    order_price: Optional[Decimal]
    order_quantity: int
    executed_price: Optional[Decimal]
    executed_quantity: Optional[int]
    total_amount: Optional[Decimal]
    status: str
    order_id: Optional[str]
    message: Optional[str]
    entry_reason: Optional[str]
    exit_reason: Optional[str]
    signals: Optional[List[str]]
    created_at: datetime
    executed_at: Optional[datetime]
    profit_loss: Optional[Decimal] = None
    profit_loss_rate: Optional[float] = None
    
    class Config:
        from_attributes = True


@router.get("", response_model=List[TradeHistoryResponse])
async def get_trade_history(
    skip: int = 0,
    limit: int = 100,
    stock_code: Optional[str] = None,
    status: Optional[str] = None,
    order_type: Optional[str] = None,
    days: int = 30,
    db: AsyncSession = Depends(get_db)
):
    """거래 이력 조회 (손익 포함)"""
    query = select(TradeHistory)
    
    # 날짜 필터
    since_date = now_kst() - timedelta(days=days)
    query = query.where(TradeHistory.created_at >= since_date)
    
    # 종목 코드 필터
    if stock_code:
        query = query.where(TradeHistory.stock_code == stock_code)
    
    # 상태 필터
    if status:
        query = query.where(TradeHistory.status == status)
    
    # 주문 유형 필터
    if order_type:
        query = query.where(TradeHistory.order_type == order_type)
    
    query = query.order_by(TradeHistory.created_at.desc())
    query = query.offset(skip).limit(limit)
    
    result = await db.execute(query)
    trades = result.scalars().all()
    
    # 손익 계산을 위해 매수/매도 매칭
    trade_responses = []
    buy_trades = {}  # stock_code -> list of buy trades
    
    for trade in trades:
        response = TradeHistoryResponse.model_validate(trade)

        # 매도 시 손익 정보 설정
        if trade.order_type == "SELL" and trade.status in ("EXECUTED", "COMPLETED"):
            # 1. DB에 저장된 값 먼저 사용
            if hasattr(trade, 'net_profit_loss') and trade.net_profit_loss is not None:
                response.profit_loss = trade.net_profit_loss
                logger.debug(f"✅ DB에서 손익 금액 로드: {response.profit_loss}")

            if hasattr(trade, 'profit_loss_rate') and trade.profit_loss_rate is not None:
                response.profit_loss_rate = float(trade.profit_loss_rate)
                logger.debug(f"✅ DB에서 손익률 로드: {response.profit_loss_rate}%")

            # 2. DB 값이 없으면 exit_reason/message에서 파싱 (이전 데이터 호환성)
            if response.profit_loss is None or response.profit_loss_rate is None:
                text_to_parse = trade.exit_reason or trade.message or ""
                logger.debug(f"🔍 손익 파싱 시도 - 종목: {trade.stock_name}, 텍스트: {text_to_parse[:100]}")

                # 손익 금액 추출
                if response.profit_loss is None:
                    profit_match = re.search(r'손익:\s*([+-]?[\d,]+)원', text_to_parse)
                    if profit_match:
                        profit_str = profit_match.group(1).replace(',', '')
                        try:
                            response.profit_loss = Decimal(profit_str)
                            logger.info(f"✅ 파싱으로 손익 금액 추출: {response.profit_loss}")
                        except Exception as e:
                            logger.error(f"❌ 손익 금액 변환 실패: {e}")

                # 손익률 추출
                if response.profit_loss_rate is None:
                    message_rate_match = re.search(r'손익률\s*([+-]?[\d.]+)%', trade.message or "")
                    if message_rate_match:
                        try:
                            response.profit_loss_rate = float(message_rate_match.group(1))
                            logger.info(f"✅ 파싱으로 손익률 추출 (message): {response.profit_loss_rate}%")
                        except Exception as e:
                            logger.error(f"❌ 손익률 변환 실패: {e}")
                    else:
                        rate_match = re.search(r'([+-]?[\d.]+)%', text_to_parse)
                        if rate_match:
                            try:
                                response.profit_loss_rate = float(rate_match.group(1))
                                logger.info(f"✅ 파싱으로 손익률 추출 (exit_reason): {response.profit_loss_rate}%")
                            except Exception as e:
                                logger.error(f"❌ 손익률 변환 실패: {e}")
        
        trade_responses.append(response)
    
    return trade_responses


@router.get("/{trade_id}", response_model=TradeHistoryResponse)
async def get_trade(trade_id: int, db: AsyncSession = Depends(get_db)):
    """특정 거래 조회"""
    result = await db.execute(select(TradeHistory).where(TradeHistory.id == trade_id))
    trade = result.scalar_one_or_none()
    
    if not trade:
        raise HTTPException(status_code=404, detail="Trade not found")
    
    return trade


@router.get("/stats/summary")
async def get_trade_stats(
    days: int = 30,
    db: AsyncSession = Depends(get_db)
):
    """거래 통계 조회"""
    since_date = now_kst() - timedelta(days=days)
    
    result = await db.execute(
        select(TradeHistory).where(TradeHistory.created_at >= since_date)
    )
    trades = result.scalars().all()
    
    total_trades = len(trades)
    buy_trades = len([t for t in trades if t.order_type == "BUY"])
    sell_trades = len([t for t in trades if t.order_type == "SELL"])
    executed_trades = len([t for t in trades if t.status in ("EXECUTED", "COMPLETED")])
    failed_trades = len([t for t in trades if t.status == "FAILED"])

    # 총 거래 금액 계산
    total_amount = sum(
        float(t.executed_price or 0) * (t.executed_quantity or 0)
        for t in trades if t.status in ("EXECUTED", "COMPLETED")
    )
    
    return {
        "period_days": days,
        "total_trades": total_trades,
        "buy_trades": buy_trades,
        "sell_trades": sell_trades,
        "executed_trades": executed_trades,
        "failed_trades": failed_trades,
        "success_rate": executed_trades / total_trades if total_trades > 0 else 0,
        "total_amount": total_amount
    }


@router.delete("/pending")
async def delete_pending_trades(db: AsyncSession = Depends(get_db)):
    """장 마감 후 PENDING과 FAILED 상태의 매수 시도 내역 정리"""
    result = await db.execute(
        select(TradeHistory).where(
            TradeHistory.status.in_(['PENDING', 'FAILED'])
        )
    )
    pending_trades = result.scalars().all()
    count = len(pending_trades)
    
    for trade in pending_trades:
        await db.delete(trade)
    await db.commit()
    
    logger.info(f"✅ 정리 완료: {count}개의 PENDING/FAILED 매수 시도 삭제")
    
    return {"deleted_count": count, "message": f"Cleaned up {count} pending/failed trades"}