"""
Custom managers and QuerySets for Rides models.
Optimized queries following Django styleguide patterns.
"""

from typing import Optional, List, Dict, Any, Union
from django.db import models
from django.db.models import Q, F, Count, Avg, Max, Min, Prefetch

from core.managers import (
    BaseQuerySet, BaseManager, ReviewableQuerySet, ReviewableManager, 
    StatusQuerySet, StatusManager
)


class RideQuerySet(StatusQuerySet, ReviewableQuerySet):
    """Optimized QuerySet for Ride model."""
    
    def by_category(self, *, category: Union[str, List[str]]):
        """Filter rides by category."""
        if isinstance(category, list):
            return self.filter(category__in=category)
        return self.filter(category=category)
    
    def coasters(self):
        """Filter for roller coasters."""
        return self.filter(category__in=['RC', 'WC'])
    
    def thrill_rides(self):
        """Filter for thrill rides."""
        return self.filter(category__in=['RC', 'WC', 'FR'])
    
    def family_friendly(self, *, max_height_requirement: int = 42):
        """Filter for family-friendly rides."""
        return self.filter(
            Q(min_height_in__lte=max_height_requirement) |
            Q(min_height_in__isnull=True)
        )
    
    def by_park(self, *, park_id: int):
        """Filter rides by park."""
        return self.filter(park_id=park_id)
    
    def by_manufacturer(self, *, manufacturer_id: int):
        """Filter rides by manufacturer."""
        return self.filter(manufacturer_id=manufacturer_id)
    
    def by_designer(self, *, designer_id: int):
        """Filter rides by designer."""
        return self.filter(designer_id=designer_id)
    
    def with_capacity_info(self):
        """Add capacity-related annotations."""
        return self.annotate(
            estimated_daily_capacity=F('capacity_per_hour') * 10,  # Assuming 10 operating hours
            duration_minutes=F('ride_duration_seconds') / 60.0
        )
    
    def high_capacity(self, *, min_capacity: int = 1000):
        """Filter for high-capacity rides."""
        return self.filter(capacity_per_hour__gte=min_capacity)
    
    def optimized_for_list(self):
        """Optimize for ride list display."""
        return self.select_related(
            'park',
            'park_area', 
            'manufacturer',
            'designer',
            'ride_model'
        ).with_review_stats()
    
    def optimized_for_detail(self):
        """Optimize for ride detail display."""
        from .models import RideReview
        
        return self.select_related(
            'park',
            'park_area',
            'manufacturer', 
            'designer',
            'ride_model__manufacturer'
        ).prefetch_related(
            'location',
            'rollercoaster_stats',
            Prefetch(
                'reviews',
                queryset=RideReview.objects.select_related('user')
                .filter(is_published=True)
                .order_by('-created_at')[:10]
            ),
            'photos'
        )
    
    def for_map_display(self):
        """Optimize for map display."""
        return self.select_related('park', 'park_area').prefetch_related('location').values(
            'id', 'name', 'slug', 'category', 'status',
            'park__name', 'park__slug',
            'park_area__name',
            'location__point'
        )
    
    def search_by_specs(self, *, min_height: Optional[int] = None, max_height: Optional[int] = None,
                       min_speed: Optional[float] = None, inversions: Optional[bool] = None):
        """Search rides by physical specifications."""
        queryset = self
        
        if min_height:
            queryset = queryset.filter(
                Q(rollercoaster_stats__height_ft__gte=min_height) |
                Q(min_height_in__gte=min_height)
            )
        
        if max_height:
            queryset = queryset.filter(
                Q(rollercoaster_stats__height_ft__lte=max_height) |
                Q(max_height_in__lte=max_height)
            )
        
        if min_speed:
            queryset = queryset.filter(rollercoaster_stats__speed_mph__gte=min_speed)
        
        if inversions is not None:
            if inversions:
                queryset = queryset.filter(rollercoaster_stats__inversions__gt=0)
            else:
                queryset = queryset.filter(
                    Q(rollercoaster_stats__inversions=0) |
                    Q(rollercoaster_stats__isnull=True)
                )
        
        return queryset


class RideManager(StatusManager, ReviewableManager):
    """Custom manager for Ride model."""
    
    def get_queryset(self):
        return RideQuerySet(self.model, using=self._db)
    
    def coasters(self):
        return self.get_queryset().coasters()
    
    def thrill_rides(self):
        return self.get_queryset().thrill_rides()
    
    def family_friendly(self, *, max_height_requirement: int = 42):
        return self.get_queryset().family_friendly(max_height_requirement=max_height_requirement)
    
    def by_park(self, *, park_id: int):
        return self.get_queryset().by_park(park_id=park_id)
    
    def high_capacity(self, *, min_capacity: int = 1000):
        return self.get_queryset().high_capacity(min_capacity=min_capacity)
    
    def optimized_for_list(self):
        return self.get_queryset().optimized_for_list()
    
    def optimized_for_detail(self):
        return self.get_queryset().optimized_for_detail()


