from rest_framework import serializers
from rest_framework.pagination import PageNumberPagination
from ..models import BookReference, BookAuthor, BookEdition, BookVolume, BookTag, BookResearcher, BookEditor
from .category import get_localized_text
from apps.hadis.serializers import HadisListSerializer, HadisShortSerializer
from ..serializers.category import LocalizedField
from ..serializers.reference import BookAttributeSerializer, BookReferenceImageSerializer
from utils import absolute_https_url

class BookTagV2Serializer(serializers.ModelSerializer):
    title = LocalizedField()
    class Meta:
        model = BookTag
        fields = ['id', 'title']

class BookAuthorV2Serializer(serializers.ModelSerializer):
    name = LocalizedField()
    class Meta:
        model = BookAuthor
        fields = ['id', 'name', 'slug', 'image']

class BookResearcherV2Serializer(serializers.ModelSerializer):
    name = LocalizedField()
    author = BookAuthorV2Serializer(read_only=True)
    author_id = serializers.SerializerMethodField()
    slug = serializers.SerializerMethodField()

    class Meta:
        model = BookResearcher
        fields = ['id', 'name', 'slug', 'author', 'author_id']

    def get_author_id(self, obj):
        return obj.author_id

    def get_slug(self, obj):
        if obj.author and obj.author.slug:
            return obj.author.slug
        return obj.slug

class BookEditorV2Serializer(serializers.ModelSerializer):
    name = LocalizedField()
    author = BookAuthorV2Serializer(read_only=True)
    author_id = serializers.SerializerMethodField()
    slug = serializers.SerializerMethodField()

    class Meta:
        model = BookEditor
        fields = ['id', 'name', 'slug', 'author', 'author_id']

    def get_author_id(self, obj):
        return obj.author_id

    def get_slug(self, obj):
        if obj.author and obj.author.slug:
            return obj.author.slug
        return obj.slug

class BookReferenceV2ListSerializer(serializers.ModelSerializer):
    title = LocalizedField()
    authors = serializers.SerializerMethodField()
    tag = BookTagV2Serializer(read_only=True)
    number_of_volumes = serializers.SerializerMethodField()
    image = serializers.SerializerMethodField()

    class Meta:
        model = BookReference
        fields = ['id', 'slug', 'title', 'authors', 'number_of_volumes', 'tag', 'image']

    def get_authors(self, obj):
        if obj.author:
            return [BookAuthorV2Serializer(obj.author, context=self.context).data]
        return []

    def get_number_of_volumes(self, obj):
        return obj.volumes.count()

    def get_image(self, obj):
        if hasattr(obj, 'thumbnail') and obj.thumbnail:
            request = self.context.get('request')
            if request:
                return absolute_https_url(obj.thumbnail.url, request)
            return absolute_https_url(obj.thumbnail.url)
        first_volume = obj.volumes.first()
        if first_volume:
            if first_volume.image:
                request = self.context.get('request')
                if request:
                    return absolute_https_url(first_volume.image.url, request)
                return absolute_https_url(first_volume.image.url)
            first_image = first_volume.images.order_by('order').first()
            if first_image and first_image.image:
                request = self.context.get('request')
                if request:
                    return absolute_https_url(first_image.image.url, request)
                return absolute_https_url(first_image.image.url)
        return None

class BookEditionV2Serializer(serializers.ModelSerializer):
    publisher = LocalizedField()
    notes = LocalizedField()
    tag = BookTagV2Serializer(read_only=True)
    publication_place = serializers.SerializerMethodField()
    researchers = BookResearcherV2Serializer(many=True, read_only=True)
    editors = BookEditorV2Serializer(many=True, read_only=True)
    number_of_volumes = serializers.SerializerMethodField()

    class Meta:
        model = BookEdition
        fields = [
            'id', 'publisher', 'publication_place', 'edition_number', 
            'year_of_publication', 'number_of_volumes', 'notes', 'source_url', 'tag',
            'researchers', 'editors'
        ]

    def get_number_of_volumes(self, obj):
        count = obj.volumes.count()
        if count > 0:
            return count
        return obj.number_of_volumes or 0

    def get_publication_place(self, obj):
        request = self.context.get("request")
        city = get_localized_text(obj.city_of_publication, request) if obj.city_of_publication else ""
        country = get_localized_text(obj.country_of_publication, request) if obj.country_of_publication else ""
        return {
            "city": city,
            "country": country
        }

