from functools import lru_cache

from django.db.models import F
from django.shortcuts import get_object_or_404
from django.utils.translation import gettext_lazy as _
from phonenumber_field.serializerfields import PhoneNumberField
from rest_framework import serializers
from slugify import slugify

from account.serializers.common import UserShortSerializer
from collection.models import Guide
from establishment import models, serializers as model_serializers
from establishment.models import ContactEmail, ContactPhone, EstablishmentEmployee
from establishment.serializers.common import ContactPhonesSerializer
from gallery.models import Image
from location.serializers import AddressDetailSerializer, TranslatedField
from main.models import Currency
from main.serializers import AwardSerializer
from utils.decorators import with_base_attributes
from utils.methods import string_random
from utils.serializers import ImageBaseSerializer, ProjectModelSerializer, TimeZoneChoiceField, \
    PhoneMixinSerializer


def phones_handler(phones_list, establishment):
    """
    create or update phones for establishment
    """
    ContactPhone.objects.filter(establishment=establishment).delete()

    for new_phone in phones_list:
        ContactPhone.objects.create(establishment=establishment, phone=new_phone)


def emails_handler(emails_list, establishment):
    """
    create or update emails for establishment
    """
    ContactEmail.objects.filter(establishment=establishment).delete()

    for new_email in emails_list:
        ContactEmail.objects.create(establishment=establishment, email=new_email)


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

    type_id = serializers.PrimaryKeyRelatedField(
        source='establishment_type',
        queryset=models.EstablishmentType.objects.all(),
        write_only=True
    )
    address_id = serializers.PrimaryKeyRelatedField(
        source='address',
        queryset=models.Address.objects.all(),
        write_only=True
    )
    transliterated_name = serializers.CharField(
        required=False, allow_null=True, allow_blank=True
    )
    socials = model_serializers.SocialNetworkRelatedSerializers(
        read_only=True,
        many=True,
    )
    type = model_serializers.EstablishmentTypeBaseSerializer(
        source='establishment_type',
        read_only=True,
    )
    tz = TimeZoneChoiceField()
    phones = serializers.ListField(
        source='contact_phones',
        allow_null=True,
        allow_empty=True,
        child=PhoneNumberField(),
        required=False,
        write_only=True,
    )
    contact_phones = ContactPhonesSerializer(source='phones', read_only=True, many=True)
    emails = serializers.ListField(
        source='contact_emails',
        allow_null=True,
        allow_empty=True,
        child=serializers.CharField(max_length=128),
        required=False,
    )

    class Meta(model_serializers.EstablishmentBaseSerializer.Meta):
        fields = [
            'id',
            'name',
            'transliterated_name',
            'index_name',
            'website',
            'phones',
            'contact_phones',
            'emails',
            'price_level',
            'toque_number',
            'type_id',
            'type',
            'socials',
            'image_url',
            'slug',
            'facebook',
            'twitter',
            'instagram',
            # TODO: check in admin filters
            'is_publish',
            'guestonline_id',
            'lastable_id',
            'tags',
            'tz',
            'address_id',
            'status',
            'status_display',
        ]

    def to_representation(self, instance):
        data = super(EstablishmentListCreateSerializer, self).to_representation(instance)
        data['phones'] = data.pop('contact_phones', None)
        return data

    def create(self, validated_data):
        phones_list = []
        if 'contact_phones' in validated_data:
            phones_list = validated_data.pop('contact_phones')

        emails_list = []
        if 'contact_emails' in validated_data:
            emails_list = validated_data.pop('contact_emails')

        index_name = validated_data.get('index_name')
        if 'slug' in validated_data and index_name:
            slug = slugify(
                index_name,
                word_boundary=True
            )
            while models.Establishment.objects.filter(slug=slug).exists():
                slug = slugify(
                    f'{index_name} {string_random()}',
                    word_boundary=True
                )

        instance = super().create(validated_data)
        phones_handler(phones_list, instance)
        emails_handler(emails_list, instance)
        return instance


