# services/tenant/app/schemas/tenant_settings.py
"""
Tenant Settings Schemas
Pydantic models for API request/response validation
"""

from pydantic import BaseModel, Field, validator
from typing import Optional
from datetime import datetime
from uuid import UUID


# ================================================================
# SETTING CATEGORY SCHEMAS
# ================================================================

class ProcurementSettings(BaseModel):
    """Procurement and auto-approval settings"""
    auto_approve_enabled: bool = True
    auto_approve_threshold_eur: float = Field(500.0, ge=0, le=10000)
    auto_approve_min_supplier_score: float = Field(0.80, ge=0.0, le=1.0)
    require_approval_new_suppliers: bool = True
    require_approval_critical_items: bool = True
    procurement_lead_time_days: int = Field(3, ge=1, le=30)
    demand_forecast_days: int = Field(14, ge=1, le=90)
    safety_stock_percentage: float = Field(20.0, ge=0.0, le=100.0)
    po_approval_reminder_hours: int = Field(24, ge=1, le=168)
    po_critical_escalation_hours: int = Field(12, ge=1, le=72)
    use_reorder_rules: bool = Field(True, description="Use ingredient reorder point and reorder quantity in procurement calculations")
    economic_rounding: bool = Field(True, description="Round order quantities to economic multiples (reorder_quantity or supplier minimum_order_quantity)")
    respect_storage_limits: bool = Field(True, description="Enforce max_stock_level constraints on orders")
    use_supplier_minimums: bool = Field(True, description="Respect supplier minimum_order_quantity and minimum_order_amount")
    optimize_price_tiers: bool = Field(True, description="Optimize order quantities to capture volume discount price tiers")


class InventorySettings(BaseModel):
    """Inventory management settings"""
    low_stock_threshold: int = Field(10, ge=1, le=1000)
    reorder_point: int = Field(20, ge=1, le=1000)
    reorder_quantity: int = Field(50, ge=1, le=1000)
    expiring_soon_days: int = Field(7, ge=1, le=30)
    expiration_warning_days: int = Field(3, ge=1, le=14)
    quality_score_threshold: float = Field(8.0, ge=0.0, le=10.0)
    temperature_monitoring_enabled: bool = True
    refrigeration_temp_min: float = Field(1.0, ge=-5.0, le=10.0)
    refrigeration_temp_max: float = Field(4.0, ge=-5.0, le=10.0)
    freezer_temp_min: float = Field(-20.0, ge=-30.0, le=0.0)
    freezer_temp_max: float = Field(-15.0, ge=-30.0, le=0.0)
    room_temp_min: float = Field(18.0, ge=10.0, le=35.0)
    room_temp_max: float = Field(25.0, ge=10.0, le=35.0)
    temp_deviation_alert_minutes: int = Field(15, ge=1, le=60)
    critical_temp_deviation_minutes: int = Field(5, ge=1, le=30)

    @validator('refrigeration_temp_max')
    def validate_refrigeration_range(cls, v, values):
        if 'refrigeration_temp_min' in values and v <= values['refrigeration_temp_min']:
            raise ValueError('refrigeration_temp_max must be greater than refrigeration_temp_min')
        return v

    @validator('freezer_temp_max')
    def validate_freezer_range(cls, v, values):
        if 'freezer_temp_min' in values and v <= values['freezer_temp_min']:
            raise ValueError('freezer_temp_max must be greater than freezer_temp_min')
        return v

    @validator('room_temp_max')
    def validate_room_range(cls, v, values):
        if 'room_temp_min' in values and v <= values['room_temp_min']:
            raise ValueError('room_temp_max must be greater than room_temp_min')
        return v


