from typing import Dict, List, Optional
from datetime import datetime
from app.utils.logger import get_logger

logger = get_logger(__name__)


class TradingPosition:
    timestamp: datetime
    position_type: str
    region: Optional[str]
    volume_mw: float
    entry_price: float
    current_price: float
    pnl: float


class TradingService:
    def __init__(self):
        self._positions: List[Dict] = []
        self._orders: List[Dict] = []

    async def get_positions(self) -> List[Dict]:
        return self._positions.copy()

    async def get_orders(self, limit: int = 100) -> List[Dict]:
        return self._orders[-limit:]

    async def place_order(self, order: Dict) -> Dict:
        order_id = f"order_{len(self._orders) + 1}"
        order["order_id"] = order_id
        order["timestamp"] = datetime.utcnow()
        order["status"] = "filled"

        self._orders.append(order)

        logger.info(f"Order placed: {order_id}, type: {order.get('type')}, volume: {order.get('volume_mw')}")

        return order

    async def close_position(self, position_id: str) -> Dict:
        for i, pos in enumerate(self._positions):
            if pos.get("position_id") == position_id:
                position = self._positions.pop(i)
                position["closed_at"] = datetime.utcnow()
                position["status"] = "closed"
                logger.info(f"Position closed: {position_id}")
                return position

        raise ValueError(f"Position not found: {position_id}")

    async def get_trading_summary(self) -> Dict:
        total_pnl = sum(pos.get("pnl", 0) for pos in self._positions)
        open_positions = len([p for p in self._positions if p.get("status") == "open"])

        return {
            "total_pnl": total_pnl,
            "open_positions": open_positions,
            "total_trades": len(self._orders),
            "last_trade": self._orders[-1]["timestamp"] if self._orders else None,
        }