"""
Data models for Statistics Service
"""
from pydantic import BaseModel, Field
from datetime import datetime
from typing import Optional, List, Dict, Any, Literal
from enum import Enum

class MetricType(str, Enum):
    """Types of metrics"""
    COUNTER = "counter"
    GAUGE = "gauge"
    HISTOGRAM = "histogram"
    SUMMARY = "summary"

class AggregationType(str, Enum):
    """Types of aggregation"""
    AVG = "avg"
    SUM = "sum"
    MIN = "min"
    MAX = "max"
    COUNT = "count"
    PERCENTILE = "percentile"

class Granularity(str, Enum):
    """Time granularity for aggregation"""
    MINUTE = "minute"
    HOUR = "hour"
    DAY = "day"
    WEEK = "week"
    MONTH = "month"

class Metric(BaseModel):
    """Single metric data point"""
    id: Optional[str] = Field(None, description="Unique metric ID")
    name: str = Field(..., description="Metric name")
    type: MetricType = Field(..., description="Metric type")
    value: float = Field(..., description="Metric value")
    tags: Dict[str, str] = Field(default_factory=dict, description="Metric tags")
    timestamp: datetime = Field(default_factory=datetime.now, description="Metric timestamp")
    service: str = Field(..., description="Source service")
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.isoformat()
        }

class AggregatedMetric(BaseModel):
    """Aggregated metric result"""
    metric_name: str
    aggregation_type: AggregationType
    value: float
    start_time: datetime
    end_time: datetime
    granularity: Optional[Granularity] = None
    group_by: Optional[str] = None
    count: int = Field(..., description="Number of data points aggregated")
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.isoformat()
        }

class TimeSeriesData(BaseModel):
    """Time series data response"""
    metric_name: str
    start_time: datetime
    end_time: datetime
    interval: str
    data: List[Dict[str, Any]]
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.isoformat()
        }

class DashboardConfig(BaseModel):
    """Dashboard configuration"""
    id: str
    name: str
    description: Optional[str] = None
    widgets: List[Dict[str, Any]]
    refresh_interval: int = Field(60, description="Refresh interval in seconds")
    created_at: datetime = Field(default_factory=datetime.now)
    updated_at: datetime = Field(default_factory=datetime.now)
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.isoformat()
        }

class AlertRule(BaseModel):
    """Alert rule configuration"""
    id: Optional[str] = None
    name: str
    metric_name: str
    condition: Literal["gt", "lt", "gte", "lte", "eq", "neq"]
    threshold: float
    duration: int = Field(..., description="Duration in seconds")
    severity: Literal["low", "medium", "high", "critical"]
    enabled: bool = True
    notification_channels: List[str] = Field(default_factory=list)
    created_at: datetime = Field(default_factory=datetime.now)
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.isoformat()
        }

class Alert(BaseModel):
    """Active alert"""
    id: str
    rule_id: str
    rule_name: str
    metric_name: str
    current_value: float
    threshold: float
    severity: str
    triggered_at: datetime
    resolved_at: Optional[datetime] = None
    status: Literal["active", "resolved", "acknowledged"]
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.isoformat()
        }

class UserAnalytics(BaseModel):
    """User analytics data"""
    total_users: int
    active_users: int
    new_users: int
    user_growth_rate: float
    average_session_duration: float
    top_actions: List[Dict[str, Any]]
    user_distribution: Dict[str, int]
    period: str
    
class SystemAnalytics(BaseModel):
    """System performance analytics"""
    uptime_percentage: float
    average_response_time: float
    error_rate: float
    throughput: float
    cpu_usage: float
    memory_usage: float
    disk_usage: float
    active_connections: int
    services_health: Dict[str, str]
    
class EventAnalytics(BaseModel):
    """Event analytics data"""
    total_events: int
    events_per_second: float
    event_types: Dict[str, int]
    top_events: List[Dict[str, Any]]
    error_events: int
    success_rate: float
    processing_time: Dict[str, float]