Dovodi_Backend/apps/hadis/serializers/hadis.py

from rest_framework import serializers
from django.utils.translation import gettext_lazy as _
from urllib3 import fields

from ..models import (
    Hadis, HadisStatus, HadisTag, HadisTransmitter,
    HadisReference, ReferenceImage, Transmitters, HadisCollection,
    TransmitterOpinion, BookReference, BookReferenceImage, BookAuthor, HadisCorrection
)
from apps.library.serializers import BookSerializer


class HadisCollectionListSerializer(serializers.ModelSerializer):
    thumbnail = serializers.SerializerMethodField()

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

    def get_thumbnail(self, obj):
        if obj.thumbnail:
            request = self.context.get('request')
            if request:
                return request.build_absolute_uri(obj.thumbnail.url)
            return obj.thumbnail.url
        return None


class HadisSyncSerializer(serializers.ModelSerializer):
    """Serializer for syncing all hadis data"""
    translations = serializers.SerializerMethodField()
    hadis_status = serializers.SerializerMethodField()
    tags = serializers.SerializerMethodField()
    transmitters = serializers.SerializerMethodField()
    description = serializers.SerializerMethodField()
    references = serializers.SerializerMethodField()
    corrections = serializers.SerializerMethodField()

    class Meta:
        model = Hadis
        fields = [
            'id', 'number', 'category_id', 'title', 'title_narrator',
            'text', 'translations', 'explanation', 'address', 'description',
            'hadis_status', 'hadis_status_text', 'share_link', 'tags', 'links',
            'transmitters', 'references', 'corrections'
        ]
    
    def get_translations(self, obj):
        """Get all translations"""
        translations_dict = {}
        if obj.translation and isinstance(obj.translation, list):
            for tr in obj.translation:
                if isinstance(tr, dict):
                    lang_code = tr.get('language_code')
                    title = tr.get('title')
                    if lang_code:
                        translations_dict[lang_code] = title
        return translations_dict
    
    def get_hadis_status(self, obj):
        """Get hadis status info"""
        if obj.hadis_status:
            return {
                'id': obj.hadis_status.id,
                'title': obj.hadis_status.title,
                'color': obj.hadis_status.color
            }
        return None
    
    def get_tags(self, obj):
        """Get tags"""
        return [{'id': tag.id, 'title': tag.title} for tag in obj.tags.all()]

    def get_transmitters(self, obj):
        """Get transmitters with their details"""
        transmitters_data = []
        for transmitter_rel in obj.transmitters.all().order_by('order'):
            transmitter_info = {
                'id': transmitter_rel.id,
                'order': transmitter_rel.order,
                'is_gap': transmitter_rel.is_gap,
                'narrator_layer': transmitter_rel.narrator_layer,
                'transmitter': {
                    'id': transmitter_rel.transmitter.id,
                    'full_name': transmitter_rel.transmitter.full_name,
                    'birth_year_hijri': transmitter_rel.transmitter.birth_year_hijri,
                    'death_year_hijri': transmitter_rel.transmitter.death_year_hijri,
                    'madhhab': transmitter_rel.transmitter.madhhab,
                    'description': transmitter_rel.transmitter.description,
                    'reliability': transmitter_rel.transmitter.reliability
                }
            }
            transmitters_data.append(transmitter_info)
        return transmitters_data

    def get_description(self, obj):
        """Get hadis description"""
        return getattr(obj, 'description', None)

    def get_references(self, obj):
        """Get references with book information"""
        references_data = []
        for reference in obj.references.all():
            try:
                book = reference.book_reference
                reference_info = {
                    'id': reference.id,
                    'title': book.title if book else None,
                    'images': [
                        {
                            'id': img.id,
                            'image': img.image.url if img.image else None,
                            'order': img.order,
                            'description': img.description
                        } for img in book.images.all() if book
                    ] if book else [],
                    'authors': [
                        {
                            'id': author.id,
                            'name': author.name
                        } for author in book.authors.all() if book
                    ] if book else [],
                    'description': book.description if book else None
                }
                references_data.append(reference_info)
            except:
                continue
        return references_data

    def get_corrections(self, obj):
        """Get hadis corrections"""
        corrections_data = []
        for correction in obj.hadiscorrection_set.all():
            correction_info = {
                'id': correction.id,
                'title': correction.title,
                'description': correction.description,
                'translation': correction.translation
            }
            corrections_data.append(correction_info)
        return corrections_data


