"""Establishment serializers."""
from django.utils.translation import ugettext_lazy as _
from rest_framework import serializers

from comment import models as comment_models
from comment.serializers import common as comment_serializers
from establishment import models
from location.serializers import AddressBaseSerializer, CitySerializer, AddressDetailSerializer, CityShortSerializer
from main.serializers import AwardSerializer, CurrencySerializer
from tag.serializers import TagBaseSerializer
from timetable.serialziers import ScheduleRUDSerializer
from utils import exceptions as utils_exceptions
from utils.serializers import (ProjectModelSerializer, TranslatedField,
                               FavoritesCreateSerializer)
from review.serializers import ReviewShortSerializer


class ContactPhonesSerializer(serializers.ModelSerializer):
    """Contact phone serializer"""

    class Meta:
        model = models.ContactPhone
        fields = [
            'phone'
        ]


class ContactEmailsSerializer(serializers.ModelSerializer):
    """Contact email serializer"""

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


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

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


class PlateSerializer(ProjectModelSerializer):
    name_translated = TranslatedField()
    currency = CurrencySerializer(read_only=True)

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


class MenuSerializers(ProjectModelSerializer):
    plates = PlateSerializer(read_only=True, many=True, source='plate_set')
    category_translated = serializers.CharField(read_only=True)

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


class MenuRUDSerializers(ProjectModelSerializer):
    plates = PlateSerializer(read_only=True, many=True, source='plate_set')

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


class EstablishmentTypeBaseSerializer(serializers.ModelSerializer):
    """Serializer for EstablishmentType model."""
    name_translated = TranslatedField()

    class Meta:
        """Meta class."""
        model = models.EstablishmentType
        fields = [
            'id',
            'name',
            'name_translated',
            'use_subtypes',
            'index_name',
        ]
        extra_kwargs = {
            'name': {'write_only': True},
            'use_subtypes': {'write_only': True},
        }


class EstablishmentTypeGeoSerializer(EstablishmentTypeBaseSerializer):
    """Serializer for EstablishmentType model w/ index_name."""

    class Meta(EstablishmentTypeBaseSerializer.Meta):
        fields = EstablishmentTypeBaseSerializer.Meta.fields + [
            'index_name'
        ]
        extra_kwargs = {
            **EstablishmentTypeBaseSerializer.Meta.extra_kwargs,
            'index_name': {'read_only': True},
        }


class EstablishmentSubTypeBaseSerializer(serializers.ModelSerializer):
    """Serializer for EstablishmentSubType models."""

    name_translated = TranslatedField()

    class Meta:
        """Meta class."""
        model = models.EstablishmentSubType
        fields = [
            'id',
            'name',
            'name_translated',
            'establishment_type',
            'index_name',
        ]
        extra_kwargs = {
            'name': {'write_only': True},
            'establishment_type': {'write_only': True}
        }


class EstablishmentSubTypeGeoSerializer(EstablishmentSubTypeBaseSerializer):
    """Serializer for EstablishmentSuType model w/ index_name."""

    class Meta(EstablishmentSubTypeBaseSerializer.Meta):
        fields = EstablishmentSubTypeBaseSerializer.Meta.fields + [
            'index_name'
        ]
        extra_kwargs = {
            **EstablishmentSubTypeBaseSerializer.Meta.extra_kwargs,
            'index_name': {'read_only': True},
        }


class EstablishmentEmployeeSerializer(serializers.ModelSerializer):
    """Serializer for actual employees."""

    id = serializers.IntegerField(source='employee.id')
    name = serializers.CharField(source='employee.name')
    position_translated = serializers.CharField(source='position.name_translated')
    awards = AwardSerializer(source='employee.awards', many=True)
    priority = serializers.IntegerField(source='position.priority')
    position_index_name = serializers.CharField(source='position.index_name')

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

        model = models.Employee
        fields = ('id', 'name', 'position_translated', 'awards', 'priority', 'position_index_name')


class EstablishmentShortSerializer(serializers.ModelSerializer):
    """Short serializer for establishment."""
    city = CitySerializer(source='address.city', allow_null=True)
    establishment_type = EstablishmentTypeGeoSerializer()
    establishment_subtypes = EstablishmentSubTypeBaseSerializer(many=True)

    class Meta:
        """Meta class."""
        model = models.Establishment
        fields = [
            'id',
            'name',
            'index_name',
            'slug',
            'city',
            'establishment_type',
            'establishment_subtypes',
        ]


class EstablishmentProductShortSerializer(serializers.ModelSerializer):
    """SHORT Serializer for displaying info about an establishment on product page."""
    establishment_type = EstablishmentTypeGeoSerializer()
    establishment_subtypes = EstablishmentSubTypeBaseSerializer(many=True)
    address = AddressBaseSerializer()
    city = CityShortSerializer(source='address.city', allow_null=True)

    class Meta:
        """Meta class."""
        model = models.Establishment
        fields = [
            'id',
            'name',
            'index_name',
            'slug',
            'city',
            'establishment_type',
            'establishment_subtypes',
            'address',
        ]


class EstablishmentProductSerializer(EstablishmentShortSerializer):
    """Serializer for displaying info about an establishment on product page."""

    address = AddressBaseSerializer()

    class Meta(EstablishmentShortSerializer.Meta):
        """Meta class."""
        fields = EstablishmentShortSerializer.Meta.fields + [
            'address',
        ]


