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

from establishment import models
from establishment.serializers import (
    EstablishmentBaseSerializer, PlateSerializer, ContactEmailsSerializer,
    ContactPhonesSerializer, SocialNetworkRelatedSerializers,
    EstablishmentTypeBaseSerializer, EstablishmentSubTypeBaseSerializer,
    EstablishmentTypeTagCategoryBaseSerializer)
from main.models import Currency
from tag.serializers import TagBaseSerializer
from utils.decorators import with_base_attributes
from utils.serializers import TranslatedField


class EstablishmentListCreateSerializer(EstablishmentBaseSerializer):
    """Establishment create serializer"""

    type_id = serializers.PrimaryKeyRelatedField(
        source='establishment_type',
        queryset=models.EstablishmentType.objects.all(), write_only=True
    )
    phones = ContactPhonesSerializer(read_only=True, many=True, )
    emails = ContactEmailsSerializer(read_only=True, many=True, )
    socials = SocialNetworkRelatedSerializers(read_only=True, many=True, )
    slug = serializers.SlugField(required=True, allow_blank=False, max_length=50)
    type = EstablishmentTypeBaseSerializer(source='establishment_type', read_only=True)

    class Meta:
        model = models.Establishment
        fields = [
            'id',
            'name',
            'website',
            'phones',
            'emails',
            'price_level',
            'toque_number',
            'type_id',
            'type',
            'socials',
            'image_url',
            'slug',
            # TODO: check in admin filters
            'is_publish',
            'guestonline_id',
            'lastable_id',
        ]


class EstablishmentRUDSerializer(EstablishmentBaseSerializer):
    """Establishment create serializer"""

    type_id = serializers.PrimaryKeyRelatedField(
        source='establishment_type',
        queryset=models.EstablishmentType.objects.all(), write_only=True
    )
    phones = ContactPhonesSerializer(read_only=False, many=True, )
    emails = ContactEmailsSerializer(read_only=False, many=True, )
    socials = SocialNetworkRelatedSerializers(read_only=False, many=True, )
    type = EstablishmentTypeBaseSerializer(source='establishment_type')

    class Meta:
        model = models.Establishment
        fields = [
            'id',
            'name',
            'website',
            'phones',
            'emails',
            'price_level',
            'toque_number',
            'type_id',
            'type',
            'socials',
            'image_url',
            # TODO: check in admin filters
            'is_publish'
        ]


class SocialNetworkSerializers(serializers.ModelSerializer):
    """Social network serializers."""
    class Meta:
        model = models.SocialNetwork
        fields = [
            'id',
            'establishment',
            'title',
            'url',
        ]


class PlatesSerializers(PlateSerializer):
    """Social network serializers."""

    currency_id = serializers.PrimaryKeyRelatedField(
        source='currency',
        queryset=Currency.objects.all(), write_only=True
    )

    class Meta:
        """Meta class."""

        model = models.Plate
        fields = PlateSerializer.Meta.fields + [
            'name',
            'currency_id',
            'menu'
        ]


class ContactPhoneBackSerializers(PlateSerializer):
    """Social network serializers."""
    class Meta:
        model = models.ContactPhone
        fields = [
            'id',
            'establishment',
            'phone'
        ]


class ContactEmailBackSerializers(PlateSerializer):
    """Social network serializers."""
    class Meta:
        model = models.ContactEmail
        fields = [
            'id',
            'establishment',
            'email'
        ]


# TODO: test decorator
@with_base_attributes
class EmployeeBackSerializers(serializers.ModelSerializer):

    """Social network serializers."""
    class Meta:
        model = models.Employee
        fields = [
            'id',
            'user',
            'name'
        ]


class EstablishmentTagCreateSerializer(serializers.ModelSerializer):
    """Serializer for model EstablishmentTag."""
    class Meta:
        model = models.EstablishmentTag
        fields = [
            'tag',
            'establishment'
        ]
        extra_kwargs = {
            'tag': {'write_only': True},
            'establishment': {'write_only': True},
        }

    def validate(self, attrs):
        """Validate method."""
        establishment = attrs.get('establishment')
        tag = attrs.get('tag')

        # Check if tag is already added to establishment.
        if establishment.tags.filter(tag=tag).exists():
            raise serializers.ValidationError(detail={'detail': _('Tag is already added.')})

        # Сhecking tag availability for establishment type.
        if not establishment.establishment_type.use_subtypes:
            qs = establishment.establishment_type.tag_categories.filter(tag_category=tag.category)
        else:
            # Сhecking tag availability for establishment subtype.
            qs = establishment.establishment_type.tag_categories.filter(
                establishmentsubtype_set__tag_category=tag.category)
        if not qs.exists():
            raise serializers.ValidationError(
                detail={'detail': _('Tag is not available for this establishment type|subtype.')})
        return attrs


class EstablishmentSubTypeTagCategoryBaseSerializer(serializers.ModelSerializer):
    """Serializer for intermediate model EstablishmentSubTypeTagCategories."""
    id = serializers.IntegerField(source='tag_category.id', read_only=True)
    label_translated = TranslatedField(source='tag_category.label_translated')
    tags = TagBaseSerializer(source='tag_category.tags', many=True, read_only=True)

    class Meta:
        """Meta class."""
        model = models.EstablishmentSubTypeTagCategory
        fields = [
            'id',
            'label_translated',
            'tags',
            'establishment_subtype',
            'tag_category',
        ]
        extra_kwargs = {
            'establishment_subtype': {'write_only': True},
            'tag_category': {'write_only': True},
        }

    def validate(self, attrs):
        """Override validate method."""
        if models.EstablishmentTypeTagCategory.objects.filter(
                establishment_type=attrs.get('establishment_type'),
                tag_category=attrs.get('tag_category')).exists():
            raise serializers.ValidationError(detail={'detail': _('Objects is already attached.')})
        return attrs


class EstablishmentSubTypeSerializer(EstablishmentSubTypeBaseSerializer):
    """Extended serializer for EstablishmentSubType model with tags."""
    tag_categories = EstablishmentSubTypeTagCategoryBaseSerializer(many=True, read_only=True)

    class Meta(EstablishmentSubTypeBaseSerializer.Meta):
        """Meta class"""
        fields = [
            'id',
            'name_translated',
            'tag_categories'
        ]


class EstablishmentTagsByType(EstablishmentTypeBaseSerializer):
    """Tags by establishment type"""
    tag_categories = EstablishmentTypeTagCategoryBaseSerializer(many=True)
    subtypes = EstablishmentSubTypeSerializer(many=True, source='establishmentsubtype_set')

    class Meta(EstablishmentTypeBaseSerializer.Meta):
        """Meta class."""
        fields = [
            'id',
            'name_translated',
            'tag_categories',
            'subtypes',
        ]