"""
=========================================
CV6 AI Trading OS
Trade History Router
GET  /history
GET  /history/{id}
POST /history
PATCH /history/{id}
GET  /history/pnl
GET  /history/export
=========================================
"""

from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.responses import PlainTextResponse
from sqlalchemy.orm import Session

from app.database.session import get_db
from app.history.history_schemas import (
    TradeCreate, TradeUpdate, TradeOut, TradeListResponse, PnLSummary,
)
from app.history.history_service import history_service

router = APIRouter(
    prefix="/history",
    tags=["Trade History"],
)


@router.get(
    "/",
    response_model=TradeListResponse,
    summary="List trade history with filters",
)
def list_trades(
    status:  Optional[str]   = Query(None, example="EXECUTED",
                                     description="EXECUTED | CANCELLED | REJECTED | PENDING"),
    symbol:  Optional[str]   = Query(None, example="NIFTY"),
    broker:  Optional[str]   = Query(None, example="angelone"),
    from_ts: Optional[float] = Query(None, description="Unix timestamp from"),
    to_ts:   Optional[float] = Query(None, description="Unix timestamp to"),
    limit:   int             = Query(100, le=1000),
    offset:  int             = Query(0),
    db:      Session         = Depends(get_db),
):
    trades = history_service.get_all(
        db, status=status, symbol=symbol, broker=broker,
        from_ts=from_ts, to_ts=to_ts, limit=limit, offset=offset,
    )
    return TradeListResponse(
        total=history_service.count(db, status=status),
        limit=limit, offset=offset,
        trades=[TradeOut.model_validate(t) for t in trades],
    )


@router.get("/executed", response_model=TradeListResponse, summary="Executed orders")
def executed(limit: int = Query(100), db: Session = Depends(get_db)):
    trades = history_service.get_all(db, status="EXECUTED", limit=limit)
    return TradeListResponse(
        total=len(trades), limit=limit, offset=0,
        trades=[TradeOut.model_validate(t) for t in trades],
    )


@router.get("/cancelled", response_model=TradeListResponse, summary="Cancelled orders")
def cancelled(limit: int = Query(100), db: Session = Depends(get_db)):
    trades = history_service.get_all(db, status="CANCELLED", limit=limit)
    return TradeListResponse(
        total=len(trades), limit=limit, offset=0,
        trades=[TradeOut.model_validate(t) for t in trades],
    )


@router.get("/rejected", response_model=TradeListResponse, summary="Rejected orders")
def rejected(limit: int = Query(100), db: Session = Depends(get_db)):
    trades = history_service.get_all(db, status="REJECTED", limit=limit)
    return TradeListResponse(
        total=len(trades), limit=limit, offset=0,
        trades=[TradeOut.model_validate(t) for t in trades],
    )


@router.get(
    "/pnl",
    response_model=PnLSummary,
    summary="PnL summary — net PnL, win rate, charges",
)
def pnl_summary(
    symbol:  Optional[str]   = Query(None),
    broker:  Optional[str]   = Query(None),
    from_ts: Optional[float] = Query(None),
    to_ts:   Optional[float] = Query(None),
    db:      Session         = Depends(get_db),
):
    return history_service.pnl_summary(
        db, symbol=symbol, broker=broker, from_ts=from_ts, to_ts=to_ts,
    )


@router.get(
    "/export",
    summary="Export trade history as CSV",
)
def export_csv(
    status:  Optional[str]   = Query(None),
    symbol:  Optional[str]   = Query(None),
    from_ts: Optional[float] = Query(None),
    to_ts:   Optional[float] = Query(None),
    db:      Session         = Depends(get_db),
):
    csv_data = history_service.export_csv(
        db, status=status, symbol=symbol, from_ts=from_ts, to_ts=to_ts,
    )
    if not csv_data:
        raise HTTPException(404, "No trades found")
    return PlainTextResponse(
        content=csv_data,
        media_type="text/csv",
        headers={"Content-Disposition": "attachment; filename=trade_history.csv"},
    )


@router.get(
    "/{trade_id}",
    response_model=TradeOut,
    summary="Get single trade by ID",
)
def get_trade(trade_id: int, db: Session = Depends(get_db)):
    record = history_service.get_by_id(db, trade_id)
    if not record:
        raise HTTPException(404, f"Trade {trade_id} not found")
    return TradeOut.model_validate(record)


@router.post(
    "/",
    response_model=TradeOut,
    status_code=201,
    summary="Record a new trade",
)
def create_trade(data: TradeCreate, db: Session = Depends(get_db)):
    record = history_service.create(db, data)
    return TradeOut.model_validate(record)


@router.patch(
    "/{trade_id}",
    response_model=TradeOut,
    summary="Update trade status / PnL / charges",
)
def update_trade(trade_id: int, data: TradeUpdate, db: Session = Depends(get_db)):
    record = history_service.update(db, trade_id, data)
    if not record:
        raise HTTPException(404, f"Trade {trade_id} not found")
    return TradeOut.model_validate(record)


@router.delete(
    "/clear",
    summary="Clear all trade history (removes test/fake trades)",
)
def clear_history(db: Session = Depends(get_db)):
    count = history_service.clear_all(db)
    return {"success": True, "deleted": count, "message": f"Cleared {count} trade history records"}