class EstablishmentPositionListSerializer(model_serializers.EstablishmentBaseSerializer):
    """Establishment position serializer"""

    class Meta:
        model = models.Establishment
        fields = [
            'id',
            'name',
            'transliterated_name',
            'index_name',
        ]


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

    type_id = serializers.PrimaryKeyRelatedField(
        source='establishment_type',
        queryset=models.EstablishmentType.objects.all(), write_only=True
    )
    address = AddressDetailSerializer(read_only=True)
    emails = serializers.ListField(
        source='contact_emails',
        allow_null=True,
        allow_empty=True,
        child=serializers.CharField(max_length=128),
        required=False,
    )
    socials = model_serializers.SocialNetworkRelatedSerializers(read_only=True,
                                                                many=True, )
    subtypes = model_serializers.EstablishmentSubTypeBaseSerializer(source='establishment_subtypes',
                                                                    read_only=True, many=True)
    type = model_serializers.EstablishmentTypeBaseSerializer(source='establishment_type', read_only=True)
    phones = serializers.ListField(
        source='contact_phones',
        allow_null=True,
        allow_empty=True,
        child=PhoneNumberField(),
        required=False,
        write_only=True,
    )
    contact_phones = ContactPhonesSerializer(source='phones', read_only=True, many=True)

    class Meta(model_serializers.EstablishmentBaseSerializer.Meta):
        fields = [
            'id',
            'slug',
            'transliterated_name',
            'name',
            'index_name',
            'website',
            'phones',
            'contact_phones',
            'emails',
            'price_level',
            'toque_number',
            'type_id',
            'type',
            'subtypes',
            'socials',
            'image_url',
            'facebook',
            'twitter',
            'instagram',
            # TODO: check in admin filters
            'is_publish',
            'address',
            'transportation',
            'tags',
            'status',
            'status_display',
        ]

    def to_representation(self, instance):
        data = super(EstablishmentRUDSerializer, self).to_representation(instance)
        data['phones'] = data.pop('contact_phones', None)
        return data

    def update(self, instance, validated_data):
        phones_list = []
        if 'contact_phones' in validated_data:
            phones_list = validated_data.pop('contact_phones')

        emails_list = []
        if 'contact_emails' in validated_data:
            emails_list = validated_data.pop('contact_emails')

        instance = super().update(instance, validated_data)
        phones_handler(phones_list, instance)
        emails_handler(emails_list, instance)
        return instance


class SocialChoiceSerializers(serializers.ModelSerializer):
    """SocialChoice serializers."""

    class Meta:
        model = models.SocialChoice
        fields = '__all__'


class SocialNetworkSerializers(serializers.ModelSerializer):
    """Social network serializers."""

    class Meta:
        model = models.SocialNetwork
        fields = [
            'id',
            'establishment',
            'network',
            'url',
        ]


class PlatesSerializers(model_serializers.PlateSerializer):
    """Plates serializers."""

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

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

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


class ContactPhoneBackSerializers(PhoneMixinSerializer, serializers.ModelSerializer):
    """ContactPhone serializers."""

    class Meta:
        model = models.ContactPhone
        fields = [
            'id',
            'establishment',
            'phone',
            'country_calling_code',
            'national_calling_number',
        ]
        extra_kwarg = {
            'phone': {'write_only': True}
        }


class ContactEmailBackSerializers(model_serializers.PlateSerializer):
    """ContactEmail serializers."""

    class Meta:
        model = models.ContactEmail
        fields = [
            'id',
            'establishment',
            'email'
        ]


class PositionBackSerializer(serializers.ModelSerializer):
    """Position Back serializer."""

    name_translated = TranslatedField()

    class Meta:
        model = models.Position
        fields = [
            'id',
            'name_translated',
            'priority',
            'index_name',
        ]


