from rest_framework import serializers
from taggit_serializer.serializers import TagListSerializerField
from accounts.models import IAmPrincipalLocation
from manage_cms.api.serializers import TagSerializer
from taggit.models import Tag
from manage_events.utils import get_location_info
from accounts.api.serializers import ProfileSerializer
from manage_events.models import (
    EventMaster,
    Event,
    EventCategory,
    EventImage,
    EventPrincipalInteraction,
    EventReview,
    Favorites,
    Venue,
    PrincipalPreference,
)


class EventImageSerializer(serializers.ModelSerializer):
    class Meta:
        model = EventImage
        fields = ["image"]

    def get_image(self, obj):
        request = self.context.get("request")
        if obj.image and hasattr(obj.image, "url"):
            return request.build_absolute_uri(obj.image.url)
        return None


class VenueSerializer(serializers.ModelSerializer):
    created_by = ProfileSerializer(read_only=True)

    class Meta:
        model = Venue
        fields = "__all__"
        read_only_fields = ("created_by",)


class EventCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = EventCategory
        fields = ["id", "title", "image", "description", "video_url"]


class EventListSerializer(serializers.ModelSerializer):
    # category = EventCategorySerializer(read_only=True)
    # venue = VenueSerializer(read_only=True)
    # draft = serializers.BooleanField(read_only=True)
    # tags = TagSerializer(many=True, read_only=True)

    class Meta:
        model = Event
        fields = [
            "id",
            "title",
            "description",
            "start_date",
            "end_date",
            # "from_time",
            # "to_time",
            # "category",
            # "venue",
            # "venue_capacity",
            "image",
            # "video_url",
            # "entry_type",
            "entry_fee",
            "key_guest",
            # "age_group",
            # "images",
            # "is_favorited",
            # "reviews",
            # "tags",
            # "principal_interaction",
            # "draft",
        ]


class EventDetailSerializer(serializers.ModelSerializer):
    tags = TagSerializer(many=True, read_only=True)
    images = serializers.SerializerMethodField()
    venue = VenueSerializer(read_only=True)  # Use VenueSerializer for the venue field
    category = EventCategorySerializer(read_only=True)
    is_favorited = serializers.SerializerMethodField()
    reviews = serializers.SerializerMethodField()
    principal_interaction = serializers.SerializerMethodField()
    draft = serializers.BooleanField(read_only=True)

    class Meta:
        model = Event
        fields = [
            "id",
            "title",
            "description",
            "start_date",
            "end_date",
            "from_time",
            "to_time",
            "category",
            "venue",
            "venue_capacity",
            "image",
            "video_url",
            "entry_type",
            "entry_fee",
            "key_guest",
            "coupon_code",
            "coupon_description",
            "age_group",
            "images",
            "is_favorited",
            "reviews",
            "tags",
            "principal_interaction",
            "draft",
        ]

    def get_images(self, obj):
        images = (
            obj.event_images.all()
        )  # Ensure this uses the correct related_name from your model
        return EventImageSerializer(images, many=True, context=self.context).data

    def get_is_favorited(self, obj):
        request = self.context.get("request")
        if request and hasattr(request, "user"):
            user = request.user
            return Favorites.objects.filter(event=obj, principal=user).exists()
        return False

    def get_reviews(self, obj):
        # related_name is 'reviews' as defined in EventReview model
        reviews = obj.reviews.all()
        return EventReviewSerializer(reviews, many=True, context=self.context).data

    def get_principal_interaction(self, obj):
        request = self.context.get("request")
        if request and hasattr(request, "user") and not request.user.is_anonymous:
            user = request.user
            interaction = EventPrincipalInteraction.objects.filter(
                event=obj, principal=user
            ).first()
            if interaction:
                return {
                    "status": interaction.status,
                    "status_display": interaction.get_status_display(),
                }
        return None


class CreateEventSerializer(serializers.ModelSerializer):
    tags = TagListSerializerField(required=False)
    images = serializers.ListField(
        child=serializers.ImageField(), write_only=True, required=False
    )

    class Meta:
        model = Event
        fields = [
            "id",
            "images",
            "title",
            "description",
            "image",
            "start_date",
            "end_date",
            "from_time",
            "to_time",
            "category",
            "venue_capacity",
            "video_url",
            "entry_type",
            "entry_fee",
            "key_guest",
            "age_group",
            "draft",
            "venue",
            "tags",
            "coupon_code",
            "coupon_description",
        ]

    def create(self, validated_data):
        tags = validated_data.pop("tags", None)
        images_data = validated_data.pop("images", None)
        event = Event.objects.create(**validated_data)

        if tags:
            event.tags.add(*tags)

        if images_data:
            for image_data in images_data:
                EventImage.objects.create(event=event, image=image_data)

        return event

    def update(self, instance, validated_data):
        tags = validated_data.pop("tags", None)
        images_data = validated_data.pop("images", None)

        # Update fields if there is any change.
        if tags is not None:
            # Clear existing tags and add the new ones
            instance.tags.clear()
            instance.tags.add(*tags)

        if images_data is not None:
            EventImage.objects.filter(event=instance).delete()
            for image_data in images_data:
                EventImage.objects.create(event=instance, image=image_data)

        # Update other fields
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()

        return instance


class CreateVenueSerializer(serializers.ModelSerializer):
    class Meta:
        model = Venue
        fields = [
            "title",
            "description",
            "address",
            "image",
            "url",
            "latitude",
            "longitude",
        ]


class IAmPrincipalLocationSerializer(serializers.ModelSerializer):
    class Meta:
        model = IAmPrincipalLocation
        fields = ["latitude", "longitude"]


class PrincipalPreferenceSerializer(serializers.ModelSerializer):
    preferred_categories = serializers.PrimaryKeyRelatedField(
        many=True, queryset=EventCategory.objects.all()
    )

    class Meta:
        model = PrincipalPreference
        fields = ["preferred_categories"]  # Removed 'principal' from fields

    def create(self, validated_data):
        # Accessing the principal from the context
        user = self.context["request"].user
        preferred_categories = validated_data.pop("preferred_categories")
        principal_preference, created = PrincipalPreference.objects.update_or_create(
            principal=user, defaults={}
        )
        principal_preference.preferred_categories.set(preferred_categories)
        return principal_preference

    def update(self, instance, validated_data):
        instance.preferred_categories.set(
            validated_data.get(
                "preferred_categories", instance.preferred_categories.all()
            )
        )
        instance.save()
        return instance


class EventMasterSearchSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=255)


class EventMasterSerializer(serializers.ModelSerializer):
    class Meta:
        model = EventMaster
        fields = "__all__"


class EventDateRangeSerializer(serializers.Serializer):
    start_date = serializers.DateField(format="%Y-%m-%d", input_formats=["%Y-%m-%d"])
    end_date = serializers.DateField(format="%Y-%m-%d", input_formats=["%Y-%m-%d"])


class EventReviewSerializer(serializers.ModelSerializer):
    principal = ProfileSerializer(read_only=True)

    class Meta:
        model = EventReview
        fields = ["id", "event", "principal", "review_text", "rating"]
        extra_kwargs = {
            "principal": {"read_only": True},
        }

    def create(self, validated_data):
        validated_data["principal"] = self.context["request"].user
        return super().create(validated_data)


class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ["name"]