# coding=utf8
# -*- coding: utf8 -*-
# vim: set fileencoding=utf8 :

from __future__ import unicode_literals

from django.conf import settings
from django.utils.timezone import now
from rest_framework import mixins, permissions, status, viewsets
from rest_framework.decorators import detail_route, list_route
from rest_framework.response import Response
from rest_messaging.compat import compat_get_paginated_response, compat_get_request_data, compat_pagination_messages, compat_serializer_check_is_valid, compat_thread_serializer_set, compat_perform_update
from rest_messaging.models import Message, NotificationCheck, Participant, Participation, Thread
from rest_messaging.permissions import IsInThread
from rest_messaging.serializers import MessageNotificationCheckSerializer, ComplexMessageSerializer, SimpleMessageSerializer, ThreadSerializer
import json


class ThreadView(mixins.RetrieveModelMixin,
                 mixins.CreateModelMixin,
                 mixins.UpdateModelMixin,
                 viewsets.GenericViewSet):
    """
    The ThreadView allow us to create threads, and add/remove people to/from them.
    It does not list the messages belonging to the thread.
    """
    queryset = Thread.objects.all().prefetch_related('participants')
    serializer_class = ThreadSerializer
    permission_classes = (IsInThread,)

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = ThreadSerializer(instance, callback=getattr(settings, 'REST_MESSAGING_SERIALIZE_PARTICIPANTS_CALLBACK', None), context={'request': request})  # self.get_serializer will raise an error in DRF 2.4
        return Response(serializer.data)

    def create(self, request, *args, **kwargs):
        """ We ensure the Thread only involves eligible participants. """
        serializer = self.get_serializer(data=compat_get_request_data(request))
        compat_serializer_check_is_valid(serializer)
        self.perform_create(request, serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, request, serializer):
        participants_ids = json.loads(compat_get_request_data(self.request).get('participants'))
        thread = Thread.managers.get_or_create_thread(self.request, compat_get_request_data(self.request).get('name'), *participants_ids)
        setattr(serializer, compat_thread_serializer_set(), thread)

    def update(self, request, *args, **kwargs):
        participants_ids = compat_get_request_data(self.request).getlist('participants', [])
        if len(participants_ids) > 0:
            # we warn the user he cannot update the participants here
            return Response("Participant updates not allowed by this method.", status=status.HTTP_400_BAD_REQUEST)
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=compat_get_request_data(request), partial=partial)
        compat_serializer_check_is_valid(serializer)
        try:
            self.perform_update(serializer)
        except:
            compat_perform_update(self, serializer)
        return Response(serializer.data)

    @detail_route(methods=['post'])
    def add_participants(self, request, pk=None):
        # we get the thread and check for permission
        thread = Thread.objects.get(id=pk)
        self.check_object_permissions(request, thread)
        # we get the participants and add them
        participants_ids = json.loads(compat_get_request_data(self.request).get('participants'))
        thread.add_participants(request, *participants_ids)
        # we return the thread
        serializer = self.get_serializer(thread)
        return Response(serializer.data)

    @detail_route(methods=['post'])
    def remove_participant(self, request, pk=None):
        # we get the thread and check for permission
        thread = Thread.objects.get(id=pk)
        self.check_object_permissions(request, thread)
        # we get the participant
        participant_id = compat_get_request_data(self.request).get('participant')
        participant = Participant.objects.get(id=participant_id)
        # we remove him if thread.remove_participant allows us to
        try:
            thread.remove_participant(request, participant)
            # we return the thread
            serializer = self.get_serializer(thread)
            return Response(serializer.data)
        except Exception:
            return Response(status=status.HTTP_400_BAD_REQUEST)

    @detail_route(methods=['get'])
    def get_removable_participants_ids(self, request, pk=None):
        # we get the thread and check for permission
        thread = Thread.objects.get(id=pk)
        self.check_object_permissions(request, thread)
        # we get the removable participants
        removable_participants_ids = thread.get_removable_participants_ids(request)
        # we remove him if thread.remove_participant allows us to
        try:
            return Response({'participants': removable_participants_ids})
        except Exception:
            return Response(status=status.HTTP_400_BAD_REQUEST)

    @detail_route(methods=['post'])
    def mark_thread_as_read(self, request, pk=None):
        """ Pk is the pk of the Thread to which the messages belong. """
        # we get the thread and check for permission
        thread = Thread.objects.get(id=pk)
        self.check_object_permissions(request, thread)
        # we save the date
        try:
            participation = Participation.objects.get(thread=thread, participant=request.rest_messaging_participant)
            participation.date_last_check = now()
            participation.save()
            # we return the thread
            serializer = self.get_serializer(thread)
            return Response(serializer.data)
        except Exception:
            return Response(status=status.HTTP_400_BAD_REQUEST)