# TODO: test decorator
@with_base_attributes
class EmployeeBackSerializers(PhoneMixinSerializer, serializers.ModelSerializer):
    """Employee serializers."""
    public_mark = serializers.SerializerMethodField()
    positions = serializers.SerializerMethodField()
    establishment = serializers.SerializerMethodField()
    awards = AwardSerializer(many=True, read_only=True)
    toque_number = serializers.SerializerMethodField()
    photo = ImageBaseSerializer(source='crop_image', read_only=True)
    photo_id = serializers.PrimaryKeyRelatedField(source='photo', write_only=True, required=False,
                                                  queryset=Image.objects.all(), allow_null=True)

    @staticmethod
    @lru_cache(maxsize=32)
    def get_qs(obj):
        return obj.establishmentemployee_set.actual().annotate(
            public_mark=F('establishment__public_mark'),
            est_id=F('establishment__id'),
            est_slug=F('establishment__slug'),
            toque_number=F('establishment__toque_number'),
        ).order_by('-from_date').first()

    def get_public_mark(self, obj):
        """Get last list actual public_mark"""
        if hasattr(obj, 'prefetched_establishment_employee'):
            return obj.prefetched_establishment_employee[0].establishment.public_mark if len(
                obj.prefetched_establishment_employee) else None
        qs = self.get_qs(obj)
        if qs:
            return qs.public_mark
        return None

    def get_toque_number(self, obj):
        if hasattr(obj, 'prefetched_establishment_employee'):
            return obj.prefetched_establishment_employee[0].establishment.toque_number if len(
                obj.prefetched_establishment_employee) else None
        qs = self.get_qs(obj)
        if qs:
            return qs.toque_number
        return None

    def get_positions(self, obj):
        """Get last list actual positions"""
        if hasattr(obj, 'prefetched_establishment_employee'):
            if not len(obj.prefetched_establishment_employee):
                return []
            return [PositionBackSerializer(ee.position).data for ee in obj.prefetched_establishment_employee]

        est_id = self.get_qs(obj)

        if not est_id:
            return None

        qs = obj.establishmentemployee_set.actual() \
            .filter(establishment_id=est_id.establishment_id) \
            .prefetch_related('position').values('position')

        positions = models.Position.objects.filter(id__in=[q['position'] for q in qs])

        return [PositionBackSerializer(p).data for p in positions]

    def get_establishment(self, obj):
        """Get last actual establishment"""
        if hasattr(obj, 'prefetched_establishment_employee'):
            return {
                'id': obj.prefetched_establishment_employee[0].establishment.pk,
                'slug': obj.prefetched_establishment_employee[0].establishment.slug,
            } if len(obj.prefetched_establishment_employee) else None
        est = self.get_qs(obj)

        if not est:
            return None

        return {
            "id": est.est_id,
            "slug": est.est_slug
        }

    class Meta:
        model = models.Employee
        fields = [
            'id',
            'name',
            'last_name',
            'user',
            'public_mark',
            'positions',
            'awards',
            'establishment',
            'sex',
            'birth_date',
            'email',
            'phone',
            'country_calling_code',
            'national_calling_number',
            'toque_number',
            'available_for_events',
            'photo',
            'photo_id',
        ]
        extra_kwargs = {
            'phone': {'write_only': True}
        }


class EstablishmentEmployeeBackSerializer(serializers.ModelSerializer):
    """Establishment Employee serializer."""

    employee = EmployeeBackSerializers()
    position = PositionBackSerializer()

    class Meta:
        model = models.EstablishmentEmployee
        fields = [
            'id',
            'employee',
            'from_date',
            'to_date',
            'position',
            'status',
        ]


class EstEmployeeBackSerializer(EmployeeBackSerializers):

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

    def get_positions(self, obj):
        establishment_id = self.request_kwargs.get('establishment_id')
        establishment = self.context['view'].kwargs['establishment_instance']
        establishment_type = self.context['view'].kwargs['establishment_instance_type']
        establishment_subtypes = self.context['view'].kwargs['establishment_instance_subtypes']
        es_emp = EstablishmentEmployee.objects.filter(
            employee=obj,
            establishment_id=establishment_id,
        ).distinct().order_by('from_date').prefetch_related('position', 'position__establishment_type',
                                                            'position__establishment_subtype')
        result = []
        for item in es_emp:
            if item.position.establishment_type == establishment_type or \
                    item.position.establishment_subtype in establishment_subtypes or \
                    (item.position.establishment_subtype is None and item.position.establishment_type is None):
                # show only relevant for current establishment positions
                result.append({
                    'id': item.id,
                    'from_date': item.from_date,
                    'to_date': item.to_date,
                    'status': item.status,
                    'position_id': item.position_id,
                    'position_priority': item.position.priority,
                    'position_index_name': item.position.index_name,
                    'position_name_translated': item.position.name_translated,
                })
        return result

    class Meta:
        model = models.Employee
        fields = [
            'id',
            'name',
            'last_name',
            'user',
            'public_mark',
            'positions',
            'awards',
            'sex',
            'birth_date',
            'email',
            'phone',
            'country_calling_code',
            'national_calling_number',
            'toque_number',
            'available_for_events',
            'photo',
        ]
        extra_kwargs = {
            'phone': {'write_only': True}
        }


