import re
import pytz
from datetime import datetime, time, timedelta
from django.db.models import Sum, Max
from django.core.cache import cache
from rest_framework.generics import (
    ListAPIView,
    RetrieveAPIView,
    CreateAPIView
)
from rest_framework.views import APIView
from rest_framework.response import Response

from rest_framework.permissions import IsAuthenticated
from rest_framework.filters import SearchFilter, OrderingFilter
from mosquito.api.pagination import (
    PostLimitOffsetPagination,
    PostPageNumberPagination,
    DeviceLogListPagination,
    DeviceLogHistoryPagination
)
from .serializers import (
    DeviceCountSerializer,
    DeviceInfoSerializer,
    LogHistorySerializer,
    DeviceLogHistorySerializer,
)
from ..mixins.role import RoleMixin, DeviceListMixin
from ..models import DeviceCount, DeviceInfo
from mosquito.models import MosqPostStatistic, DevicePostStatistic
from mosquito.models import DeviceInfo as CelexDeviceInfo


class DeviceLogListAPIView(ListAPIView, RoleMixin, DeviceListMixin):
    serializer_class = DeviceCountSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = DeviceLogListPagination
    search_fields = ['device_id']

    def get_queryset(self, *args, **kwargs):
        user_roles = self.get_role()
        device = self.request.GET.get('device')
        start = self.request.GET.get('start')
        end = self.request.GET.get('end')
        queryset = DeviceCount.objects.get_queryset().order_by('-data_time')
        if 'staff' in user_roles or 'manager' in user_roles:
            device_list = self.get_device_list()
            device_ids = [query.device_id for query in device_list if query.org == self.request.user.org]
            queryset = queryset.filter(device_id__in=device_ids)
        if device:
            # device_id or device_name
            qs = queryset.filter(device_id__icontains=device)
            if qs.count() > 0:
                queryset = qs
            else:
                qs = CelexDeviceInfo.objects.filter(device_name__contains=device)
                device_ids = [device.device_id for device in qs]
                queryset = queryset.filter(device_id__in=device_ids)
        if start and end:
            t_pattern = re.compile(r'^2\d{3}-\d{1,2}-\d{1,2}$')
            start_m = t_pattern.match(start)
            end_m = t_pattern.match(end)
            if not start_m or not end_m:
                return Response({'detail': 'start or end must be format "yyyy-mm-dd"'})
            start = datetime.strptime(start, '%Y-%m-%d')
            end = datetime.strptime(end, '%Y-%m-%d')
            queryset = queryset.filter(data_time__gte=start, data_time__lt=end + timedelta(days=1))
        return queryset


class DeviceInfoListAPIView(ListAPIView, RoleMixin):
    serializer_class = DeviceInfoSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = PostPageNumberPagination
    search_fields = ['device_id', 'online']

    def get_queryset(self, *args, **kwargs):
        user_roles = self.get_role()
        queryset = DeviceInfo.objects.get_queryset().order_by('-online')
        if 'staff' in user_roles or 'manager' in user_roles:
            device_ids = [query.device_id for query in queryset if query.org == self.request.user.org]
            queryset = queryset.filter(device_id__in=device_ids)
        device_id = self.request.GET.get('device_id')
        status = self.request.GET.get('status')

        if device_id:
            queryset = queryset.filter(device_id__icontains=device_id)

        if status:
            queryset = queryset.filter(online=int(status))
        return queryset


