from pydantic import BaseModel, Field, field_validator
from datetime import datetime
from typing import Optional


class SiteSettingsBase(BaseModel):
    """Base schema for site settings"""
    scraping_enabled: bool = Field(default=False, description="Enable/disable automated scraping")
    scraping_frequency: str = Field(
        default="daily",
        description="Frequency: 'daily', 'weekly', or 'custom'"
    )
    scraping_time: Optional[str] = Field(
        default="02:00",
        description="Time to run scraping (UTC). Format: HH:MM. Can be null for custom frequency"
    )
    scraping_day_of_week: Optional[str] = Field(
        default="monday",
        description="For weekly scraping: day of week (monday-sunday)"
    )
    scraping_custom_cron: Optional[str] = Field(
        default=None,
        description="Custom cron expression (used when frequency='custom')"
    )
    enable_discovery: bool = Field(default=True, description="Enable SERP API discovery")
    headless_mode: bool = Field(default=True, description="Run browser in headless mode")
    timeout_seconds: int = Field(default=15, ge=5, le=60, description="Page load timeout in seconds")
    client_timezone: str = Field(
        default="UTC",
        description="Client timezone for scheduling (e.g., 'Europe/Madrid', 'America/New_York', 'UTC')"
    )

    @field_validator('scraping_time')
    @classmethod
    def validate_time_format(cls, v):
        """Validate time format is HH:MM"""
        if v is None:
            return v  # Optional - can be None
        if not isinstance(v, str):
            return v
        parts = v.split(':')
        if len(parts) != 2:
            raise ValueError("Time format must be HH:MM")
        try:
            hour, minute = int(parts[0]), int(parts[1])
            if not (0 <= hour <= 23 and 0 <= minute <= 59):
                raise ValueError("Invalid time range")
        except (ValueError, TypeError):
            raise ValueError("Time format must be HH:MM (24-hour)")
        return v

    @field_validator('scraping_frequency')
    @classmethod
    def validate_frequency(cls, v):
        """Validate frequency is one of allowed values"""
        if v not in ['daily', 'weekly', 'custom']:
            raise ValueError("Frequency must be 'daily', 'weekly', or 'custom'")
        return v

    @field_validator('scraping_day_of_week')
    @classmethod
    def validate_day_of_week(cls, v):
        """Validate day of week if provided"""
        if v is None:
            return v
        allowed_days = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
        if v.lower() not in allowed_days:
            raise ValueError(f"Day must be one of: {', '.join(allowed_days)}")
        return v.lower()

    @field_validator('client_timezone')
    @classmethod
    def validate_timezone(cls, v):
        """Validate timezone is valid"""
        if v is None:
            return "UTC"
        import pytz
        try:
            pytz.timezone(v)
            return v
        except pytz.exceptions.UnknownTimeZoneError:
            raise ValueError(f"Invalid timezone: {v}. Use IANA timezone names like 'Europe/Madrid', 'America/New_York', etc.")


class SiteSettingsUpdate(SiteSettingsBase):
    """Schema for updating site settings"""
    class Config:
        from_attributes = True


class SiteSettingsResponse(SiteSettingsBase):
    """Schema for site settings response"""
    id: int
    last_scheduled_run: Optional[datetime] = None
    last_scheduled_run_status: Optional[str] = None
    last_scheduled_run_summary: Optional[str] = None
    created_at: datetime
    updated_at: datetime

    class Config:
        from_attributes = True


class ScheduledScrapingOutput(BaseModel):
    """Output for scheduled scraping job response"""
    message: str
    products_scraped: int
    total_violations: int
    status: str