class EstablishmentBackOfficeGallerySerializer(serializers.ModelSerializer):
    """Serializer class for model EstablishmentGallery."""

    class Meta:
        """Meta class"""

        model = models.EstablishmentGallery
        fields = [
            'id',
            'is_main',
        ]

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

    def validate(self, attrs):
        """Override validate method."""
        establishment_pk = self.request_kwargs.get('pk')
        establishment_slug = self.request_kwargs.get('slug')

        search_kwargs = {'pk': establishment_pk} if establishment_pk else {'slug': establishment_slug}

        image_id = self.request_kwargs.get('image_id')

        establishment_qs = models.Establishment.objects.filter(**search_kwargs)
        image_qs = Image.objects.filter(id=image_id)

        if not establishment_qs.exists():
            raise serializers.ValidationError({'detail': _('Establishment not found')})

        if not image_qs.exists():
            raise serializers.ValidationError({'detail': _('Image not found')})

        establishment = establishment_qs.first()
        image = image_qs.first()

        if image in establishment.gallery.all():
            raise serializers.ValidationError({'detail': _('Image is already added.')})

        attrs['establishment'] = establishment
        attrs['image'] = image

        return attrs


class EstablishmentCompanyListCreateSerializer(model_serializers.CompanyBaseSerializer):
    """Serializer for linking page w/ advertisement."""

    class Meta(model_serializers.CompanyBaseSerializer.Meta):
        """Meta class."""
        model_serializers.CompanyBaseSerializer.Meta.extra_kwargs.update({
            'establishment': {'required': False}
        })

    def create(self, validated_data):
        """Overridden create method."""
        validated_data['establishment'] = self.context.get('view').get_object()
        return super().create(validated_data)


class EstablishmentNoteBaseSerializer(serializers.ModelSerializer):
    """Serializer for model EstablishmentNote."""

    user_detail = UserShortSerializer(read_only=True, source='user')

    class Meta:
        """Meta class."""
        model = models.EstablishmentNote
        fields = [
            'id',
            'created',
            'modified',
            'text',
            'user',
            'user_detail',
            'establishment',
        ]
        extra_kwargs = {
            'created': {'read_only': True},
            'modified': {'read_only': True},
            'establishment': {'required': False, 'write_only': True},
            'user': {'required': False, 'write_only': True},
        }

    @property
    def serializer_view(self):
        """Return view instance."""
        return self.context.get('view')


class EstablishmentNoteListCreateSerializer(EstablishmentNoteBaseSerializer):
    """Serializer for List|Create action for model EstablishmentNote."""

    def create(self, validated_data):
        """Overridden create method."""
        validated_data['user'] = self.user
        validated_data['establishment'] = self.establishment
        return super().create(validated_data)

    @property
    def user(self):
        """Return user instance from view."""
        if self.serializer_view:
            return self.serializer_view.request.user

    @property
    def establishment(self):
        """Return establishment instance from view."""
        if self.serializer_view:
            return self.serializer_view.get_object()


class EstablishmentAdminListSerializer(UserShortSerializer):
    """Establishment admin serializer."""

    class Meta:
        model = UserShortSerializer.Meta.model
        fields = [
            'id',
            'username',
            'email'
        ]


class EstablishmentGuideSerializer(serializers.ModelSerializer):
    """Serializer for model Guide. """

    class Meta:
        """Meta class."""
        model = Guide
        fields = [
            'id',
        ]