class HadisListSerializer(serializers.ModelSerializer):
    """Serializer for Hadis list"""
    category = serializers.SerializerMethodField()
    translation = serializers.SerializerMethodField()
    
    class Meta:
        model = Hadis
        fields = ['id', 'number', 'title', 'text' ,'category', 'translation']
    
    def get_category(self, obj):
        """Get category id and title"""
        if obj.category:
            return {
                'id': obj.category.id,
                'title': obj.category.title
            }
        return None
    
    def get_translation(self, obj):
        """Get translation based on request language"""
        request = self.context.get('request')
        language_code = getattr(request, 'LANGUAGE_CODE', 'en')
        return obj.get_translation(language_code)


class HadisStatusSerializer(serializers.ModelSerializer):
    """Serializer for HadisStatus"""

    class Meta:
        model = HadisStatus
        fields = ['id', 'title', 'color']


class HadisTagSerializer(serializers.ModelSerializer):
    """Serializer for HadisTag"""

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


class TransmitterSerializer(serializers.ModelSerializer):
    """Serializer for Transmitters"""

    class Meta:
        model = Transmitters
        fields = [
            'id', 'full_name', 'birth_year_hijri', 'death_year_hijri',
            'description','reliability','madhhab',
        ]
class TransmitterOpinionSerializer(serializers.ModelSerializer):
    """ Serializer for TransmitterOpinions """

    class Meta:
        model = TransmitterOpinion
        fields = '__all__'

class HadisTransmitterSerializer(serializers.ModelSerializer):
    """ Serializer for HadisTransmitters """

    class Meta:
        model = HadisTransmitter
        fields = '__all__'

class TransmitterDetailSerializer(serializers.ModelSerializer):
    """ Serializer for Details of Transmitters """

    opinions = TransmitterOpinionSerializer(
        many=True,
        read_only=True,
    )

    hadis_transmissions = HadisTransmitterSerializer(
        source='hadis',
        many=True,
        read_only=True,
    )
    class Meta:
        model = Transmitters
        fields = [
            'id','full_name','kunya','known_as','nickname',
            'origin','lived_in','died_in','birth_year_hijri',
            'death_year_hijri','age_at_death','reliability',
            'madhhab',"in_sahih_muslim","in_sahih_bukhari","description",
            "thumbnail",'opinions','hadis_transmissions'
        ]


class TransmitterSyncSerializer(serializers.ModelSerializer):
    """Serializer for syncing all transmitter data for offline mode"""

    # Biographical data group
    biographical = serializers.SerializerMethodField()

    # Scholar's opinions group
    scholars_opinions = serializers.SerializerMethodField()

    class Meta:
        model = Transmitters
        fields = [
            'id', 'full_name', 'biographical', 'scholars_opinions'
        ]

    def get_biographical(self, obj):
        """Get biographical information"""
        return {
            'personal_info': {
                'full_name': obj.full_name,
                'kunya': obj.kunya,
                'known_as': obj.known_as,
                'nickname': obj.nickname,
            },
            'dates': {
                'birth_year_hijri': obj.birth_year_hijri,
                'death_year_hijri': obj.death_year_hijri,
                'age_at_death': obj.age_at_death,
            },
            'locations': {
                'origin': obj.origin,
                'lived_in': obj.lived_in,
                'died_in': obj.died_in,
            },
            'religious_profile': {
                'reliability': obj.reliability,
                'madhhab': obj.madhhab,
                'in_sahih_muslim': obj.in_sahih_muslim,
                'in_sahih_bukhari': obj.in_sahih_bukhari,
            },
            'description': obj.description,
            'thumbnail': obj.thumbnail.url if obj.thumbnail else None,
        }

    def get_scholars_opinions(self, obj):
        """Get all scholarly opinions about this transmitter"""
        opinions = []
        for opinion in obj.opinions.all():
            opinions.append({
                'id': opinion.id,
                'scholar_name': opinion.scholar_name,
                'opinion_text': opinion.opinion_text,
                'status': opinion.status,
                'created_at': opinion.created_at.isoformat() if opinion.created_at else None,
                'updated_at': opinion.updated_at.isoformat() if opinion.updated_at else None,
            })
        return opinions     



