from datetime import datetime
from typing import Optional, List, Dict, Any
from pydantic import BaseModel, Field
from app.models.enums import (
    RegionEnum,
    StrategyEnum,
    TradeTypeEnum,
    BacktestStatusEnum,
    ModelType,
    AlertTypeEnum,
    TrainingStatusEnum,
)


class PriceData(BaseModel):
    timestamp: datetime
    region: RegionEnum
    day_ahead_price: float
    real_time_price: float
    volume_mw: float


class BatteryState(BaseModel):
    timestamp: datetime
    battery_id: str
    capacity_mwh: float
    charge_level_mwh: float
    charge_rate_mw: float
    discharge_rate_mw: float
    efficiency: float
    charge_level_pct: float = Field(default_factory=lambda: 0.0)


class BacktestConfig(BaseModel):
    start_date: str
    end_date: str
    strategies: List[StrategyEnum] = Field(default_factory=list)
    use_ml: bool = True
    battery_min_reserve: Optional[float] = None
    battery_max_charge: Optional[float] = None
    arbitrage_min_spread: Optional[float] = None


class BacktestMetrics(BaseModel):
    total_revenue: float
    arbitrage_profit: float
    battery_revenue: float
    mining_profit: float
    battery_utilization: float
    price_capture_rate: float
    win_rate: float
    sharpe_ratio: float
    max_drawdown: float
    total_trades: int


class TrainingRequest(BaseModel):
    model_type: ModelType
    horizon: Optional[int] = None
    start_date: str
    end_date: str
    hyperparameters: Dict[str, Any] = Field(default_factory=dict)


class PredictionResponse(BaseModel):
    model_id: str
    timestamp: datetime
    prediction: float
    confidence: Optional[float] = None
    features_used: List[str] = Field(default_factory=list)


class ModelInfo(BaseModel):
    model_id: str
    model_type: ModelType
    version: str
    created_at: datetime
    metrics: Dict[str, float] = Field(default_factory=dict)
    hyperparameters: Dict[str, Any] = Field(default_factory=dict)


class TrainingStatus(BaseModel):
    training_id: str
    status: TrainingStatusEnum
    progress: float = 0.0
    current_epoch: Optional[int] = None
    total_epochs: Optional[int] = None
    metrics: Dict[str, float] = Field(default_factory=dict)
    error_message: Optional[str] = None
    started_at: Optional[datetime] = None
    completed_at: Optional[datetime] = None


class ArbitrageOpportunity(BaseModel):
    timestamp: datetime
    buy_region: RegionEnum
    sell_region: RegionEnum
    buy_price: float
    sell_price: float
    spread: float
    volume_mw: float


class DashboardSummary(BaseModel):
    latest_timestamp: datetime
    total_volume_mw: float
    avg_realtime_price: float
    arbitrage_count: int
    battery_count: int
    avg_battery_charge: float


class Trade(BaseModel):
    timestamp: datetime
    backtest_id: str
    trade_type: TradeTypeEnum
    region: Optional[RegionEnum] = None
    price: float
    volume_mw: float
    revenue: float
    battery_id: Optional[str] = None


class StrategyStatus(BaseModel):
    strategy: StrategyEnum
    enabled: bool
    last_execution: Optional[datetime] = None
    total_trades: int = 0
    profit_loss: float = 0.0


class Alert(BaseModel):
    alert_id: str
    alert_type: AlertTypeEnum
    timestamp: datetime
    message: str
    data: Dict[str, Any] = Field(default_factory=dict)
    acknowledged: bool = False


class AppSettings(BaseModel):
    battery_min_reserve: float
    battery_max_charge: float
    arbitrage_min_spread: float
    mining_margin_threshold: float