from rest_framework import generics, permissions, status, serializers

from django.shortcuts import get_object_or_404
from establishment.models import Establishment
from booking.models.models import Booking, GuestonlineService, LastableService
from rest_framework.response import Response
from booking.serializers.web import (PendingBookingSerializer,
                                     UpdateBookingSerializer, GetBookingSerializer, CheckBookingSerializer)


class CheckWhetherBookingAvailable(generics.GenericAPIView):
    """ Checks which service to use if establishmend is managed by any """

    permission_classes = (permissions.AllowAny,)
    serializer_class = CheckBookingSerializer
    pagination_class = None

    def get(self, request, *args, **kwargs):
        is_booking_available = False
        establishment = get_object_or_404(Establishment, pk=kwargs['establishment_id'])
        service = None
        date = request.query_params.get('date')
        g_service = GuestonlineService()
        l_service = LastableService()
        if (not establishment.lastable_id is None) and l_service \
                .check_whether_booking_available(establishment.lastable_id, date):
            is_booking_available = True
            service = l_service
            service.service_id = establishment.lastable_id
        elif (not establishment.guestonline_id is None) and g_service \
                .check_whether_booking_available(establishment.guestonline_id, date):
            is_booking_available = True
            service = g_service
            service.service_id = establishment.guestonline_id

        response = {
            'available': is_booking_available,
            'type': service.service if service else None,
        }
        response.update({'details': service.response} if service and service.response else {})
        return Response(data=response, status=200)


class CreatePendingBooking(generics.CreateAPIView):
    """ Creates pending booking """
    permission_classes = (permissions.AllowAny,)
    serializer_class = PendingBookingSerializer

    def post(self, request, *args, **kwargs):
        data = request.data.copy()
        if data.get('type') == Booking.LASTABLE and data.get("offer_id") is None:
            raise serializers.ValidationError(detail='Offer_id is required field for Lastable service')
        establishment = get_object_or_404(Establishment, pk=kwargs['establishment_id'])
        data['restaurant_id'] = Booking.get_booking_id_by_type(establishment, data.get('type'))
        service = Booking.get_service_by_type(request.data.get('type'))
        data['user'] = request.user.pk if request.user else None
        service_to_keys = {
            Booking.GUESTONLINE: {'restaurant_id', 'booking_time', 'booking_date', 'booked_persons_number', },
            Booking.LASTABLE: {'booking_time', 'booked_persons_number', 'offer_id', 'email', 'phone',
                               'first_name', 'last_name', },
        }
        data['pending_booking_id'] = service.create_booking(
            service.get_certain_keys(data.copy(), service_to_keys[data.get('type')]))
        if not data['pending_booking_id']:
            return Response(status=status.HTTP_403_FORBIDDEN, data='Unable to create booking')
        data['booking_id'] = data['pending_booking_id'] if data.get('type') == Booking.LASTABLE else None
        serializer = self.get_serializer(data=data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(status=status.HTTP_201_CREATED, data=serializer.data)


class UpdatePendingBooking(generics.UpdateAPIView):
    """ Update pending booking with contacts """
    queryset = Booking.objects.all()
    permission_classes = (permissions.AllowAny,)
    serializer_class = UpdateBookingSerializer

    def patch(self, request, *args, **kwargs):
        instance = self.get_object()
        data = request.data.copy()
        service = Booking.get_service_by_type(instance.type)
        data['pending_booking_id'] = instance.pending_booking_id
        service.update_booking(service.get_certain_keys(data, {
            'email', 'phone', 'last_name', 'first_name', 'country_code', 'pending_booking_id',
        }))
        service.commit_booking(data['pending_booking_id'])
        data = {
            'booking_id': service.response.get('id'),
            'id': instance.pk,
        }
        serializer = self.get_serializer(data=data)
        serializer.is_valid(raise_exception=True)
        serializer.update(instance, data)
        return Response(status=status.HTTP_200_OK, data=serializer.data)


class CancelBooking(generics.DestroyAPIView):
    """ Cancel existing booking """
    queryset = Booking.objects.all()
    permission_classes = (permissions.AllowAny,)


class LastBooking(generics.RetrieveAPIView):
    """ Get last booking by user credentials """
    permission_classes = (permissions.IsAuthenticated,)
    serializer_class = GetBookingSerializer
    lookup_field = None

    def get_object(self):
        return Booking.objects.by_user(self.request.user).latest('modified')


class GetBookingById(generics.RetrieveAPIView):
    """ Returns booking by its id"""
    permission_classes = (permissions.AllowAny,)
    serializer_class = GetBookingSerializer
    queryset = Booking.objects.all()