"""
Ride submission service for ThrillWiki.

Handles Ride entity creation and updates through the Sacred Pipeline.
"""

import logging
from django.core.exceptions import ValidationError

from apps.entities.models import Ride, Park
from apps.entities.services import BaseEntitySubmissionService

logger = logging.getLogger(__name__)


class RideSubmissionService(BaseEntitySubmissionService):
    """
    Service for creating Ride submissions through the Sacred Pipeline.
    
    Rides require special handling for:
    - Park foreign key relationship
    - Manufacturer foreign key relationship (optional)
    - Ride model foreign key relationship (optional)
    - is_coaster flag (auto-set based on ride_category)
    
    Required fields:
    - name: Ride name
    - park: Park instance or park ID (UUID)
    - ride_category: Category of ride (roller_coaster, flat_ride, etc.)
    
    Example:
        from apps.entities.services.ride_submission import RideSubmissionService
        
        park = Park.objects.get(slug='cedar-point')
        
        submission, ride = RideSubmissionService.create_entity_submission(
            user=request.user,
            data={
                'name': 'Steel Vengeance',
                'park': park,
                'ride_category': 'roller_coaster',
                'status': 'operating',
                'height': Decimal('205'),
                'speed': Decimal('74'),
                'description': 'Hybrid steel-wooden coaster...',
            },
            source='api'
        )
    """
    
    entity_model = Ride
    entity_type_name = 'Ride'
    required_fields = ['name', 'park', 'ride_category']
    
    @classmethod
    def create_entity_submission(cls, user, data, **kwargs):
        """
        Create a Ride submission with foreign key handling.
        
        The 'park' field can be provided as either:
        - A Park instance
        - A UUID string (will be converted to Park instance)
        
        The 'is_coaster' flag is automatically set based on ride_category.
        
        Args:
            user: User creating the ride
            data: Ride field data (must include name, park, and ride_category)
            **kwargs: Additional metadata (source, ip_address, user_agent)
        
        Returns:
            tuple: (ContentSubmission, Ride or None)
        
        Raises:
            ValidationError: If park not found or invalid
        """
        # Validate and normalize park FK
        park = data.get('park')
        if park:
            if isinstance(park, str):
                # UUID string - convert to Park instance
                try:
                    park = Park.objects.get(id=park)
                    data['park'] = park
                except Park.DoesNotExist:
                    raise ValidationError(f"Park not found: {park}")
            elif not isinstance(park, Park):
                raise ValidationError(f"Invalid park type: {type(park)}")
        
        # Validate and normalize manufacturer FK if provided
        manufacturer = data.get('manufacturer')
        if manufacturer and isinstance(manufacturer, str):
            try:
                from apps.entities.models import Company
                manufacturer = Company.objects.get(id=manufacturer)
                data['manufacturer'] = manufacturer
            except Company.DoesNotExist:
                raise ValidationError(f"Manufacturer not found: {manufacturer}")
        
        # Validate and normalize model FK if provided
        model = data.get('model')
        if model and isinstance(model, str):
            try:
                from apps.entities.models import RideModel
                model = RideModel.objects.get(id=model)
                data['model'] = model
            except RideModel.DoesNotExist:
                raise ValidationError(f"Ride model not found: {model}")
        
        # Create submission through base class
        submission, ride = super().create_entity_submission(user, data, **kwargs)
        
        return submission, ride