from pydantic import BaseModel, Field
from typing import Optional, List, Dict, Any, Union
from datetime import datetime
from enum import Enum

class ResponseStatus(str, Enum):
    """Enumeration for API response statuses"""
    SUCCESS = "success"
    ERROR = "error"
    FAIL = "fail"

class PaginationMeta(BaseModel):
    """Schema for pagination metadata"""
    current_page: int = Field(..., description="Current page number")
    per_page: int = Field(..., description="Items per page")
    total: int = Field(..., description="Total number of items")
    total_pages: int = Field(..., description="Total number of pages")
    has_next: bool = Field(..., description="Whether there is a next page")
    has_prev: bool = Field(..., description="Whether there is a previous page")
    next_page: Optional[int] = Field(None, description="Next page number")
    prev_page: Optional[int] = Field(None, description="Previous page number")

class BaseResponse(BaseModel):
    """Base response schema for all API responses"""
    status: ResponseStatus = Field(..., description="Response status")
    message: str = Field(..., description="Response message")
    timestamp: datetime = Field(default_factory=datetime.utcnow, description="Response timestamp")
    request_id: Optional[str] = Field(None, description="Unique request identifier")

class SuccessResponse(BaseResponse):
    """Schema for successful API responses"""
    status: ResponseStatus = Field(default=ResponseStatus.SUCCESS)
    data: Optional[Any] = Field(None, description="Response data")
    meta: Optional[Dict[str, Any]] = Field(None, description="Additional metadata")

class PaginatedResponse(SuccessResponse):
    """Schema for paginated API responses"""
    data: List[Any] = Field(default_factory=list, description="Paginated data items")
    pagination: PaginationMeta = Field(..., description="Pagination metadata")

class ErrorResponse(BaseResponse):
    """Schema for error API responses"""
    status: ResponseStatus = Field(default=ResponseStatus.ERROR)
    error_code: Optional[str] = Field(None, description="Specific error code")
    error_details: Optional[Dict[str, Any]] = Field(None, description="Detailed error information")

class ValidationErrorResponse(BaseResponse):
    """Schema for validation error responses"""
    status: ResponseStatus = Field(default=ResponseStatus.FAIL)
    errors: Dict[str, List[str]] = Field(..., description="Field validation errors")

# Specific response schemas for OTT reporting endpoints

class ActiveUsersResponse(BaseModel):
    """Schema for active users count response"""
    studio_id: int = Field(..., description="Studio ID")
    active_users_count: int = Field(..., description="Number of active users")
    date_range: Dict[str, str] = Field(..., description="Date range for the count")
    last_updated: datetime = Field(..., description="When the data was last updated")

class ContentStatsResponse(BaseModel):
    """Schema for content statistics response"""
    total_content: int = Field(..., description="Total number of content items")
    active_content: int = Field(..., description="Number of active content items")
    content_by_genre: Dict[str, int] = Field(..., description="Content count by genre")
    content_by_studio: Optional[Dict[str, int]] = Field(None, description="Content count by studio")
    average_rating: Optional[float] = Field(None, description="Average content rating")

class UserAnalyticsResponse(BaseModel):
    """Schema for user analytics response"""
    user_id: int = Field(..., description="User ID")
    total_watch_time: int = Field(..., description="Total watch time in minutes")
    content_watched: int = Field(..., description="Number of content items watched")
    favorite_genres: List[str] = Field(..., description="User's favorite genres")
    device_usage: Dict[str, int] = Field(..., description="Usage by device type")
    daily_analytics: Optional[List[Dict[str, Any]]] = Field(None, description="Daily analytics data")

class ReportGenerationResponse(BaseModel):
    """Schema for report generation response"""
    report_id: str = Field(..., description="Unique report identifier")
    report_type: str = Field(..., description="Type of report generated")
    status: str = Field(..., description="Report generation status")
    download_url: Optional[str] = Field(None, description="URL to download the report")
    expires_at: Optional[datetime] = Field(None, description="When the download link expires")
    created_at: datetime = Field(..., description="When the report was created")

class DatabaseHealthResponse(BaseModel):
    """Schema for database health check response"""
    mysql: Dict[str, Any] = Field(..., description="MySQL connection status")
    mongodb: Dict[str, Any] = Field(..., description="MongoDB connection status")
    cassandra: Dict[str, Any] = Field(..., description="Cassandra connection status")
    overall_status: str = Field(..., description="Overall database health status")

