import re
import pytz
import json
import paho.mqtt.publish as publish
import paho.mqtt.subscribe as subscribe
# import paho.mqtt.subscribe as subscribe
from rest_framework import decorators, mixins

from rest_framework.viewsets import GenericViewSet
from rest_framework.decorators import api_view
from rest_framework.generics import (
    ListAPIView,
)
from django.utils.timezone import timedelta, datetime
from rest_framework.response import Response
from rest_framework import filters
from rest_framework.pagination import PageNumberPagination
from django_filters.rest_framework import DjangoFilterBackend

from rest_framework.permissions import IsAuthenticated
from rest_framework.filters import SearchFilter, OrderingFilter
from django.db.models import Q
from counter.mixins.role import RoleMixin, DeviceListMixin, WeatherStationListMixin
from ..models import MosqPost, DeviceTempLog, WeatherLog, WeatherStationInfo, DeviceInfo
from .pagination import (
    PostLimitOffsetPagination,
    DeviceLogHistoryPagination,
    WeatherlogHistoryPagination,
    DeviceInfoPagination,
    WeatherStationInfoPagination,
)
from .serializers import (
    MosqPostListSerializer,
    DeviceTempLogSerializer,
    WeatherLogSerializer,
    WeatherLogWithInfoSerializer,
    DeviceInfoSerializer,
    WeatherStationInfoSerializer,
    DeviceRemoteSerializer,
)


class DeviceLogPagination(PageNumberPagination):
    page_size = 10
    page_size_query_param = 'limit'
    page_query_param = 'page'
    max_page_size = 1000


class MosquitoPostListAPIView(ListAPIView):
    serializer_class = MosqPostListSerializer
    permission_classes = [IsAuthenticated, ]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = PostLimitOffsetPagination
    search_fields = ['mosq__name', 'mosq__region']

    def get_queryset(self, *args, **kwargs):
        queryset_list = MosqPost.objects.all()
        query = self.request.GET.get('q')
        if query:
            queryset_list = queryset_list.filter(
                Q(mosq__name__contains=query) |
                Q(mosq__region=query)
            ).distinct()
        return queryset_list


class DeviceTempLogListAPIView(ListAPIView, RoleMixin, DeviceListMixin):
    serializer_class = DeviceTempLogSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)
    pagination_class = DeviceLogHistoryPagination
    search_fields = ['device_id']
    filterset_fields = ['device_id']
    ordering_fields = ['create_time']

    def get_queryset(self, *args, **kwargs):
        user_roles = self.get_role()
        start = self.request.GET.get('start')
        end = self.request.GET.get('end')
        queryset = DeviceTempLog.objects.get_queryset().order_by('create_time')

        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)
        last_day = self.request.GET.get('last_day')
        if last_day == '1':
            t = datetime.now().replace(tzinfo=pytz.timezone('UTC')) - timedelta(days=1)
            queryset = queryset.filter(last_time__gte=t).filter(last_time__minute=0)

        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(last_time__gte=start, last_time__lt=end + timedelta(days=1))

        return queryset


class WeatherLogListAPIView(ListAPIView, RoleMixin, WeatherStationListMixin):
    # serializer_class = WeatherLogSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)
    pagination_class = WeatherlogHistoryPagination
    search_fields = ['device_id']
    filterset_fields = ['device_id']
    ordering_fields = ['data_time']

    def get_serializer_class(self):
        with_device = self.request.GET.get('with_device')
        if with_device == 'true':
            return WeatherLogWithInfoSerializer
        return WeatherLogSerializer

    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 = WeatherLog.objects.get_queryset().order_by('-data_time')
        queryset_info = WeatherStationInfo.objects.get_queryset().order_by('device_id')

        if 'staff' in user_roles or 'manager' in user_roles:
            child = self.request.user.get_child()
            device_ids = [query.device_id for query in queryset_info
                          if query.org == self.request.user.org or query.org.id in child]
            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 = WeatherStationInfo.objects.filter(device_name__contains=device)
                device_ids = [device.device_id for device in qs]
                queryset = queryset.filter(device_id__in=device_ids)
        last_day = self.request.GET.get('last_day')
        if last_day == '1':
            t = datetime.now().replace(tzinfo=pytz.timezone('UTC')) - timedelta(days=1)
            queryset = queryset.filter(data_time__gte=t).filter(data_time__minute=0)

        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 WeatherStationInfoAPIView(ListAPIView, RoleMixin):
    serializer_class = WeatherStationInfoSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = WeatherStationInfoPagination
    search_fields = ['name', 'device_id']

    def get_queryset(self, *args, **kwargs):
        user_roles = self.get_role()
        queryset_list = WeatherStationInfo.objects.get_queryset().order_by('device_id')

        if 'staff' in user_roles or 'manager' in user_roles:
            child = self.request.user.get_child()
            device_ids = [query.device_id for query in queryset_list
                          if query.org == self.request.user.org or query.org.id in child]
            queryset_list = queryset_list.filter(device_id__in=device_ids)

        return queryset_list


class DeviceInfoAPIView(ListAPIView, RoleMixin):
    serializer_class = DeviceInfoSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]
    pagination_class = DeviceInfoPagination
    search_fields = ['name', 'device_id']

    def get_queryset(self, *args, **kwargs):
        user_roles = self.get_role()
        queryset_list = DeviceInfo.objects.get_queryset().order_by('device_id')

        if 'staff' in user_roles or 'manager' in user_roles:
            child = self.request.user.get_child()
            device_ids = [query.device_id for query in queryset_list
                          if query.org == self.request.user.org or query.org.id in child]
            queryset_list = queryset_list.filter(device_id__in=device_ids)

        return queryset_list


class DeviceRemoteViewSet(mixins.ListModelMixin,
                          mixins.RetrieveModelMixin,
                          RoleMixin,
                          GenericViewSet):
    serializer_class = DeviceRemoteSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [SearchFilter, OrderingFilter]

    @decorators.action(methods='POST', detail=True)
    def pub(self, request, device_id=None):
        command = request.data.get('command')
        speed = request.data.get('speed')

        if command == 'ledOn':
            message = {'RemoteControl': {'LED': 'ON'}}
        elif command == 'ledOff':
            message = {'RemoteControl': {'LED': 'OFF'}}
        elif command == 'countClear':
            message = {'count': 0}
        elif command == 'mosqClean':
            message = {'MosqDeviceClean': speed}
        else:
            return Response({'error': 'Invalid command'}, status=400)

        topic = f'solarmosquitolamp/devices/{device_id}/control'
        publish.single(topic, payload=json.dumps(message), hostname='8.217.112.255', port=1883)

        return Response({'success': True})

    @decorators.action(methods='POST', detail=True)
    def sub(self, request, device_id=None):
        topic = f'solarmosquitolamp/devices/{device_id}/state'
        msg = subscribe.simple(topic, hostname='8.217.112.255', port=1883)
        print("%s %s" % (msg.topic, msg.payload))

        return Response({'code': 0, 'data': None, 'msg': 'success'})