@compat_pagination_messages
class MessageView(mixins.ListModelMixin,
                  viewsets.GenericViewSet):
    """ The view only lists and creates. """

    queryset = Message.objects.none()
    serializer_class = ComplexMessageSerializer
    permission_classes = (IsInThread,)

    def get_queryset(self):
        """ We list all the threads involving the user """
        check_notifications = self.request.GET.get("check_notifications", True)
        messages = Message.managers.get_lasts_messages_of_threads(self.request.rest_messaging_participant.id, check_who_read=True, check_is_notification=check_notifications)
        return messages

    @detail_route(methods=['post'], permission_classes=[IsInThread], serializer_class=SimpleMessageSerializer)
    def post_message(self, request, pk=None):
        """ Pk is the pk of the Thread to which the message belongs. """
        # we get the thread and check for permission
        thread = Thread.objects.get(id=pk)
        self.check_object_permissions(request, thread)
        # we get the body
        body = compat_get_request_data(self.request).get('body')
        # we create the message
        # Message.objects.save() could return an Exception
        try:
            message = Message(sender=request.rest_messaging_participant, thread=thread, body=body)
            message.save()
            serializer = SimpleMessageSerializer(message)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        except Exception:
            return Response(status=status.HTTP_412_PRECONDITION_FAILED)

    @detail_route(methods=['get'], permission_classes=[IsInThread], serializer_class=ComplexMessageSerializer)
    def list_messages_in_thread(self, request, pk=None):
        """ Pk is the pk of the Thread to which the messages belong. """
        # we get the thread and check for permission
        thread = Thread.objects.get(id=pk)
        self.check_object_permissions(request, thread)
        messages = Message.managers.get_all_messages_in_thread(participant_id=request.rest_messaging_participant.id, thread_id=thread.id, check_who_read=True)
        page = self.paginate_queryset(messages)
        if page is not None:
            return compat_get_paginated_response(self, page)
        serializer = ComplexMessageSerializer(messages, many=True)
        return Response(serializer.data)


class NotificationCheckView(mixins.ListModelMixin, viewsets.GenericViewSet):

    serializer_class = MessageNotificationCheckSerializer
    permission_classes = (permissions.IsAuthenticated,)

    @list_route(methods=['post'])
    def check(self, request, *args, **kwargs):
        # we get the NotificationCheck instance corresponding to the user or we create it

        try:
            nc = NotificationCheck.objects.get(participant=request.rest_messaging_participant)
            if nc:
                nc.date_check = now()
                nc.save()
            status_code = status.HTTP_200_OK

        except Exception:
            nc = NotificationCheck.objects.create(participant=request.rest_messaging_participant, date_check=now())
            status_code = status.HTTP_201_CREATED

        serializer = self.get_serializer(nc)
        return Response(serializer.data, status=status_code)


class ParticipantAuthenticationView(mixins.ListModelMixin, viewsets.GenericViewSet):
    """
    View that simply return the participant id of the user as set by the middleware, if it exists.
    """

    permission_classes = (permissions.IsAuthenticated,)

    def list(self, request, *args, **kwargs):
        participant = Participant.objects.get(id=self.request.rest_messaging_participant.id)
        return Response({'id': participant.id})