class StudioInfoResponse(BaseModel):
    """Schema for studio information response"""
    studio_id: int = Field(..., description="Studio ID")
    studio_name: str = Field(..., description="Studio name")
    is_active: bool = Field(..., description="Whether the studio is active")
    content_count: int = Field(..., description="Number of content items")
    user_count: int = Field(..., description="Number of users")
    created_at: datetime = Field(..., description="Studio creation date")

class ContentDetailsResponse(BaseModel):
    """Schema for content details response"""
    content_id: int = Field(..., description="Content ID")
    title: str = Field(..., description="Content title")
    genre: str = Field(..., description="Content genre")
    duration: int = Field(..., description="Content duration in minutes")
    rating: Optional[float] = Field(None, description="Content rating")
    studio_id: int = Field(..., description="Studio ID")
    view_count: int = Field(..., description="Total view count")
    is_active: bool = Field(..., description="Whether content is active")
    created_at: datetime = Field(..., description="Content creation date")

class UserProfileResponse(BaseModel):
    """Schema for user profile response"""
    user_id: int = Field(..., description="User ID")
    username: str = Field(..., description="Username")
    email: str = Field(..., description="User email")
    subscription_type: str = Field(..., description="Subscription type")
    is_active: bool = Field(..., description="Whether user is active")
    last_login: Optional[datetime] = Field(None, description="Last login timestamp")
    preferences: Dict[str, Any] = Field(default_factory=dict, description="User preferences")
    created_at: datetime = Field(..., description="Account creation date")

class AnalyticsMetricsResponse(BaseModel):
    """Schema for analytics metrics response"""
    total_users: int = Field(..., description="Total number of users")
    active_users_today: int = Field(..., description="Active users today")
    total_content_views: int = Field(..., description="Total content views")
    peak_concurrent_users: int = Field(..., description="Peak concurrent users")
    average_session_duration: float = Field(..., description="Average session duration in minutes")
    top_content: List[Dict[str, Any]] = Field(..., description="Top performing content")
    user_growth: Dict[str, int] = Field(..., description="User growth metrics")

class BandwidthUsageResponse(BaseModel):
    """Schema for bandwidth usage response"""
    studio_id: Optional[int] = Field(None, description="Studio ID (if filtered)")
    total_bandwidth_gb: float = Field(..., description="Total bandwidth usage in GB")
    peak_bandwidth_mbps: float = Field(..., description="Peak bandwidth in Mbps")
    average_bandwidth_mbps: float = Field(..., description="Average bandwidth in Mbps")
    bandwidth_by_hour: List[Dict[str, Any]] = Field(..., description="Hourly bandwidth usage")
    top_consuming_content: List[Dict[str, Any]] = Field(..., description="Top bandwidth consuming content")

class SystemStatusResponse(BaseModel):
    """Schema for system status response"""
    system_health: str = Field(..., description="Overall system health")
    services: Dict[str, Dict[str, Any]] = Field(..., description="Individual service statuses")
    performance_metrics: Dict[str, float] = Field(..., description="Performance metrics")
    last_updated: datetime = Field(..., description="When status was last updated")
    uptime: str = Field(..., description="System uptime")

# Wrapper classes for different response types
class ActiveUsersSuccessResponse(SuccessResponse):
    """Wrapper for active users success response"""
    data: ActiveUsersResponse

class ContentStatsSuccessResponse(SuccessResponse):
    """Wrapper for content stats success response"""
    data: ContentStatsResponse

class UserAnalyticsSuccessResponse(SuccessResponse):
    """Wrapper for user analytics success response"""
    data: UserAnalyticsResponse

class ReportGenerationSuccessResponse(SuccessResponse):
    """Wrapper for report generation success response"""
    data: ReportGenerationResponse

class DatabaseHealthSuccessResponse(SuccessResponse):
    """Wrapper for database health success response"""
    data: DatabaseHealthResponse

class StudioInfoSuccessResponse(SuccessResponse):
    """Wrapper for studio info success response"""
    data: StudioInfoResponse

class ContentDetailsSuccessResponse(SuccessResponse):
    """Wrapper for content details success response"""
    data: ContentDetailsResponse

class UserProfileSuccessResponse(SuccessResponse):
    """Wrapper for user profile success response"""
    data: UserProfileResponse

class AnalyticsMetricsSuccessResponse(SuccessResponse):
    """Wrapper for analytics metrics success response"""
    data: AnalyticsMetricsResponse

class BandwidthUsageSuccessResponse(SuccessResponse):
    """Wrapper for bandwidth usage success response"""
    data: BandwidthUsageResponse

class SystemStatusSuccessResponse(SuccessResponse):
    """Wrapper for system status success response"""
    data: SystemStatusResponse