class EstablishmentEmployeePositionsSerializer(serializers.ModelSerializer):
    """Establishments from employee serializer"""

    restaurant_name = serializers.CharField(read_only=True, source='establishment.name')
    position = PositionBackSerializer(read_only=True)
    state = serializers.CharField(read_only=True, source='status')
    start = serializers.DateTimeField(read_only=True, source='from_date')
    end = serializers.DateTimeField(read_only=True, source='to_date')

    class Meta:
        model = models.EstablishmentEmployee
        fields = [
            'restaurant_name',
            'position',
            'state',
            'start',
            'end',
        ]


class _PlateSerializer(ProjectModelSerializer):
    name_translated = TranslatedField()

    class Meta:
        model = models.Plate
        fields = [
            'name_translated',
            'price',
        ]


class _MenuUploadsSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField()
    original_url = serializers.URLField()


class MenuDishesSerializer(ProjectModelSerializer):
    """for dessert, main_course and starter category"""

    plates = _PlateSerializer(read_only=True, many=True, source='plate_set', allow_null=True)
    category_translated = serializers.CharField(read_only=True)
    last_update = serializers.DateTimeField(source='created')
    gallery = ImageBaseSerializer(read_only=True, source='crop_gallery', many=True)

    class Meta:
        model = models.Menu
        fields = [
            'id',
            'category',
            'category_translated',
            'establishment',
            'is_drinks_included',
            'schedule',
            'plates',
            'last_update',
            'gallery',
        ]


class MenuDishesRUDSerializers(ProjectModelSerializer):
    """for dessert, main_course and starter category"""

    plates = _PlateSerializer(read_only=True, many=True, source='plate_set', allow_null=True)
    gallery = ImageBaseSerializer(read_only=True, source='crop_gallery', many=True)

    class Meta:
        model = models.Menu
        fields = [
            'id',
            'category',
            'plates',
            'establishment',
            'is_drinks_included',
            'schedule',
            'gallery',
        ]


class MenuGallerySerializer(serializers.ModelSerializer):
    """Serializer class for model MenuGallery."""

    class Meta:
        """Meta class"""

        model = models.MenuGallery
        fields = [
            'id',
            'is_main',
        ]

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

    def create(self, validated_data):
        menu_pk = self.request_kwargs.get('pk')
        image_id = self.request_kwargs.get('image_id')
        qs = models.MenuGallery.objects.filter(image_id=image_id, menu_id=menu_pk)
        instance = qs.first()
        if instance:
            qs.update(**validated_data)
            return instance
        return super().create(validated_data)

    def validate(self, attrs):
        """Override validate method."""
        menu_pk = self.request_kwargs.get('pk')
        image_id = self.request_kwargs.get('image_id')

        menu_qs = models.Menu.objects.filter(pk=menu_pk)
        image_qs = Image.objects.filter(id=image_id)

        if not menu_qs.exists():
            raise serializers.ValidationError({'detail': _('Menu not found')})
        if not image_qs.exists():
            raise serializers.ValidationError({'detail': _('Image not found')})

        menu = menu_qs.first()
        image = image_qs.first()

        attrs['menu'] = menu
        attrs['image'] = image

        return attrs


class MenuFilesSerializers(ProjectModelSerializer):
    type = serializers.CharField(read_only=True)

    class Meta:
        model = models.MenuFiles
        fields = [
            'id',
            'name',
            'type',
            'file',
        ]

    def create(self, validated_data):
        instance = models.MenuFiles.objects.create(**validated_data)
        return instance

    def validate(self, attrs):
        extension = attrs['file'].name.split('.')[-1]
        attrs['type'] = 'image' if extension in ('jpg', 'jpeg', 'png') else 'file'
        if 'name' not in attrs or not attrs['name']:
            attrs['name'] = attrs['file'].name
        return attrs