class ProductionSettings(BaseModel):
    """Production settings"""
    planning_horizon_days: int = Field(7, ge=1, le=30)
    minimum_batch_size: float = Field(1.0, ge=0.1, le=100.0)
    maximum_batch_size: float = Field(100.0, ge=1.0, le=1000.0)
    production_buffer_percentage: float = Field(10.0, ge=0.0, le=50.0)
    working_hours_per_day: int = Field(12, ge=1, le=24)
    max_overtime_hours: int = Field(4, ge=0, le=12)
    capacity_utilization_target: float = Field(0.85, ge=0.5, le=1.0)
    capacity_warning_threshold: float = Field(0.95, ge=0.7, le=1.0)
    quality_check_enabled: bool = True
    minimum_yield_percentage: float = Field(85.0, ge=50.0, le=100.0)
    quality_score_threshold: float = Field(8.0, ge=0.0, le=10.0)
    schedule_optimization_enabled: bool = True
    prep_time_buffer_minutes: int = Field(30, ge=0, le=120)
    cleanup_time_buffer_minutes: int = Field(15, ge=0, le=120)
    labor_cost_per_hour_eur: float = Field(15.0, ge=5.0, le=100.0)
    overhead_cost_percentage: float = Field(20.0, ge=0.0, le=50.0)

    @validator('maximum_batch_size')
    def validate_batch_size_range(cls, v, values):
        if 'minimum_batch_size' in values and v <= values['minimum_batch_size']:
            raise ValueError('maximum_batch_size must be greater than minimum_batch_size')
        return v

    @validator('capacity_warning_threshold')
    def validate_capacity_threshold(cls, v, values):
        if 'capacity_utilization_target' in values and v <= values['capacity_utilization_target']:
            raise ValueError('capacity_warning_threshold must be greater than capacity_utilization_target')
        return v


class SupplierSettings(BaseModel):
    """Supplier management settings"""
    default_payment_terms_days: int = Field(30, ge=1, le=90)
    default_delivery_days: int = Field(3, ge=1, le=30)
    excellent_delivery_rate: float = Field(95.0, ge=90.0, le=100.0)
    good_delivery_rate: float = Field(90.0, ge=80.0, le=99.0)
    excellent_quality_rate: float = Field(98.0, ge=90.0, le=100.0)
    good_quality_rate: float = Field(95.0, ge=80.0, le=99.0)
    critical_delivery_delay_hours: int = Field(24, ge=1, le=168)
    critical_quality_rejection_rate: float = Field(10.0, ge=0.0, le=50.0)
    high_cost_variance_percentage: float = Field(15.0, ge=0.0, le=100.0)

    @validator('good_delivery_rate')
    def validate_delivery_rates(cls, v, values):
        if 'excellent_delivery_rate' in values and v >= values['excellent_delivery_rate']:
            raise ValueError('good_delivery_rate must be less than excellent_delivery_rate')
        return v

    @validator('good_quality_rate')
    def validate_quality_rates(cls, v, values):
        if 'excellent_quality_rate' in values and v >= values['excellent_quality_rate']:
            raise ValueError('good_quality_rate must be less than excellent_quality_rate')
        return v


class POSSettings(BaseModel):
    """POS integration settings"""
    sync_interval_minutes: int = Field(5, ge=1, le=60)
    auto_sync_products: bool = True
    auto_sync_transactions: bool = True


class OrderSettings(BaseModel):
    """Order and business rules settings"""
    max_discount_percentage: float = Field(50.0, ge=0.0, le=100.0)
    default_delivery_window_hours: int = Field(48, ge=1, le=168)
    dynamic_pricing_enabled: bool = False
    discount_enabled: bool = True
    delivery_tracking_enabled: bool = True


class ReplenishmentSettings(BaseModel):
    """Replenishment planning settings"""
    projection_horizon_days: int = Field(7, ge=1, le=30)
    service_level: float = Field(0.95, ge=0.0, le=1.0)
    buffer_days: int = Field(1, ge=0, le=14)
    enable_auto_replenishment: bool = True
    min_order_quantity: float = Field(1.0, ge=0.1, le=1000.0)
    max_order_quantity: float = Field(1000.0, ge=1.0, le=10000.0)
    demand_forecast_days: int = Field(14, ge=1, le=90)