class BookVolumeV2Serializer(serializers.ModelSerializer):
    image = serializers.SerializerMethodField()

    class Meta:
        model = BookVolume
        fields = ['id', 'title', 'image']

    def get_image(self, obj):
        request = self.context.get('request')
        if obj.image:
            if request:
                return absolute_https_url(obj.image.url, request)
            return absolute_https_url(obj.image.url)
        first_image = obj.images.order_by('order').first()
        if first_image and first_image.image:
            if request:
                return absolute_https_url(first_image.image.url, request)
            return absolute_https_url(first_image.image.url)
        return None

class BookReferenceV2DetailSerializer(serializers.ModelSerializer):
    title = LocalizedField()
    authors = serializers.SerializerMethodField()
    image = serializers.SerializerMethodField()
    tag = BookTagV2Serializer(read_only=True)
    
    information = serializers.SerializerMethodField()
    volumes = serializers.SerializerMethodField()

    class Meta:
        model = BookReference
        fields = ['id', 'title', 'authors', 'image', 'tag', 'information', 'volumes']

    def get_authors(self, obj):
        if obj.author:
            return [BookAuthorV2Serializer(obj.author, context=self.context).data]
        return []

    def get_image(self, obj):
        first_image = obj.images.filter(book_volume__isnull=True).order_by('order').first()
        if not first_image:
            first_image = obj.images.order_by('order').first()
        if first_image and first_image.image:
            request = self.context.get('request')
            if request:
                return absolute_https_url(first_image.image.url, request)
            return absolute_https_url(first_image.image.url)
        return None

    def get_information(self, obj):
        request = self.context.get("request")
        summary = get_localized_text(obj.description, request) if obj.description else ""
        valid_editions = [ed for ed in obj.editions.all() if ed.volumes.exists()]
        editions = BookEditionV2Serializer(valid_editions, many=True, context=self.context).data
        
        return {
            "summary": summary,
            "editions": editions
        }

    def get_volumes(self, obj):
        if obj.has_editions:
            editions = obj.editions.all()
            editions_data = []
            for ed in editions:
                vol_qs = ed.volumes.all()
                if not vol_qs.exists():
                    continue
                editions_data.append({
                    "edition_id": ed.id,
                    "edition_statement": ed.edition_number or f"Edition {ed.id}",
                    "volumes": BookVolumeV2Serializer(vol_qs, many=True, context=self.context).data
                })
            return {
                "has_editions": True,
                "editions_volumes": editions_data,
                "all_volumes": []
            }
        else:
            return {
                "has_editions": False,
                "editions_volumes": [],
                "all_volumes": BookVolumeV2Serializer(obj.volumes.all(), many=True, context=self.context).data
            }

class BookReferenceV2SyncSerializer(serializers.ModelSerializer):
    title = LocalizedField()
    authors = serializers.SerializerMethodField()
    attributes = BookAttributeSerializer(many=True, read_only=True)
    images = BookReferenceImageSerializer(many=True, read_only=True)
    
    information = serializers.SerializerMethodField()
    hadises = serializers.SerializerMethodField()
    volumes = serializers.SerializerMethodField()

    class Meta:
        model = BookReference
        fields = [
            'id', 'title', 'slug', 'share_link', 'rate', 'has_editions', 'authors', 
            'attributes', 'images', 'information', 'hadises', 'volumes'
        ]

    def get_authors(self, obj):
        if obj.author:
            return [BookAuthorV2Serializer(obj.author, context=self.context).data]
        return []

    def get_information(self, obj):
        request = self.context.get("request")
        summary = get_localized_text(obj.description, request) if obj.description else ""
        valid_editions = [ed for ed in obj.editions.all() if ed.volumes.exists()]
        editions = BookEditionV2Serializer(valid_editions, many=True, context=self.context).data
        return {
            "summary": summary,
            "editions": editions,
            "language": get_localized_text(obj.language, request) if obj.language else "",
            "number_page": obj.number_page
        }

    def get_hadises(self, obj):
        references = obj.hadis_references.all()
        hadis_list = [ref.hadis for ref in references if ref.hadis]
        return HadisShortSerializer(hadis_list, many=True, context=self.context).data

    def get_volumes(self, obj):
        if obj.has_editions:
            editions = obj.editions.all()
            editions_data = []
            for ed in editions:
                vol_qs = ed.volumes.all()
                if not vol_qs.exists():
                    continue
                editions_data.append({
                    "edition_id": ed.id,
                    "edition_statement": ed.edition_number or f"Edition {ed.id}",
                    "volumes": BookVolumeV2Serializer(vol_qs, many=True, context=self.context).data
                })
            return {
                "has_editions": True,
                "editions_volumes": editions_data,
                "all_volumes": []
            }
        else:
            return {
                "has_editions": False,
                "editions_volumes": [],
                "all_volumes": BookVolumeV2Serializer(obj.volumes.filter(edition__isnull=True), many=True, context=self.context).data
            }

