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',
#         ]