class DeviceLogStatisticAPIView(APIView, RoleMixin):
    permission_classes = [IsAuthenticated]

    def get(self, request, *args, **kwargs):
        # calc total count, no cache
        devices = self.get_devices()
        total_count_queryset = [DeviceCount.objects.filter(device_id=x['device_id'],
                                                           data_time=x['max_time']).order_by('-count')[0]
                                for x in DeviceCount.objects.filter(
                device_id__in=devices).values('device_id').annotate(max_time=Max('data_time'))]
        if total_count_queryset:
            total_count = sum(map(lambda x: int(x.count), total_count_queryset))
        else:
            total_count = 0

        tz = pytz.timezone("UTC")
        today = datetime.now(tz).date()

        # calc month_ago_count, put it in redis as cache.
        if cache.get('month_ago_count'):
            month_ago_count = cache.get('month_ago_count')
        else:
            cur_month = tz.localize(datetime.combine(datetime(today.year, today.month, 1), time(0, 0)), is_dst=None)
            one_month_ago_queryset = [
                DeviceCount.objects.filter(device_id=x['device_id'], data_time=x['max_time']).order_by('-count')[0]
                for x in DeviceCount.objects.filter(
                    data_time__lt=cur_month, device_id__in=devices).values('device_id').annotate(
                    max_time=Max('data_time'))]
            if one_month_ago_queryset:
                one_month_ago_count = sum(map(lambda x: int(x.count), one_month_ago_queryset))
                month_ago_count = total_count - one_month_ago_count
            else:
                month_ago_count = 0
            cache.set('month_ago_count', month_ago_count, 60 * 60)

        # calc daily count, put it in redis as cache.
        if cache.get('daily_count'):
            daily_count = cache.get('daily_count')
        else:
            midnight = tz.localize(datetime.combine(today, time(0, 0)), is_dst=None)
            one_day_ago_queryset = [DeviceCount.objects.filter(device_id=x['device_id'], data_time=x['max_time']).order_by('-count')[0]
                                    for x in DeviceCount.objects.filter(
                                        data_time__lt=midnight, device_id__in=devices).values('device_id').annotate(max_time=Max('data_time'))]
            if one_day_ago_queryset:
                one_day_ago_count = sum(map(lambda x: int(x.count), one_day_ago_queryset))
                daily_count = total_count - one_day_ago_count
            else:
                daily_count = 0
            cache.set('daily_count', daily_count, 60 * 60)

        # print(total_count, month_ago_count)
        data = {'month_ago_count': month_ago_count, 'daily_count': daily_count}
        return Response(data)

    def get_devices(self):
        user_roles = self.get_role()
        queryset = DeviceInfo.objects.get_queryset().order_by('-online')
        if 'staff' in user_roles or 'manager' in user_roles:
            device_ids = [query.device_id for query in queryset if query.org == self.request.user.org]
            queryset = queryset.filter(device_id__in=device_ids)
        return queryset


class DeviceInfoStatisticAPIView(APIView, RoleMixin):
    permission_classes = [IsAuthenticated]

    def get(self, request, *args, **kwargs):
        user_roles = self.get_role()
        online_devices = DeviceInfo.objects.filter(online=1)
        offline_devices = DeviceInfo.objects.filter(online=0)
        if 'staff' in user_roles or 'manager' in user_roles:
            online_ids = [query.device_id for query in online_devices if query.org == self.request.user.org]
            offline_ids = [query.device_id for query in offline_devices if query.org == self.request.user.org]
            online_devices = online_devices.filter(device_id__in=online_ids)
            offline_devices = offline_devices.filter(device_id__in=offline_ids)
        online_count = online_devices.count()
        offline_count = offline_devices.count()

        data = {'online_count': online_count, 'offline_count': offline_count}
        return Response(data)


class LogHistoryListAPIView(ListAPIView):
    serializer_class = LogHistorySerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = PostLimitOffsetPagination
    search_fields = ['date']
    queryset = MosqPostStatistic.objects.all().order_by('-date')


class DeviceLogHistoryListAPIView(ListAPIView, RoleMixin, DeviceListMixin):
    serializer_class = DeviceLogHistorySerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = DeviceLogHistoryPagination
    search_fields = ['device_id', 'date']

    def get_queryset(self, *args, **kwargs):
        user_roles = self.get_role()
        device_id = self.request.GET.get('device_id')
        queryset = DevicePostStatistic.objects.get_queryset().order_by('-date')

        if 'staff' in user_roles or 'manager' in user_roles:
            devices = self.get_device_list()
            device_ids = [device.device_id for device in devices if device.org == self.request.user.org]
            queryset = queryset.filter(device_id__in=device_ids)

        if device_id:
            queryset = queryset.filter(device_id__icontains=device_id)

        return queryset