class SafetyStockSettings(BaseModel):
    """Safety stock settings"""
    service_level: float = Field(0.95, ge=0.0, le=1.0)
    method: str = Field("statistical", description="Method for safety stock calculation")
    min_safety_stock: float = Field(0.0, ge=0.0, le=1000.0)
    max_safety_stock: float = Field(100.0, ge=0.0, le=1000.0)
    reorder_point_calculation: str = Field("safety_stock_plus_lead_time_demand", description="Method for reorder point calculation")


class MOQSettings(BaseModel):
    """MOQ aggregation settings"""
    consolidation_window_days: int = Field(7, ge=1, le=30)
    allow_early_ordering: bool = True
    enable_batch_optimization: bool = True
    min_batch_size: float = Field(1.0, ge=0.1, le=1000.0)
    max_batch_size: float = Field(1000.0, ge=1.0, le=10000.0)


class SupplierSelectionSettings(BaseModel):
    """Supplier selection settings"""
    price_weight: float = Field(0.40, ge=0.0, le=1.0)
    lead_time_weight: float = Field(0.20, ge=0.0, le=1.0)
    quality_weight: float = Field(0.20, ge=0.0, le=1.0)
    reliability_weight: float = Field(0.20, ge=0.0, le=1.0)
    diversification_threshold: int = Field(1000, ge=0, le=1000)
    max_single_percentage: float = Field(0.70, ge=0.0, le=1.0)
    enable_supplier_score_optimization: bool = True

    @validator('price_weight', 'lead_time_weight', 'quality_weight', 'reliability_weight')
    def validate_weights_sum(cls, v, values):
        weights = [values.get('price_weight', 0.40), values.get('lead_time_weight', 0.20),
                  values.get('quality_weight', 0.20), values.get('reliability_weight', 0.20)]
        total = sum(weights)
        if total > 1.0:
            raise ValueError('Weights must sum to 1.0 or less')
        return v


class MLInsightsSettings(BaseModel):
    """ML Insights configuration settings"""
    # Inventory ML (Safety Stock Optimization)
    inventory_lookback_days: int = Field(90, ge=30, le=365, description="Days of demand history for safety stock analysis")
    inventory_min_history_days: int = Field(30, ge=7, le=180, description="Minimum days of history required")

    # Production ML (Yield Prediction)
    production_lookback_days: int = Field(90, ge=30, le=365, description="Days of production history for yield analysis")
    production_min_history_runs: int = Field(30, ge=10, le=100, description="Minimum production runs required")

    # Procurement ML (Supplier Analysis & Price Forecasting)
    supplier_analysis_lookback_days: int = Field(180, ge=30, le=730, description="Days of order history for supplier analysis")
    supplier_analysis_min_orders: int = Field(10, ge=5, le=100, description="Minimum orders required for analysis")
    price_forecast_lookback_days: int = Field(180, ge=90, le=730, description="Days of price history for forecasting")
    price_forecast_horizon_days: int = Field(30, ge=7, le=90, description="Days to forecast ahead")

    # Forecasting ML (Dynamic Rules)
    rules_generation_lookback_days: int = Field(90, ge=30, le=365, description="Days of sales history for rule learning")
    rules_generation_min_samples: int = Field(10, ge=5, le=100, description="Minimum samples required for rule generation")

    # Global ML Settings
    enable_ml_insights: bool = Field(True, description="Enable/disable ML insights generation")
    ml_insights_auto_trigger: bool = Field(False, description="Automatically trigger ML insights in daily workflow")
    ml_confidence_threshold: float = Field(0.80, ge=0.0, le=1.0, description="Minimum confidence threshold for ML recommendations")


