"""Establishment serializers."""
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 favorites.models import Favorites
from location.serializers import AddressSerializer
from main.models import MetaDataContent
from main.serializers import MetaDataContentSerializer, AwardSerializer, CurrencySerializer
from review import models as review_models
from timetable.serialziers import ScheduleRUDSerializer
from utils import exceptions as utils_exceptions
from django.utils.translation import gettext_lazy as _


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',
            'title',
            'url',
        ]


class PlateSerializer(serializers.ModelSerializer):

    name_translated = serializers.CharField(allow_null=True, read_only=True)
    currency = CurrencySerializer(read_only=True)

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


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

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


class MenuRUDSerializers(serializers.ModelSerializer):
    plates = PlateSerializer(read_only=True, many=True, source='plate_set')
    category = serializers.JSONField()

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


class EstablishmentTypeSerializer(serializers.ModelSerializer):
    """Serializer for EstablishmentType model."""

    name_translated = serializers.CharField(allow_null=True)

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

        model = models.EstablishmentType
        fields = ('id', 'name_translated')


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

    name_translated = serializers.CharField(allow_null=True)

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

        model = models.EstablishmentSubType
        fields = ('id', 'name_translated')


class ReviewSerializer(serializers.ModelSerializer):
    """Serializer for model Review."""
    text_translated = serializers.CharField(read_only=True)

    class Meta:
        """Meta class."""
        model = review_models.Review
        fields = (
            'text_translated',
        )


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')

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

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


class EstablishmentBaseSerializer(serializers.ModelSerializer):
    """Base serializer for Establishment model."""
    type = EstablishmentTypeSerializer(source='establishment_type', read_only=True)
    subtypes = EstablishmentSubTypeSerializer(many=True)
    address = AddressSerializer()
    tags = MetaDataContentSerializer(many=True)
    slug = serializers.SlugField(allow_blank=True)

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

        model = models.Establishment
        fields = [
            'id',
            'name',
            'name_translated',
            'price_level',
            'toque_number',
            'public_mark',
            'type',
            'subtypes',
            'address',
            'tags',
            'slug',
        ]


class EstablishmentListSerializer(EstablishmentBaseSerializer):
    """Serializer for Establishment model."""
    # Annotated fields
    in_favorites = serializers.BooleanField(allow_null=True)

    preview_image = serializers.URLField(source='preview_image_url')

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

        model = models.Establishment
        fields = EstablishmentBaseSerializer.Meta.fields + [
            'in_favorites',
            'preview_image',
        ]


class EstablishmentDetailSerializer(EstablishmentListSerializer):
    """Serializer for Establishment model."""
    description_translated = serializers.CharField(allow_null=True)
    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 = serializers.SerializerMethodField()
    employees = EstablishmentEmployeeSerializer(source='actual_establishment_employees',
                                                many=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)

    slug = serializers.SlugField(read_only=True)

    in_favorites = serializers.SerializerMethodField()

    image = serializers.URLField(source='image_url')

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

        model = models.Establishment
        fields = EstablishmentListSerializer.Meta.fields + [
            'description_translated',
            'price_level',
            'image',
            'awards',
            'schedule',
            'website',
            'facebook',
            'twitter',
            'lafourchette',
            'booking',
            'phones',
            'emails',
            'review',
            'employees',
            'menu',
            'best_price_menu',
            'best_price_carte',
            'transportation',
            'slug',
        ]

    def get_review(self, obj):
        """Serializer method for getting last published review"""
        return ReviewSerializer(obj.reviews.by_status(status=review_models.Review.READY)
                                           .order_by('-published_at').first()).data

    def get_in_favorites(self, obj):
        """Get in_favorites status flag"""
        user = self.context.get('request').user
        if user.is_authenticated:
            return obj.id in user.favorites.by_content_type(app_label='establishment',
                                                            model='establishment')\
                                           .values_list('object_id', flat=True)
        else:
            return False


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 EstablishmentCommentRUDSerializer(comment_serializers.CommentSerializer):
    """Retrieve/Update/Destroy comment serializer."""
    class Meta:
        """Meta class."""
        model = comment_models.Comment
        fields = [
            'id',
            'created',
            'text',
            'mark',
            'nickname',
            'profile_pic',
        ]


class EstablishmentFavoritesCreateSerializer(serializers.ModelSerializer):
    """Create comment serializer"""

    class Meta:
        """Serializer for model Comment"""
        model = Favorites
        fields = [
            'id',
            'created',
        ]

    def get_user(self):
        """Get user from request"""
        return self.context.get('request').user

    def validate(self, attrs):
        """Override validate method"""
        # Check establishment object
        establishment_id = self.context.get('request').parser_context.get('kwargs').get('pk')
        establishment_qs = models.Establishment.objects.filter(id=establishment_id)

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

        # Check existence in favorites
        if self.get_user().favorites.by_content_type(app_label='establishment',
                                                     model='establishment')\
                                    .by_object_id(object_id=establishment_id).exists():
            raise utils_exceptions.FavoritesError()

        attrs['establishment'] = establishment_qs.first()
        return attrs

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


class EstablishmentTagListSerializer(serializers.ModelSerializer):
    """List establishment tag serializer."""
    id = serializers.IntegerField(source='metadata.id')
    label_translated = serializers.CharField(
        source='metadata.label_translated', read_only=True, allow_null=True)

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