from rest_framework import serializers
from rest_framework.reverse import reverse
from .models import Document, DocumentType, DocumentSubType
from django.contrib.contenttypes.models import ContentType 
from django.urls import NoReverseMatch
from django.conf import settings

class ContentTypeModelSerializer(serializers.ModelSerializer):
    '''Model Serializer for ContentType'''

    model_url = serializers.SerializerMethodField()
    def get_model_url(self, obj):
        try:
            return reverse(f'{obj.app_label}:{obj.model}-list', request=self.context['request'])
        except NoReverseMatch:
            return None

    model_repr_field = serializers.SerializerMethodField()
    def get_model_repr_field(self, obj):
        try:
            return settings.FILES_LINKED_MODELS[f'{obj.app_label}.{obj.model}'][3]
        except IndexError:
            return None

    class Meta:
        model = ContentType
        fields = (
            "id",
            'app_label',
            'model',
            'model_url',
            'model_repr_field',
        )


class DocumentTypeModelSerializer(serializers.ModelSerializer):
    '''Model Serializer for DocumentType'''

    class Meta:
        model = DocumentType
        fields = (
            "id",
            "name",
            "slug",
        )


class DocumentSubTypeModelSerializer(serializers.ModelSerializer):
    '''Model Serializer for DocumentSubType'''

    document_type_repr = serializers.StringRelatedField(many=False, read_only=True, source='document_type')

    class Meta:
        model = DocumentSubType
        fields = (
            "id",
            "name",
            "slug",
            "document_type",
            "document_type_repr",
        )


class DocumentModelSerializer(serializers.ModelSerializer):
    '''Model Serializer for Document'''

    content_type = serializers.PrimaryKeyRelatedField(many=False, required=False, queryset=ContentType.objects.filter(
        app_label__in=[model_definition[0] for _, model_definition in settings.FILES_LINKED_MODELS.items()],
        model__in=[model_definition[1] for _, model_definition in settings.FILES_LINKED_MODELS.items()],
    ))
    content_type_repr = serializers.StringRelatedField(many=False, read_only=True, source='content_type')

    document_type_repr = serializers.StringRelatedField(many=False, read_only=True, source='document_type')
    document_sub_type_repr = serializers.StringRelatedField(many=False, read_only=True, source='document_sub_type')

    linked_model_repr = serializers.SerializerMethodField()
    def get_linked_model_repr(self, obj):
        return str(obj.linked_model) if obj.linked_model else None

    linked_model_url = serializers.SerializerMethodField()
    def get_linked_model_url(self, obj):
        try:
            if obj.content_type:
                return reverse(f'{obj.content_type.app_label}:{obj.content_type.model}-detail', args=[obj.object_id,], request=self.context['request'])
            else:
                return None
        except NoReverseMatch:
            return None

    class Meta:
        model = Document
        fields = (
            "id",
            'name',
            'slug',
            'description',
            'created',
            'last_modified',
            'file',
            'document_type',
            'document_type_repr',
            'document_sub_type',
            'document_sub_type_repr',
            'content_type',
            'content_type_repr',
            'object_id',
            'linked_model_repr',
            'linked_model_url',
        )


class DocumentsField(serializers.ReadOnlyField):
    '''Reverse Lookup Url for Files'''

    def get_attribute(self, obj):
        content_type = ContentType.objects.get_for_model(obj)
        return {
            'content_type': content_type.id,
            'url': f'{reverse("files:document-list", request=self.context["request"])}?content_type={content_type.id}&object_id={obj.id}',
            # 'documents': Document.objects.filter(content_type=content_type, object_id=obj.id).count() #TODO: Potential Bottleneck...
        }