class EstablishmentBaseSerializer(ProjectModelSerializer):
    """Base serializer for Establishment model."""

    preview_image = serializers.URLField(source='preview_image_url')
    address = AddressBaseSerializer()
    in_favorites = serializers.BooleanField(allow_null=True)
    tags = TagBaseSerializer(read_only=True, many=True)
    currency = CurrencySerializer()
    type = EstablishmentTypeBaseSerializer(source='establishment_type', read_only=True)
    subtypes = EstablishmentSubTypeBaseSerializer(many=True, source='establishment_subtypes')

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

        model = models.Establishment
        fields = [
            'id',
            'name',
            'transliterated_name',
            'index_name',
            'price_level',
            'toque_number',
            'public_mark',
            'slug',
            'preview_image',
            'in_favorites',
            'address',
            'tags',
            'currency',
            'type',
            'subtypes',
        ]


class EstablishmentListRetrieveSerializer(EstablishmentBaseSerializer):
    """Establishment with city serializer."""

    address = AddressDetailSerializer()
    schedule = ScheduleRUDSerializer(many=True, allow_null=True)

    class Meta(EstablishmentBaseSerializer.Meta):
        """Meta class."""

        fields = EstablishmentBaseSerializer.Meta.fields + [
            'schedule',
        ]


class EstablishmentGeoSerializer(EstablishmentBaseSerializer):
    """Serializer for Geo view."""

    type = EstablishmentTypeGeoSerializer(source='establishment_type', read_only=True)
    subtypes = EstablishmentSubTypeGeoSerializer(many=True, source='establishment_subtypes')

    class Meta(EstablishmentBaseSerializer.Meta):
        """Meta class."""

        fields = EstablishmentBaseSerializer.Meta.fields


class RangePriceSerializer(serializers.Serializer):
    max = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, default=0)
    min = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, default=0)


class EstablishmentDetailSerializer(EstablishmentBaseSerializer):
    """Serializer for Establishment model."""

    description_translated = TranslatedField()
    image = serializers.URLField(source='image_url')
    awards = AwardSerializer(many=True)
    schedule = ScheduleRUDSerializer(many=True, allow_null=True)
    phones = ContactPhonesSerializer(read_only=True, many=True)
    emails = ContactEmailsSerializer(read_only=True, many=True)
    review = ReviewShortSerializer(source='last_published_review', allow_null=True)
    employees = EstablishmentEmployeeSerializer(source='actual_establishment_employees',
                                                many=True)
    address = AddressDetailSerializer(read_only=True)

    menu = MenuSerializers(source='menu_set', many=True, read_only=True)
    best_price_menu = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
    best_price_carte = serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True)
    range_price_menu = RangePriceSerializer(read_only=True)
    range_price_carte = RangePriceSerializer(read_only=True)
    vintage_year = serializers.ReadOnlyField()

    class Meta(EstablishmentBaseSerializer.Meta):
        """Meta class."""

        fields = EstablishmentBaseSerializer.Meta.fields + [
            'description_translated',
            'image',
            'awards',
            'schedule',
            'website',
            'facebook',
            'twitter',
            'lafourchette',
            'booking',
            'phones',
            'emails',
            'review',
            'employees',
            'menu',
            'best_price_menu',
            'best_price_carte',
            'range_price_menu',
            'range_price_carte',
            'transportation',
            'vintage_year',
        ]


class EstablishmentSimilarSerializer(EstablishmentBaseSerializer):
    """Serializer for Establishment model."""

    address = AddressDetailSerializer(read_only=True)


class EstablishmentCommentCreateSerializer(comment_serializers.CommentSerializer):
    """Create comment serializer"""
    mark = serializers.IntegerField()

    class Meta:
        """Serializer for model Comment"""
        model = comment_models.Comment
        fields = [
            'id',
            'created',
            'text',
            'mark',
            'nickname',
            'profile_pic',
        ]

    def validate(self, attrs):
        """Override validate method"""
        # Check establishment object
        establishment_slug = self.context.get('request').parser_context.get('kwargs').get('slug')
        establishment_qs = models.Establishment.objects.filter(slug=establishment_slug)
        if not establishment_qs.exists():
            raise serializers.ValidationError({'detail': _('Establishment not found.')})
        attrs['establishment'] = establishment_qs.first()
        return attrs

    def create(self, validated_data, *args, **kwargs):
        """Override create method"""
        validated_data.update({
            'user': self.context.get('request').user,
            'content_object': validated_data.pop('establishment')
        })
        return super().create(validated_data)


class EstablishmentFavoritesCreateSerializer(FavoritesCreateSerializer):
    """Serializer to favorite object w/ model Establishment."""

    def validate(self, attrs):
        """Overridden validate method"""
        # Check establishment object
        establishment_qs = models.Establishment.objects.filter(slug=self.slug)

        # Check establishment obj by slug from lookup_kwarg
        if not establishment_qs.exists():
            raise serializers.ValidationError({'detail': _('Object not found.')})
        else:
            establishment = establishment_qs.first()

        # Check existence in favorites
        if establishment.favorites.filter(user=self.user).exists():
            raise utils_exceptions.FavoritesError()

        attrs['establishment'] = establishment
        return attrs

    def create(self, validated_data, *args, **kwargs):
        """Overridden create method"""
        validated_data.update({
            'user': self.user,
            'content_object': validated_data.pop('establishment')
        })
        return super().create(validated_data)