from apps.hadis.models.reference import BookAuthor, BookReference
from .category import LocalizedField

class BookAuthorListSerializer(serializers.ModelSerializer):
    """سریالایزر برای لیست نویسنده‌ها"""
    name = LocalizedField()

    class Meta:
        model = BookAuthor
        fields = ['id', 'slug', 'name', 'image', 'birth_year_hijri', 'birth_year_miladi']


class BookAuthorDetailSerializer(serializers.ModelSerializer):
    """سریالایزر برای دیتیل یک نویسنده"""
    name = LocalizedField()
    known_as = LocalizedField()
    scholarity = LocalizedField()
    tabaqa = LocalizedField()
    rutba = LocalizedField()
    features = LocalizedField()
    related_narrator_slug = serializers.CharField(source='related_narrator.slug', read_only=True, allow_null=True)

    class Meta:
        model = BookAuthor
        fields = [
            'id', 'slug', 'name', 'image', 'known_as', 'scholarity', 
            'tabaqa', 'rutba', 'features', 
            'birth_year_hijri', 'death_year_hijri', 
            'birth_year_miladi', 'death_year_miladi',
            'related_narrator_slug'
        ]


class AuthorBookReferenceSerializer(serializers.ModelSerializer):
    """سریالایزر برای لیست رفرنس‌های (کتاب‌های) یک نویسنده"""
    title = LocalizedField()
    authors = serializers.SerializerMethodField()
    thumbnail = serializers.SerializerMethodField()

    class Meta:
        model = BookReference
        fields = ['id', 'slug', 'title', 'thumbnail', 'authors']

    def get_authors(self, obj):
        field = LocalizedField()
        field._context = self.context
        return [field.to_representation(obj.author.name)] if obj.author else []

    def get_thumbnail(self, obj):
        # گرفتن اولین عکس آپلود شده برای این رفرنس
        first_image = obj.images.order_by('order').first()
        if first_image and first_image.image:
            request = self.context.get('request')
            if request:
                return absolute_https_url(first_image.image.url, request)
            return absolute_https_url(first_image.image.url)
        return None

# یک سریالایزر مینیمال برای کتاب‌ها داخل سینک
class BookAuthorSyncReferenceSerializer(serializers.ModelSerializer):
    title = LocalizedField()
    
    class Meta:
        model = BookReference
        fields = ['id', 'slug', 'title']

class BookAuthorSyncSerializer(serializers.ModelSerializer):
    """
    سریالایزر برای سینک آفلاین تمام نویسنده‌ها.
    شامل تمام اطلاعات و لیست کتاب‌های متصل به این نویسنده.
    """
    name = LocalizedField()
    known_as = LocalizedField()
    scholarity = LocalizedField()
    tabaqa = LocalizedField()
    rutba = LocalizedField()
    features = LocalizedField()
    related_narrator_slug = serializers.CharField(source='related_narrator.slug', read_only=True, allow_null=True)
    
    # اضافه کردن لیست کتاب‌ها
    books = BookAuthorSyncReferenceSerializer(source='book_references', many=True, read_only=True)

    class Meta:
        model = BookAuthor
        fields = [
            'id', 
            'slug', 
            'name', 
            'known_as', 
            'scholarity', 
            'tabaqa', 
            'rutba', 
            'features', 
            'birth_year_hijri', 
            'death_year_hijri',
            'birth_year_miladi', 
            'death_year_miladi',
            'books',  # 👈 لیست کتاب‌های هر نویسنده
            'related_narrator_slug'
        ]