class MenuBackOfficeSerializer(serializers.ModelSerializer):
    name = serializers.CharField(source='category_translated')
    drinks_included = serializers.BooleanField(source='is_drinks_included')
    establishment_id = serializers.IntegerField(source='establishment.id')
    establishment_slug = serializers.CharField(source='establishment.slug', read_only=True)
    uploads = MenuFilesSerializers(many=True, read_only=True)

    class Meta:
        model = models.Menu
        fields = [
            'id',
            'type',
            'name',
            'establishment_id',
            'establishment_slug',
            'price',
            'drinks_included',
            'diner',
            'lunch',
            'last_update',
            'uploads',
            'uploads_ids',
        ]
        extra_kwargs = {
            'last_update': {'read_only': True},
            'uploads_ids': {'write_only': True, 'source': 'uploads', 'required': True},
        }

    def validate(self, attrs):
        attrs['category'] = {'en-GB': attrs.pop('category_translated')}
        return attrs

    def update(self, instance, validated_data):
        uploaded_files_ids = validated_data.pop('uploads')
        establishment_kwargs = validated_data.pop('establishment')
        establishment = get_object_or_404(models.Establishment, **establishment_kwargs)
        validated_data['establishment'] = establishment
        instance = super().update(instance, validated_data)
        instance.uploads.set(uploaded_files_ids)
        return instance

    def create(self, validated_data):
        uploaded_files_ids = validated_data.pop('uploads')
        establishment_kwargs = validated_data.pop('establishment')
        establishment = get_object_or_404(models.Establishment, **establishment_kwargs)
        validated_data['establishment'] = establishment
        instance = models.Menu.objects.create(**validated_data)
        instance.uploads.set(uploaded_files_ids)
        return instance


class EstablishmentBackOfficeWineSerializer(serializers.ModelSerializer):
    establishment_id = serializers.PrimaryKeyRelatedField(
        source='establishment',
        queryset=models.Establishment.objects.all(),
        write_only=True
    )
    """BackOffice wine serializer"""

    class Meta:
        model = models.EstablishmentBackOfficeWine
        fields = (
            'id',
            'bottles',
            'price_from',
            'price_to',
            'price_from_for_one',
            'price_to_for_one',
            'is_glass',
            'establishment_id',
        )


class CardAndWinesPlatesSerializer(serializers.ModelSerializer):
    """Serializer for card&wines backoffice section"""

    type = serializers.CharField(source='menu.type')

    class Meta:
        model = models.Plate
        fields = (
            'id',
            'name',
            'is_signature_plate',
            'price',
            'type',
        )
        extra_kwargs = {
        }

    def create(self, validated_data):
        establishment = get_object_or_404(models.Establishment, pk=self.context['view'].kwargs['establishment_id'])
        menu_type = validated_data.pop('menu')['type']
        if menu_type not in models.Menu.VALID_CARD_AND_WINES_CHOICES:
            raise serializers.ValidationError({
                'detail':
                    f'Incorrect type: {menu_type}. Valid types: [{", ".join(models.Menu.VALID_CARD_AND_WINES_CHOICES)}]'
            })
        menu_to_bind = establishment.menu_set.filter(type=menu_type).first()
        if menu_to_bind is None:
            menu_to_bind = models.Menu.objects.create(type=menu_type, category={'en-GB': menu_type},
                                                      establishment=establishment)
        validated_data.update({'menu': menu_to_bind})
        return super().create(validated_data)

    def update(self, instance, validated_data):
        menu_type = validated_data.pop('menu')['type']
        if menu_type not in models.Menu.VALID_CARD_AND_WINES_CHOICES:
            raise serializers.ValidationError({
                'detail':
                    f'Incorrect type: {menu_type}. Valid types: [{", ".join(models.Menu.VALID_CARD_AND_WINES_CHOICES)}]'
            })
        if instance.menu.type != menu_type:  # type changed
            establishment = instance.menu.establishment
            menu_to_bind = establishment.menu_set.filter(type=menu_type).first()
            if menu_to_bind is None:
                menu_to_bind = models.Menu.objects.create(type=menu_type, category={'en-GB': menu_type},
                                                          establishment=establishment)
            validated_data.update({'menu': menu_to_bind})
        return super().update(instance, validated_data)


class CardAndWinesSerializer(serializers.ModelSerializer):
    """View to show menus(not formulas) with dishes for certain establishment"""

    wine = EstablishmentBackOfficeWineSerializer(allow_null=True, read_only=True, source='back_office_wine')
    dishes = CardAndWinesPlatesSerializer(many=True, source='card_and_wine_plates')

    class Meta:
        model = models.Establishment
        fields = (
            'wine',
            'dishes',
        )