from urllib.parse import urlparse, urlunparse
from rest_framework import serializers

from apps.content.models import (
    Baner, Content, Image, Text, ImageText, Video,
    Gallery, GalleryImage, ImageObject,)

from . import Base64ImageField


BASE_CONTENT_FIELDS = (
    'id',
    'uuid',
    'course',
    'lesson',
    'contest',
    'live_lesson',
    'title',
    'position',
    'type',
    'created_at',
    'update_at',
)


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

    class Meta:
        model = Baner
        fields = (
            'id',
            'text',
            'button_text',
            'url',
            'image',
            'use',
            'created_at',
            'update_at',
        )

        read_only_fields = (
            'id',
            'created_at',
            'update_at',
        )

    def get_image(self, baner):
        request = self.context.get('request')
        http_host = request.META.get('HTTP_ORIGIN')
        if http_host and baner.image:
            domain = urlparse(http_host).netloc.split(':')[0]
            baner_url = 'http://' + domain + baner.image.url
            return baner_url
        else:
            return None


class ContentCreateSerializer(serializers.Serializer):
    TYPE_CHOICES = (
        'text',
        'image',
        'image-text',
        'images',
        'video',
    )
    type = serializers.ChoiceField(choices=TYPE_CHOICES)
    data = serializers.JSONField()

    def to_representation(self, obj):
        if isinstance(obj, Image):
            return ImageSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, Text):
            return TextSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, ImageText):
            return ImageTextSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, Video):
            return VideoSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, Gallery):
            return GallerySerializer(obj, context=self.context).to_representation(obj)
        return super(ContentSerializer, self).to_representation(obj)


class ImageObjectSerializer(serializers.ModelSerializer):
    image = Base64ImageField(
        required=True, allow_empty_file=False, allow_null=False, read_only=False,
    )

    class Meta:
        model = ImageObject
        fields = (
            'id',
            'image',
            'created_at',
            'update_at',
        )

        read_only_fields = (
            'id',
            'created_at',
            'update_at',
        )


class ImageCreateSerializer(serializers.ModelSerializer):
    type = serializers.SerializerMethodField()

    class Meta:
        model = Image
        fields = BASE_CONTENT_FIELDS + ('img',)

        read_only_fields = (
            'id',
            'type',
            'created_at',
            'update_at',
        )

    def get_type(self, object):
        return 'image'


class ImageSerializer(ImageCreateSerializer):
    img = ImageObjectSerializer()


class TextCreateSerializer(serializers.ModelSerializer):
    type = serializers.SerializerMethodField()

    class Meta:
        model = Text
        fields = BASE_CONTENT_FIELDS + ('txt',)

        read_only_fields = (
            'id',
            'type',
            'created_at',
            'update_at',
        )

    def get_type(self, object):
        return 'text'


class TextSerializer(TextCreateSerializer):
    pass


class ImageTextCreateSerializer(serializers.ModelSerializer):
    type = serializers.SerializerMethodField()

    class Meta:
        model = ImageText
        fields = BASE_CONTENT_FIELDS + ('img', 'txt',)

        read_only_fields = (
            'id',
            'type',
            'created_at',
            'update_at',
        )

    def get_type(self, object):
        return 'image-text'


class ImageTextSerializer(ImageTextCreateSerializer):
    img = ImageObjectSerializer()


class VideoCreateSerializer(serializers.ModelSerializer):
    type = serializers.SerializerMethodField()

    class Meta:
        model = Video
        fields = BASE_CONTENT_FIELDS + ('url',)

        read_only_fields = (
            'id',
            'type',
            'created_at',
            'update_at',
        )

    def get_type(self, object):
        return 'video'


class VideoSerializer(VideoCreateSerializer):
    pass


class GalleryImageCreateSerializer(serializers.ModelSerializer):

    class Meta:
        model = GalleryImage
        fields = (
            'id',
            'gallery',
            'img',
            'created_at',
            'update_at',
        )

        read_only_fields = (
            'id',
            'created_at',
            'update_at',
        )


class GalleryImageSerializer(GalleryImageCreateSerializer):
    img = ImageObjectSerializer()


class GallerySerializer(serializers.ModelSerializer):
    type = serializers.SerializerMethodField()
    gallery_images = GalleryImageSerializer(many=True)

    class Meta:
        model = Gallery
        fields = BASE_CONTENT_FIELDS + ('gallery_images',)

        read_only_fields = (
            'id',
            'type',
            'created_at',
            'update_at',
        )

    def get_type(self, object):
        return 'images'


class ContentSerializer(serializers.ModelSerializer):
    type = serializers.SerializerMethodField()

    class Meta:
        model = Content
        fields = BASE_CONTENT_FIELDS

    def get_type(self, object):
        return 'content'

    def to_representation(self, obj):
        if isinstance(obj, Image):
            return ImageSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, Text):
            return TextSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, ImageText):
            return ImageTextSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, Video):
            return VideoSerializer(obj, context=self.context).to_representation(obj)
        elif isinstance(obj, Gallery):
            return GallerySerializer(obj, context=self.context).to_representation(obj)
        return super(ContentSerializer, self).to_representation(obj)