import re
from rest_framework import serializers

from .models import (
    FAQ,
    Guideline,
    OwnerInfo,
    Page,
    PageSection,
    PageSectionItem,
    PageSectionType,
    Tag,
    Category,
)
from .models import AdvertiseContent, AdvertiseImage


class AdvertiseImageSerializer(serializers.ModelSerializer):
    image_url = serializers.SerializerMethodField()

    class Meta:
        model = AdvertiseImage
        fields = ('id', 'image_url', 'order')

    def get_image_url(self, obj):
        request = self.context.get('request')
        if obj.image and request:
            return request.build_absolute_uri(obj.image.url)
        return None
class AdvertiseContentSerializer(serializers.ModelSerializer):
    images = AdvertiseImageSerializer(many=True, read_only=True)

    class Meta:
        model = AdvertiseContent
        fields = (
            'id',
            'name',
            'type',
            'is_active',
            'images',
        )

class CKEditor5Field(serializers.Field):
    def to_representation(self, value):
        if value and hasattr(self, 'context') and 'request' in self.context:
            request = self.context['request']
            # Convert relative media URLs to absolute URLs
            value = re.sub(
                r'src="(/media/[^"]+)"',
                lambda m: f'src="{request.build_absolute_uri(m.group(1))}"',
                value
            )
        return value
    
class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = "__all__"


class GuidelineListSerializer(serializers.ModelSerializer):
    country_display = serializers.CharField(
        source="get_country_display", read_only=True
    )
    study_level_display = serializers.CharField(
        source="get_study_level_display", read_only=True
    )
    featured_image_url = serializers.SerializerMethodField()
    country_flag_url = serializers.SerializerMethodField()

    class Meta:
        model = Guideline
        fields = [
            "id",
            "title",
            "slug",
            "country",
            "country_display",
            "study_level",
            "study_level_display",
            "short_description",
            "featured_image",
            "featured_image_url",
            "country_flag",
            "country_flag_url",
            "is_featured",
            "views_count",
            "published_date",
            "created_at",
        ]

    def get_featured_image_url(self, obj):
        if obj.featured_image:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.featured_image.url)
            return obj.featured_image.url
        return None

    def get_country_flag_url(self, obj):
        if obj.country_flag:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.country_flag.url)
            return obj.country_flag.url
        return None


class GuidelineDetailSerializer(serializers.ModelSerializer):
    country_display = serializers.CharField(
        source="get_country_display", read_only=True
    )
    study_level_display = serializers.CharField(
        source="get_study_level_display", read_only=True
    )
    featured_image_url = serializers.SerializerMethodField()
    country_flag_url = serializers.SerializerMethodField()
    related_guidelines = serializers.SerializerMethodField()
    overview = CKEditor5Field()
    eligibility_criteria = CKEditor5Field()
    language_requirements = CKEditor5Field()
    financial_requirements = CKEditor5Field()
    application_process = CKEditor5Field()
    deadline_information = CKEditor5Field()
    visa_process = CKEditor5Field()
    tuition_fees = CKEditor5Field()
    living_costs = CKEditor5Field()
    scholarship_info = CKEditor5Field()
    working_while_studying = CKEditor5Field()
    post_study_options = CKEditor5Field()
    useful_resources = CKEditor5Field()
    class Meta:
        model = Guideline
        fields = [
            "id",
            "title",
            "slug",
            "country",
            "country_display",
            "study_level",
            "study_level_display",
            # Basic Content
            "short_description",
            "overview",
            # Requirements
            "eligibility_criteria",
            "language_requirements",
            "financial_requirements",
            # Application Process
            "application_process",
            "deadline_information",
            "visa_process",
            # Costs & Funding
            "tuition_fees",
            "living_costs",
            "scholarship_info",
            # Additional Information
            "working_while_studying",
            "post_study_options",
            "useful_resources",
            # Media
            "featured_image",
            "featured_image_url",
            "country_flag",
            "country_flag_url",
            # Metadata
            "is_featured",
            "status",
            "order",
            "views_count",
            "created_at",
            "updated_at",
            "published_date",
            # SEO
            "meta_title",
            "meta_description",
            # Related
            "related_guidelines",
        ]
        read_only_fields = ["views_count", "created_at", "updated_at"]

    def get_featured_image_url(self, obj):
        if obj.featured_image:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.featured_image.url)
            return obj.featured_image.url
        return None

    def get_country_flag_url(self, obj):
        if obj.country_flag:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.country_flag.url)
            return obj.country_flag.url
        return None

    def get_related_guidelines(self, obj):
        # Get guidelines from same country, excluding current one
        related = (
            Guideline.objects.filter(country=obj.country, status="published")
            .exclude(id=obj.id)
            .order_by("-is_featured", "-views_count")[:4]
        )

        return GuidelineListSerializer(related, many=True, context=self.context).data