class HadisTransmitterSerializer(serializers.ModelSerializer):
    """Serializer for HadisTransmitter with transmitter details"""
    transmitter = TransmitterSerializer(read_only=True)

    class Meta:
        model = HadisTransmitter
        fields = [
            'id', 'transmitter', 'order', 'is_gap','narrator_layer'
        ]


class ReferenceImageSerializer(serializers.ModelSerializer):
    """Serializer for ReferenceImage"""
    thumbnail = serializers.SerializerMethodField()

    class Meta:
        model = ReferenceImage
        fields = ['id', 'thumbnail', 'priority']

    def get_thumbnail(self, obj):
        """Get thumbnail URL"""
        if obj.image:
            request = self.context.get('request')
            if request:
                return request.build_absolute_uri(obj.image.url)
            return obj.image.url
        return None


class HadisReferenceSerializer(serializers.ModelSerializer):
    """Serializer for HadisReference with book and images"""
    book_title = serializers.SerializerMethodField()
    book_images = serializers.SerializerMethodField()
    book_authors = serializers.SerializerMethodField()
    book_description = serializers.SerializerMethodField()
    class Meta:
        model = HadisReference
        fields = [
            'id', 'book_title', 'book_images', 'book_authors', 'book_description'
        ]
    
    def get_book_title(self, obj):
        """Get book title"""
        try :
            title = obj.book_reference.title
            return title
        except:
            return None
    
    def get_book_images(self, obj):
        """Get book images"""
        try :
            images = obj.book_reference.images.all()
            return images
        except:
            return None
    
    def get_book_authors(self, obj):
        """Get book authors"""
        try :
            authors = obj.book_reference.authors.all()
            return authors
        except:
            return None

    def get_book_description(self, obj):
        """Get book description"""
        try :
            description = obj.book_reference.description
            return description
        except:
            return None

class HadisCorrectionSerializer(serializers.ModelSerializer):
    """Serializer for HadisCorrection"""
    hadis_translation = serializers.SerializerMethodField()
    class Meta:
        model = HadisCorrection
        fields = ['id', 'title', 'description', 'hadis_translation', 'created_at', 'updated_at']
    
    def get_hadis_translation(self, obj):
        """Get translation based on request language"""
        request = self.context.get('request')
        language_code = getattr(request, 'LANGUAGE_CODE', 'en')
        return obj.translation.get(language_code, '')


class HadisDetailSerializer(serializers.ModelSerializer):
    """Detailed serializer for Hadis with all related objects"""
    hadis_status = HadisStatusSerializer(read_only=True)
    tags = HadisTagSerializer(many=True, read_only=True)
    transmitters = HadisTransmitterSerializer(
        many=True,
        read_only=True
    )
    references = HadisReferenceSerializer(
        many=True,
        read_only=True
    )
    corrections = HadisCorrectionSerializer(
        source='hadiscorrection_set',
        many=True,
        read_only=True
    )
    category = serializers.SerializerMethodField()
    translation = serializers.SerializerMethodField()

    class Meta:
        model = Hadis
        fields = [
            'id', 'number', 'title', 'title_narrator','text', 'translation', 'explanation',
            'address', 'hadis_status_text', 'links','share_link', 'status',
            'category', 'hadis_status', 'tags', 'transmitters', 'description',
             'references', 'corrections'
        ]

    def get_category(self, obj):
        """Get category details"""
        if obj.category:
            return {
                'id': obj.category.id,
                'title': obj.category.title,
                'category_type': obj.category.content_type
            }
        return None

    def get_translation(self, obj):
        """Get translation based on request language"""
        request = self.context.get('request')
        language_code = getattr(request, 'LANGUAGE_CODE', 'en')
        return obj.get_translation(language_code)