from rest_framework import serializers
from .models.rides import Ride, RideModel, Categories
from .models.company import Company
from apps.parks.models import Park


class CompanySerializer(serializers.ModelSerializer):
    """Serializer for Company model"""

    class Meta:
        model = Company
        fields = ["id", "name", "roles"]


class RideModelSerializer(serializers.ModelSerializer):
    """Serializer for RideModel"""

    manufacturer = CompanySerializer(read_only=True)

    class Meta:
        model = RideModel
        fields = ["id", "name", "manufacturer"]


class ParkSerializer(serializers.ModelSerializer):
    """Serializer for Park model"""

    location_city = serializers.CharField(source="location.city", read_only=True)
    location_country = serializers.CharField(source="location.country", read_only=True)

    class Meta:
        model = Park
        fields = ["id", "name", "slug", "location_city", "location_country"]


class RideSerializer(serializers.ModelSerializer):
    """Serializer for Ride model with all necessary fields for filtering display"""

    park = ParkSerializer(read_only=True)
    ride_model = RideModelSerializer(read_only=True)
    manufacturer = serializers.SerializerMethodField()
    designer = CompanySerializer(read_only=True)
    category_display = serializers.SerializerMethodField()
    status_display = serializers.SerializerMethodField()

    # Photo fields
    primary_photo_url = serializers.SerializerMethodField()
    photo_count = serializers.SerializerMethodField()

    # Computed fields
    age_years = serializers.SerializerMethodField()
    is_operating = serializers.SerializerMethodField()

    class Meta:
        model = Ride
        fields = [
            # Basic info
            "id",
            "name",
            "slug",
            "description",
            # Relationships
            "park",
            "ride_model",
            "manufacturer",
            "designer",
            # Categories and status
            "category",
            "category_display",
            "status",
            "status_display",
            # Dates
            "opening_date",
            "closing_date",
            "age_years",
            "is_operating",
            # Physical characteristics
            "height_ft",
            "max_speed_mph",
            "duration_seconds",
            "hourly_capacity",
            "length_ft",
            "inversions",
            "max_g_force",
            "max_angle_degrees",
            # Features (coaster specific)
            "lift_mechanism",
            "restraint_type",
            "track_material",
            # Media
            "primary_photo_url",
            "photo_count",
            # Metadata
            "created_at",
            "updated_at",
        ]

    def get_manufacturer(self, obj):
        """Get manufacturer from ride model if available"""
        if obj.ride_model and obj.ride_model.manufacturer:
            return CompanySerializer(obj.ride_model.manufacturer).data
        return None

    def get_category_display(self, obj):
        """Get human-readable category name"""
        return dict(Categories).get(obj.category, obj.category)

    def get_status_display(self, obj):
        """Get human-readable status"""
        return obj.get_status_display()

    def get_primary_photo_url(self, obj):
        """Get URL of primary photo if available"""
        # This would need to be implemented based on your photo model
        # For now, return None
        return None

    def get_photo_count(self, obj):
        """Get number of photos for this ride"""
        # This would need to be implemented based on your photo model
        # For now, return 0
        return 0

    def get_age_years(self, obj):
        """Calculate ride age in years"""
        if obj.opening_date:
            from datetime import date

            today = date.today()
            return today.year - obj.opening_date.year
        return None

    def get_is_operating(self, obj):
        """Check if ride is currently operating"""
        return obj.status == "OPERATING"


class RideListSerializer(RideSerializer):
    """Lightweight serializer for ride lists"""

    class Meta(RideSerializer.Meta):
        fields = [
            # Essential fields for list view
            "id",
            "name",
            "slug",
            "park",
            "category",
            "category_display",
            "status",
            "status_display",
            "opening_date",
            "age_years",
            "is_operating",
            "height_ft",
            "max_speed_mph",
            "manufacturer",
            "primary_photo_url",
        ]


class RideFilterOptionsSerializer(serializers.Serializer):
    """Serializer for filter options response"""

    categories = serializers.ListField(
        child=serializers.DictField(), help_text="Available ride categories"
    )
    manufacturers = serializers.ListField(
        child=serializers.DictField(), help_text="Available manufacturers"
    )
    designers = serializers.ListField(
        child=serializers.DictField(), help_text="Available designers"
    )
    parks = serializers.ListField(
        child=serializers.DictField(), help_text="Available parks (for global view)"
    )
    ride_models = serializers.ListField(
        child=serializers.DictField(), help_text="Available ride models"
    )
    ranges = serializers.DictField(help_text="Value ranges for numeric filters")
    date_ranges = serializers.DictField(help_text="Date ranges for date filters")


class FilterMetadataSerializer(serializers.Serializer):
    """Serializer for filter metadata in list responses"""

    active_filters = serializers.DictField(
        help_text="Summary of currently active filters"
    )
    has_filters = serializers.BooleanField(
        help_text="Whether any filters are currently active"
    )
    total_rides = serializers.IntegerField(
        help_text="Total number of rides before filtering"
    )
    filtered_count = serializers.IntegerField(
        help_text="Number of rides after filtering"
    )