from threading import Thread
from apps.ecm.models import AlgoChannel, Event, EventCate, Remind, NotifySetting
from apps.ecm.serializers import (AlgoChannelCreateSerializer, AlgoChannelCreatesSerializer, AlgoChannelSerializer, EventCateCreateUpdateSerializer, EventCateListSerializer, EventCateUpdateSerializer, EventHandleSerializer,
                                  EventSerializer, RemindSerializer, NotifySettingsSerializer)
from apps.ecm.service import update_remind_read
from apps.utils.viewsets import CustomGenericViewSet, CustomModelViewSet
from rest_framework.mixins import UpdateModelMixin, ListModelMixin, RetrieveModelMixin, CreateModelMixin, DestroyModelMixin
from django.db import transaction
from rest_framework.decorators import action
from rest_framework import serializers
from django.utils import timezone
from rest_framework.response import Response
from rest_framework.exceptions import PermissionDenied
from apps.utils.snowflake import idWorker


# Create your views here.
class EventCateViewSet(CreateModelMixin, UpdateModelMixin, ListModelMixin, CustomGenericViewSet):
    perms_map = {'get': '*', 'put': 'event_cate:update', 'post': 'event_cate:create'}
    queryset = EventCate.objects.all()
    list_serializer_class = EventCateListSerializer
    create_serializer_class = EventCateCreateUpdateSerializer
    update_serializer_class = EventCateCreateUpdateSerializer
    serializer_class = EventCateListSerializer
    filterset_fields = ['self_algo']


class AlgoChannelViewSet(CreateModelMixin, DestroyModelMixin, ListModelMixin, CustomGenericViewSet):
    perms_map = {'get': '*', 'post': 'event_cate:update', 'delete': 'event_cate:create'}
    queryset = AlgoChannel.objects.all()
    create_serializer_class = AlgoChannelCreateSerializer
    serializer_class = AlgoChannelSerializer
    filterset_fields = ['algo']

    @transaction.atomic
    @action(methods=['post'], detail=False, perms_map={'post': 'event_cate:update'},
            serializer_class=AlgoChannelCreatesSerializer)
    def creates(self, request, pk=None):
        """批量添加摄像头

        批量添加摄像头
        """
        serializer = AlgoChannelCreatesSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        vdata = serializer.validated_data
        acs = []
        for i in vdata['vchannels']:
            acs.append(AlgoChannel(id=idWorker.get_id(), algo=vdata['algo'], vchannel=i))
        AlgoChannel.objects.bulk_create(objs=acs, ignore_conflicts=False)
        return Response()


class NotifySettingViewSet(CustomModelViewSet):
    queryset = NotifySetting.objects.all()
    serializer_class = NotifySettingsSerializer
    filterset_fields = ['event_cate', 'obj_cate', 'post', 'user']


class EventViewSet(ListModelMixin, RetrieveModelMixin, CustomGenericViewSet):
    perms_map = {'get': 'event:view'}
    queryset = Event.objects.all()
    serializer_class = EventSerializer
    select_related_fields = ['area', 'employee', 'handle_user']
    prefetch_related_fields = ['cates']

    @transaction.atomic
    @action(methods=['post'], detail=True, perms_map={'post': 'event:handle'},
            serializer_class=EventHandleSerializer)
    def handle(self, request, pk=None):
        """处理事件

        处理事件
        """
        obj = self.get_object()
        # 判断当前用户有无处理权限
        if (not Remind.objects.filter(event=obj, recipient=request.user, can_handle=True).exists()) and (not request.user.is_superuser):
            raise PermissionDenied('您无权处理该事件')
        data = request.data
        obj.mark = data.get('mark')
        obj.handle_desc = data.get('handle_desc', '')
        obj.handle_user = request.user
        obj.handle_time = timezone.now()
        obj.save()
        return Response()

    def retrieve(self, request, *args, **kwargs):
        obj = self.get_object()
        Thread(target=update_remind_read, args=(obj, request.user), daemon=True).start()
        return super().retrieve(request, *args, **kwargs)


class RemindViewSet(ListModelMixin, CustomGenericViewSet):
    perms_map = {'get': 'envent:view'}
    queryset = Remind.objects.all()
    serializer_class = RemindSerializer
    select_related_fields = ['recipient', 'event']
    prefetch_related_fields = ['event__cates']

    @action(methods=['get'], detail=False, perms_map={'get': '*'})
    def my(self, request, *args, **kwargs):
        """推送给我的

        推送给我的
        """
        user = self.request.user
        queryset = self.filter_queryset(self.get_queryset().filter(recipient=user))

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)


# class MyRemindViewSet(ListModelMixin, CustomGenericViewSet):
#     perms_map = {'get': '*'}
#     serializer_class = RemindSerializer
#     select_related_fields = ['recipient', 'event']
#     prefetch_related_fields = ['event__cates']

#     def get_queryset(self):
#         return Remind.objects.filter(recipient=self.request.user)

#     @action(methods=['post'], detail=True, perms_map={'post': '*'})
#     def label_read(self, request, *args, **kwargs):
#         """标记已读

#         标记已读
#         """