import time
from typing import Optional
from django.db.models import Q, Min, Max
from django.core.cache import cache
from rest_framework import serializers
from counter.models import DeviceCount, DeviceInfo
from mosquito.models import DeviceInfo as MosquitoDeviceInfo
from mosquito.models import MosqPostStatistic, DevicePostStatistic


def get_vol(device_id, cur_vol):
    vol_min_key = '{}_vol_min'.format(device_id)
    vol_max_key = '{}_vol_max'.format(device_id)
    vol_min = cache.get(vol_min_key)
    vol_max = cache.get(vol_max_key)
    if not vol_min:
        vol_min = DeviceCount.objects.filter(device_id=device_id).aggregate(vol_min=Min('vol'))['vol_min']
        cache.set(vol_min_key, vol_min, 60 * 5)
    if not vol_max:
        vol_max = DeviceCount.objects.filter(device_id=device_id).aggregate(vol_max=Max('vol'))['vol_max']
        cache.set(vol_max_key, vol_max, 60 * 5)

    vol = 100 * (int(cur_vol) - int(vol_min)) / (int(vol_max) - int(vol_min))
    return '{}{}'.format(round(vol, 1), '%')


def get_device_latest_by_cache(device_id, key="device_latest_{}"):
    """
    Get latest device from cache
    """
    latest_key = key.format(device_id)
    latest = cache.get(latest_key)
    if latest:
        return latest

    latest = DeviceCount.objects.filter(device_id=device_id).order_by('-data_time').first()
    if latest is None:
        return None
    s = DeviceCountBaseSerializer(latest)
    data = s.data

    # set cache before return
    set_device_latest_cache(latest_key, data)
    return data


def set_device_latest_cache(key: str, value: serializers.ModelSerializer, timeout=60 * 10):
    cache.set(key, value, timeout)


class DeviceCountBaseSerializer(serializers.ModelSerializer):
    class Meta:
        model = DeviceCount
        fields = '__all__'


class DeviceInfoBaseSerializer(serializers.ModelSerializer):
    class Meta:
        model = MosquitoDeviceInfo
        fields = '__all__'


