from rest_framework.views import APIView
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
import time

from .serializers import SearchEquipSerializer, DeviceListSerializer, DeviceDetailSerializer
from utils.utils import get_equip_list
from utils.JWTAuthentication_diy import MyJWTAuthentication
from utils.permissions import ModulePermission, DeviceDetailPermission, AccessPermission
from utils.MyRateThrottle import DeviceListRateThrottle, DeviceDetailRateThrottle
from utils.paginations import CustomPagination
from utils.db_utils import MongoDBTools
from .models import Device, QXZData


# Create your views here.

class SearchEquip(APIView):
    def post(self, request):
        serializer = SearchEquipSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        request_data = serializer.validated_data
        data = get_equip_list(
            d_id=request_data.get("device_id"),
            isfullId=request_data.get("isfullId")
        )
        return Response(data)


class ReceiveQXZ(APIView):
    def post(self, request):
        data = request.data
        if data.get("cmd") == "offline":
            imei = data["ext"]["imei"]
            try:
                device = Device.objects.get(device_id=imei)
                device.upl_time = int(time.time())
                device.is_online = 0
                device.save()
            except Exception as e:
                print("离线数据保存异常", e)
        elif "terminalStatus" in data:
            imei = data["StationID"]
            status_data = data["terminalStatus"]
            if Device.objects.filter(device_id=imei).exists():
                device = Device.objects.get(device_id=imei)
            else:
                device = Device.objects.create(
                    device_id=imei,
                    device_type=1
                )
            if status_data.get("VOLT"):
                device.volt = status_data.get("VOLT")
            if status_data.get("RSSI"):
                device.rssi = status_data.get("RSSI")
            if status_data.get("ICCID"):
                device.iccid = status_data.get("ICCID")
            if status_data.get("longitude"):
                device.lng = status_data.get("longitude")
            if status_data.get("latitude"):
                device.lat = status_data.get("latitude")
            if status_data.get("Version"):
                device.version = status_data.get("Version")
            device.is_online = 1
            device.upl_time = int(time.time())
            device.save()

        elif 'data' in data:
            imei = data["StationID"]
            save_data = data["data"]
            if Device.objects.filter(device_id=imei).exists():
                device = Device.objects.get(device_id=imei)
            else:
                device = Device.objects.create(
                    device_id=imei,
                    device_type=1
                )
            device.is_online = 1
            device.upl_time = int(time.time())
            device.save()

            QXZData.objects.create(
                device_id=device,
                device_data=save_data,
                add_time=int(time.time())
            )
        return Response("已接收保存")


class DeviceList(GenericAPIView):
    authentication_classes = [MyJWTAuthentication]
    permission_classes = [ModulePermission]
    throttle_classes = [DeviceListRateThrottle]
    serializer_class = DeviceListSerializer
    queryset = Device.objects.all()

    def post(self, request):
        uid = int(request.user.get("uid"))
        device_queryset = self.get_queryset().filter(owner=uid)
        serializer = self.get_serializer(instance=device_queryset, many=True)
        return Response(serializer.data)


class DeviceDetail(GenericAPIView):
    authentication_classes = [MyJWTAuthentication]
    permission_classes = [DeviceDetailPermission]
    throttle_classes = [DeviceDetailRateThrottle]
    serializer_class = DeviceDetailSerializer
    queryset = QXZData.objects.all().order_by("-id")

    def post(self, request):
        deviceId = request.data.get("device_id")
        start_time = int(request.data.get("start_time"))
        device_queryset = self.get_queryset().filter(device_id_id=deviceId, add_time__gt=start_time)
        serializer = self.get_serializer(instance=device_queryset, many=True)
        return Response(serializer.data)


def get_page_or_page_size(request):
    try:
        page = int(request.query_params['page']) - 1
        if page < 0:
            page = 0
    except Exception as e:
        page = 0

    try:
        page_size = int(request.query_params['page_size'])
        if page_size < 0:
            page_size = 10
    except Exception as e:
        page_size = 10
    return page, page_size


class QxzDeviceListView(APIView):
    permission_classes = [AccessPermission]

    def get(self, request, *args, **kwargs):
        """获取气象站设备列表接口"""
        uid = request.uid
        wheres = {
            '$or': [
                {'owner_uid': uid},
                {'user_dealer': uid}
            ]
        },
        project = {
            'device_id': '$device_id',
            'uptime': '$uptime',
            'device_status': '$device_status',
            'lng': '$lng',
            'lat': '$lat'
        }
        page, page_size = get_page_or_page_size(request)
        skip, limit = page * page_size, page_size
        m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
        data = m.find_many(wheres=wheres, options=project, skip=skip, limit=limit)
        result = []
        for item in data:
            result.append(item)
        return Response(result)