class RideModelQuerySet(BaseQuerySet):
    """QuerySet for RideModel model."""
    
    def by_manufacturer(self, *, manufacturer_id: int):
        """Filter ride models by manufacturer."""
        return self.filter(manufacturer_id=manufacturer_id)
    
    def by_category(self, *, category: str):
        """Filter ride models by category."""
        return self.filter(category=category)
    
    def with_ride_counts(self):
        """Add count of rides using this model."""
        return self.annotate(
            ride_count=Count('rides', distinct=True),
            operating_rides_count=Count('rides', filter=Q(rides__status='OPERATING'), distinct=True)
        )
    
    def popular_models(self, *, min_installations: int = 5):
        """Filter for popular ride models."""
        return self.with_ride_counts().filter(ride_count__gte=min_installations)
    
    def optimized_for_list(self):
        """Optimize for model list display."""
        return self.select_related('manufacturer').with_ride_counts()


class RideModelManager(BaseManager):
    """Manager for RideModel model."""
    
    def get_queryset(self):
        return RideModelQuerySet(self.model, using=self._db)
    
    def by_manufacturer(self, *, manufacturer_id: int):
        return self.get_queryset().by_manufacturer(manufacturer_id=manufacturer_id)
    
    def popular_models(self, *, min_installations: int = 5):
        return self.get_queryset().popular_models(min_installations=min_installations)


class RideReviewQuerySet(ReviewableQuerySet):
    """QuerySet for RideReview model."""
    
    def for_ride(self, *, ride_id: int):
        """Filter reviews for a specific ride."""
        return self.filter(ride_id=ride_id)
    
    def by_user(self, *, user_id: int):
        """Filter reviews by user."""
        return self.filter(user_id=user_id)
    
    def by_rating_range(self, *, min_rating: int = 1, max_rating: int = 10):
        """Filter reviews by rating range."""
        return self.filter(rating__gte=min_rating, rating__lte=max_rating)
    
    def optimized_for_display(self):
        """Optimize for review display."""
        return self.select_related('user', 'ride', 'moderated_by')


class RideReviewManager(BaseManager):
    """Manager for RideReview model."""
    
    def get_queryset(self):
        return RideReviewQuerySet(self.model, using=self._db)
    
    def for_ride(self, *, ride_id: int):
        return self.get_queryset().for_ride(ride_id=ride_id)
    
    def by_rating_range(self, *, min_rating: int = 1, max_rating: int = 10):
        return self.get_queryset().by_rating_range(min_rating=min_rating, max_rating=max_rating)


class RollerCoasterStatsQuerySet(BaseQuerySet):
    """QuerySet for RollerCoasterStats model."""
    
    def tall_coasters(self, *, min_height_ft: float = 200):
        """Filter for tall roller coasters."""
        return self.filter(height_ft__gte=min_height_ft)
    
    def fast_coasters(self, *, min_speed_mph: float = 60):
        """Filter for fast roller coasters."""
        return self.filter(speed_mph__gte=min_speed_mph)
    
    def with_inversions(self):
        """Filter for coasters with inversions."""
        return self.filter(inversions__gt=0)
    
    def launched_coasters(self):
        """Filter for launched coasters."""
        return self.exclude(launch_type='NONE')
    
    def by_track_type(self, *, track_type: str):
        """Filter by track type."""
        return self.filter(track_type=track_type)
    
    def optimized_for_list(self):
        """Optimize for stats list display."""
        return self.select_related('ride', 'ride__park')


class RollerCoasterStatsManager(BaseManager):
    """Manager for RollerCoasterStats model."""
    
    def get_queryset(self):
        return RollerCoasterStatsQuerySet(self.model, using=self._db)
    
    def tall_coasters(self, *, min_height_ft: float = 200):
        return self.get_queryset().tall_coasters(min_height_ft=min_height_ft)
    
    def fast_coasters(self, *, min_speed_mph: float = 60):
        return self.get_queryset().fast_coasters(min_speed_mph=min_speed_mph)
    
    def with_inversions(self):
        return self.get_queryset().with_inversions()
    
    def launched_coasters(self):
        return self.get_queryset().launched_coasters()