class DeviceCountSerializer(serializers.ModelSerializer):
    device_name = serializers.SerializerMethodField()
    mosq_count = serializers.SerializerMethodField()
    signal = serializers.SerializerMethodField()
    energy = serializers.SerializerMethodField()
    calc_time = serializers.SerializerMethodField()
    longitude = serializers.SerializerMethodField()
    latitude = serializers.SerializerMethodField()

    class Meta:
        model = DeviceCount
        fields = [
            'id',
            'device_id',
            'device_name',
            'signal',
            'mosq_count',
            'energy',
            'calc_time',
            'longitude',
            'latitude'
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.device = None

    def get_mosq_count(self, obj):
        return obj.count

    def get_signal(self, obj):
        return obj.csq

    def get_energy(self, obj):
        if float(obj.vol) <= 100:
            return '{}{}'.format(round(float(obj.vol), 1), '%')
        return get_vol(obj.device_id, obj.vol)

    def get_calc_time(self, obj):
        return obj.data_time.strftime('%Y-%m-%d %H:%M:%S')

    def get_device_name(self, obj):
        device_id = obj.device_id
        device = cache.get(device_id)
        if device:
            self.device = device
            return device.device_name
        qs = MosquitoDeviceInfo.objects.filter(device_id=device_id)
        if qs.count() > 0:
            device = qs[0]
            self.device = device
            cache.set(device_id, device, 60 * 60 * 24)
            return device.device_name
        return None

    def get_longitude(self, obj):
        device = self.device
        if device:
            if device.longitude:
                return device.longitude
        return obj.longitude

    def get_latitude(self, obj):
        device = self.device
        if device:
            if device.latitude:
                return device.latitude
        return obj.latitude


class DeviceCountWithInfoSerializer(DeviceCountSerializer):
    location_id = serializers.SerializerMethodField()
    weather_code = serializers.SerializerMethodField()
    point_x = serializers.SerializerMethodField()
    point_y = serializers.SerializerMethodField()
    status = serializers.SerializerMethodField()

    class Meta:
        model = DeviceCount
        fields = [
            'id',
            'device_id',
            'device_name',
            'signal',
            'mosq_count',
            'energy',
            'calc_time',
            'longitude',
            'latitude',
            'location_id',
            'weather_code',
            'point_x',
            'point_y',
            'status'
        ]

    def get_location_id(self, obj):
        device = self.device
        if device:
            if device.location_id:
                return device.location_id
        return None

    def get_weather_code(self, obj):
        device = self.device
        if device:
            if device.weather_code:
                return device.weather_code
        return None

    def get_point_x(self, obj):
        device = self.device
        if device:
            if device.point_x:
                return device.point_x
        return None

    def get_point_y(self, obj):
        device = self.device
        if device:
            if device.point_y:
                return device.point_y
        return None

    def get_status(self, obj):
        device = self.device
        online = None
        if device:
            print(device)
            qs = DeviceInfo.objects.filter(device_id=device)
            online = qs[0].online
        return online


device_status_map = {'ON': 1, 'OFF': 0}


class DeviceInfoSerializer(serializers.ModelSerializer):
    device_name = serializers.SerializerMethodField()
    status = serializers.SerializerMethodField()
    count = serializers.SerializerMethodField()
    signal = serializers.SerializerMethodField()
    energy = serializers.SerializerMethodField()
    coordinate = serializers.SerializerMethodField()
    time = serializers.SerializerMethodField()

    class Meta:
        model = DeviceInfo
        fields = [
            'device_id',
            'device_name',
            'chip_type',
            'status',
            'count',
            'signal',
            'energy',
            'coordinate',
            'time',
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.latest = None
        self.cur_device = None
        self.mosq_device_info = None

    def get_device_name(self, obj):
        qs = MosquitoDeviceInfo.objects.filter(device_id=obj.device_id)
        if qs.count() > 0:
            device = qs.first()
            self.cur_device = device
            return device.device_name
        return None

    def get_status(self, obj):
        # 区分一代和二代设备
        if obj.chip_type == 'AIR-V2':
            mosq_device_info = MosquitoDeviceInfo.objects.filter(device_id=obj.device_id).first()
            if mosq_device_info and mosq_device_info.led_status:
                self.mosq_device_info = mosq_device_info
                return device_status_map[mosq_device_info.led_status]

        return obj.online

    def get_count(self, obj) -> str:
        self.latest = get_device_latest_by_cache(obj.device_id)

        # 区分一代和二代设备
        if obj.chip_type == 'AIR-V2':
            if self.mosq_device_info and self.mosq_device_info.count:
                return str(self.mosq_device_info.count)

        if self.latest:
            return self.latest['count']
        return '0'

    def get_signal(self, obj) -> str:
        # 区分一代和二代设备
        if obj.chip_type == 'AIR-V2':
            if self.mosq_device_info and self.mosq_device_info.signal:
                return str(self.mosq_device_info.signal)

        if self.latest:
            return self.latest['csq']
        return '0'

    def get_energy(self, obj) -> str:
        # 区分一代和二代设备
        if obj.chip_type == 'AIR-V2':
            if self.mosq_device_info and self.mosq_device_info.energy:
                return str(self.mosq_device_info.energy)

        if self.latest:
            if float(self.latest['vol']) <= 100:
                return '{}{}'.format(round(float(self.latest['vol']), 1), '%')
            return get_vol(obj.device_id, self.latest['vol'])
        return '0%'

    def get_coordinate(self, obj):
        if self.cur_device:
            lon, lat = [self.cur_device.longitude, self.cur_device.latitude]
            if lon and lat:
                return [lon, lat]
        return None

    def get_time(self, obj):
        if self.latest:
            return self.latest['data_time'].replace('T', ' ').replace('Z', '')
        return None


class LatestDailySerializer(serializers.ModelSerializer):
    class Meta:
        model = MosqPostStatistic
        fields = [
            'date',
            'total',
            'increment',
        ]


class DeviceLogHistorySerializer(serializers.ModelSerializer):
    class Meta:
        model = DevicePostStatistic
        fields = [
            'device_id',
            'total',
            'date'
        ]