# Minimal serializer for dropdowns and filters
class GuidelineMinimalSerializer(serializers.ModelSerializer):
    country_display = serializers.CharField(
        source="get_country_display", read_only=True
    )

    class Meta:
        model = Guideline
        fields = [
            "id",
            "title",
            "slug",
            "country",
            "country_display",
            "featured_image",
            "study_level",
        ]


class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = "__all__"


class EmailSerializer(serializers.Serializer):
    email = serializers.EmailField()
    subject = serializers.CharField(max_length=255)
    message = serializers.CharField()
    phone = serializers.CharField(
        max_length=11, required=False, allow_null=True, allow_blank=True
    )


class FAQSerializer(serializers.ModelSerializer):
    class Meta:
        model = FAQ
        fields = ["id", "question", "answer"]


class OwnerInfoSerializer(serializers.ModelSerializer):
    class Meta:
        model = OwnerInfo
        fields = "__all__"

    def to_representation(self, instance):
        """Custom representation to handle image URLs"""
        representation = super().to_representation(instance)
        request = self.context.get('request')
        
        # Handle all FileField/ImageField fields
        file_fields = ['logo', 'favicon', 'banner_image']  # Add your actual image field names here
        
        for field in file_fields:
            if hasattr(instance, field) and getattr(instance, field):
                file_obj = getattr(instance, field)
                if request is not None:
                    representation[field] = request.build_absolute_uri(file_obj.url)
                else:
                    representation[field] = file_obj.url
        
        return representation


class PageSectionItemSerializer(serializers.ModelSerializer):
    image = serializers.SerializerMethodField()
    description = CKEditor5Field()

    class Meta:
        model = PageSectionItem
        fields = [
            "id",
            "title",
            "subtitle",
            "description",
            "icon",
            "image",
            "key_points",
            "metadata",
            "order",
            "is_active",
            "button_text",
            "button_url",
        ]

    def get_image(self, obj):
        if obj.image:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.image.url)
            return obj.image.url
        return None


class PageSectionTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = PageSectionType
        fields = ["id", "name"]


class PageSectionSerializer(serializers.ModelSerializer):
    items = PageSectionItemSerializer(many=True, read_only=True)
    section_type = PageSectionTypeSerializer(read_only=True)
    image = serializers.SerializerMethodField()
    background_image = serializers.SerializerMethodField()
    description = CKEditor5Field()

    class Meta:
        model = PageSection
        fields = [
            "id",
            "section_type",
            "name",
            "title",
            "subtitle",
            "description",
            "icon",
            "image",
            "background_image",
            "content_alignment",
            "background_color",
            "text_color",
            "is_visible",
            "order",
            "key_points",
            "metadata",
            "items",
        ]

    def get_image(self, obj):
        if obj.image:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.image.url)
            return obj.image.url
        return None

    def get_background_image(self, obj):
        if obj.background_image:
            request = self.context.get('request')
            if request is not None:
                return request.build_absolute_uri(obj.background_image.url)
            return obj.background_image.url
        return None


class PageSerializer(serializers.ModelSerializer):
    sections = PageSectionSerializer(many=True, read_only=True)
    description = CKEditor5Field()

    class Meta:
        model = Page
        fields = [
            "id",
            "name",
            "slug",
            "title",
            "description",
            "meta_description",
            "is_active",
            "order",
            "sections",
        ]


class PageListSerializer(serializers.ModelSerializer):
    """Lightweight serializer for page listings"""

    class Meta:
        model = Page
        fields = ["id", "name", "slug", "title", "is_active", "order"]