class NotificationSettings(BaseModel):
    """Notification and communication settings"""
    # WhatsApp Configuration (Shared Account Model)
    whatsapp_enabled: bool = Field(False, description="Enable WhatsApp notifications for this tenant")
    whatsapp_phone_number_id: str = Field("", description="Meta WhatsApp Phone Number ID (from shared master account)")
    whatsapp_display_phone_number: str = Field("", description="Display format for UI (e.g., '+34 612 345 678')")
    whatsapp_default_language: str = Field("es", description="Default language for WhatsApp templates")

    # Email Configuration
    email_enabled: bool = Field(True, description="Enable email notifications for this tenant")
    email_from_address: str = Field("", description="Custom from email address (optional)")
    email_from_name: str = Field("", description="Custom from name (optional)")
    email_reply_to: str = Field("", description="Reply-to email address (optional)")

    # Notification Preferences
    enable_po_notifications: bool = Field(True, description="Enable purchase order notifications")
    enable_inventory_alerts: bool = Field(True, description="Enable inventory alerts")
    enable_production_alerts: bool = Field(True, description="Enable production alerts")
    enable_forecast_alerts: bool = Field(True, description="Enable forecast alerts")

    # Notification Channels
    po_notification_channels: list[str] = Field(["email"], description="Channels for PO notifications (email, whatsapp)")
    inventory_alert_channels: list[str] = Field(["email"], description="Channels for inventory alerts")
    production_alert_channels: list[str] = Field(["email"], description="Channels for production alerts")
    forecast_alert_channels: list[str] = Field(["email"], description="Channels for forecast alerts")

    @validator('po_notification_channels', 'inventory_alert_channels', 'production_alert_channels', 'forecast_alert_channels')
    def validate_channels(cls, v):
        """Validate that channels are valid"""
        valid_channels = ["email", "whatsapp", "sms", "push"]
        for channel in v:
            if channel not in valid_channels:
                raise ValueError(f"Invalid channel: {channel}. Must be one of {valid_channels}")
        return v

    @validator('whatsapp_phone_number_id')
    def validate_phone_number_id(cls, v, values):
        """Validate phone number ID is provided if WhatsApp is enabled"""
        if values.get('whatsapp_enabled') and not v:
            raise ValueError("whatsapp_phone_number_id is required when WhatsApp is enabled")
        return v


# ================================================================
# REQUEST/RESPONSE SCHEMAS
# ================================================================

class TenantSettingsResponse(BaseModel):
    """Response schema for tenant settings"""
    id: UUID
    tenant_id: UUID
    procurement_settings: ProcurementSettings
    inventory_settings: InventorySettings
    production_settings: ProductionSettings
    supplier_settings: SupplierSettings
    pos_settings: POSSettings
    order_settings: OrderSettings
    replenishment_settings: ReplenishmentSettings
    safety_stock_settings: SafetyStockSettings
    moq_settings: MOQSettings
    supplier_selection_settings: SupplierSelectionSettings
    ml_insights_settings: MLInsightsSettings
    notification_settings: NotificationSettings
    created_at: datetime
    updated_at: datetime

    class Config:
        from_attributes = True


class TenantSettingsUpdate(BaseModel):
    """Schema for updating tenant settings"""
    procurement_settings: Optional[ProcurementSettings] = None
    inventory_settings: Optional[InventorySettings] = None
    production_settings: Optional[ProductionSettings] = None
    supplier_settings: Optional[SupplierSettings] = None
    pos_settings: Optional[POSSettings] = None
    order_settings: Optional[OrderSettings] = None
    replenishment_settings: Optional[ReplenishmentSettings] = None
    safety_stock_settings: Optional[SafetyStockSettings] = None
    moq_settings: Optional[MOQSettings] = None
    supplier_selection_settings: Optional[SupplierSelectionSettings] = None
    ml_insights_settings: Optional[MLInsightsSettings] = None
    notification_settings: Optional[NotificationSettings] = None


class CategoryUpdateRequest(BaseModel):
    """Schema for updating a single category"""
    settings: dict


class CategoryResetResponse(BaseModel):
    """Response schema for category reset"""
    category: str
    settings: dict
    message: str
