from rest_framework import serializers

from collection import models
from location import models as location_models
from main.serializers import SiteShortSerializer
from utils.serializers import TranslatedField


class CollectionBaseSerializer(serializers.ModelSerializer):
    """Collection base serializer"""
    name_translated = TranslatedField()
    description_translated = TranslatedField()

    class Meta:
        model = models.Collection
        fields = [
            'id',
            'name_translated',
            'description_translated',
            'image_url',
            'slug',
        ]


class CollectionSerializer(CollectionBaseSerializer):
    """Collection serializer"""
    # COMMON
    block_size = serializers.JSONField()
    is_publish = serializers.BooleanField()
    on_top = serializers.BooleanField()
    slug = serializers.SlugField(allow_blank=False, required=True, max_length=50)

    # REQUEST
    start = serializers.DateTimeField(write_only=True)
    end = serializers.DateTimeField(write_only=True)
    country = serializers.PrimaryKeyRelatedField(
        queryset=location_models.Country.objects.all(),
        write_only=True)

    class Meta(CollectionBaseSerializer.Meta):
        fields = CollectionBaseSerializer.Meta.fields + [
            'start',
            'end',
            'is_publish',
            'on_top',
            'country',
            'block_size',
        ]


class GuideTypeBaseSerializer(serializers.ModelSerializer):
    """GuideType serializer."""

    class Meta:
        """Meta class."""
        model = models.GuideType
        fields = [
            'id',
            'name',
        ]


class GuideBaseSerializer(serializers.ModelSerializer):
    """Guide serializer"""
    state_display = serializers.CharField(source='get_state_display',
                                          read_only=True)
    guide_type_detail = GuideTypeBaseSerializer(read_only=True,
                                                source='guide_type')
    site_detail = SiteShortSerializer(read_only=True,
                                      source='site')
    entities = serializers.DictField(read_only=True)

    class Meta:
        model = models.Guide
        fields = [
            'id',
            'name',
            'start',
            'end',
            'vintage',
            'slug',
            'guide_type',
            'guide_type_detail',
            'site',
            'site_detail',
            'state',
            'state_display',
            'entities',
        ]
        extra_kwargs = {
            'guide_type': {'write_only': True},
            'site': {'write_only': True},
            'state': {'write_only': True},
            'start': {'required': True},
            'slug': {'required': True},
        }


class GuideFilterBaseSerializer(serializers.ModelSerializer):
    """GuideFilter serializer"""

    class Meta:
        """Meta class."""
        model = models.GuideFilter
        fields = [
            'id',
            'establishment_type_json',
            'country_json',
            'region_json',
            'sub_region_json',
            'wine_region_json',
            'with_mark',
            'locale_json',
            'max_mark',
            'min_mark',
            'review_vintage_json',
            'review_state_json',
            'guide',
        ]
        extra_kwargs = {
            'guide': {'write_only': True}
        }

    @property
    def request_kwargs(self):
        """Get url kwargs from request."""
        return self.context.get('request').parser_context.get('kwargs')

    def get_guide(self):
        """Get guide instance from kwargs."""
        return self.request_kwargs.get()

    def create(self, validated_data):
        """Overridden create method."""
        validated_data['guide'] = self.get_guide(validated_data.pop('guide', None))
        return super().create(validated_data)