#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import base64
import json
import time
import xlwt

from django.http import StreamingHttpResponse, HttpResponse, QueryDict
from django.utils.decorators import method_decorator
from django.views import View
from django.views.decorators.csrf import csrf_exempt

from Model.models import UIDModel, UserUIDModel, UserModel, LogModel
from Object.RedisObject import RedisObject
from Object.TokenObject import TokenObject
from Object.ResponseObject import ResponseObject
from Service.CommonService import CommonService


class UploadUIDFileView(View):

    @method_decorator(csrf_exempt)
    def dispatch(self, request, *args, **kwargs):
        return super(UploadUIDFileView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.GET
        fileName = request.FILES.get('fileName', None)
        return self.validate(fileName, request_dict, request)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.POST
        fileName = request.FILES.get('fileName', None)
        return self.validate(fileName, request_dict, request)

    def validate(self, fileName, request_dict, request):
        token = request_dict.get('token', None)
        area = request_dict.get('area', None)
        isReset = request_dict.get('isReset', 0)
        content = request_dict.get('fileName', None)
        print('content')
        print(content)

        content = base64.b64decode(content).decode().strip()
        content = content[3:(len(content) - 3)]
        uids = content.split('\n')
        print(uids)

        response = ResponseObject()

        tko = TokenObject(token)
        if tko.code != 0:
            return response.json(tko.code)

        # if not fileName and not area:
        #     return response.json(444, 'fileName,area')

        data = {}
        duplicate = []
        for line in uids:

            if data.__contains__(line):
                duplicate.append(line)
            else:
                data[line] = ''

        if isReset == 0:
            return self.do_insert(data, duplicate, area, response, request, tko)
        else:
            return self.do_reset(data, response, area, request, tko)

    def do_insert(self, data, duplicate, area, response, request, token):
        bulk = []
        count = 0
        add_time = int(time.time())
        update_time = int(time.time())
        keys = data.keys()
        # redisObject = RedisObject(db=3)
        for item in keys:
            key = item.strip()
            # value = redisObject.get_data(key)
            # if value is False:
            #     # redisObject.set_data(key, '1', 600)
            # else:
            #     duplicate.append(key)
            #     continue
            bulk.append(UIDModel(
                uid=item.strip(),
                uid_extra='',
                status=0,
                add_time=add_time,
                update_time=update_time,
                area=area
            ))
            try:
                if (count % 5000) == 0:
                    UIDModel.objects.bulk_create(bulk)
                    bulk.clear()
            except Exception as e:
                print(repr(e))
                return response.json(174, str(e))
            count += 1

        if len(bulk) > 0:
            UIDModel.objects.bulk_create(bulk)
            bulk.clear()
        del data
        del bulk

        # print('重复：')
        # print(duplicate)

        operation = self.formatOperation(operation='上传', quantity=int(count), area=int(area))
        self.add_log(request, operation, token)
        return response.json(0, {'count': count, 'duplicate_count': len(duplicate), 'data': duplicate})

    def do_reset(self, data, response, area, request, token):
        keys = data.keys()
        uids = []
        count = 0
        for key in keys:
            uids.append(key)
            if len(uids) % 5000 == 0:
                count += self.do_update_uid_status(uids, area)
                uids.clear()

        if len(uids) > 0:
            count += self.do_update_uid_status(uids, area)
            uids.clear()

        operation = self.formatOperation('重置', int(count), int(area))
        self.add_log(request, operation, token)
        return response.json(0)

    def do_update_uid_status(self, uids, area):
        uid_qs = UIDModel.objects.filter(uid__in=uids, area=area, status=2)
        if uid_qs.exists():
            for uid in uid_qs:
                if uid.status == 2:
                    uid.status = 1
            UIDModel.objects.bulk_update(uid_qs, fields=['status'])
            return uid_qs.count()
        return 0

    def add_log(self, request, operation, token):
        ip = CommonService.get_ip_address(request)
        now_time = time.time()
        content = json.dumps(request.POST)
        user_qs = UserModel.objects.filter(id=token.userID)

        log = {
            'status': 200,
            'content': content,
            'ip': ip,
            'time': now_time,
            'url': 'upload',
            'operation': operation,
            'user': user_qs[0]
        }

        try:
            LogModel.objects.create(**log)
        except Exception as e:
            print(repr(e))

    def formatOperation(self, operation, quantity, area):
        str = '{operation}{quantity}个{area}UID'
        if area == 0:
            return str.format(operation=operation, quantity=quantity, area='国内')
        else:
            return str.format(operation=operation, quantity=quantity, area='国外')

class DownloadUIDFileView(View):

    @method_decorator(csrf_exempt)
    def dispatch(self, request, *args, **kwargs):
        return super(DownloadUIDFileView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.GET
        return self.validate(request_dict)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.POST
        return self.validate(request_dict)

    def validate(self, request_dict):
        token = request_dict.get('token', None)
        area = request_dict.get('area', None)
        quantity = int(request_dict.get('quantity', None))
        fileType = request_dict.get('fileType', None)
        response = ResponseObject()

        # print(area)
        # print(quantity)
        token = TokenObject(token)
        if token.code != 0:
            return response.json(token.code)

        if not area:
            return response.json(444, 'area')

        area = int(area)

        if area >= 0 and quantity > 0:

            uid_qs = UserUIDModel.objects.filter(user__id=token.userID, uid__status=1, uid__area=area). \
                values('uid__id', 'uid__uid', 'uid__uid_extra', 'uid__add_time', 'uid__update_time', 'uid__area')
            count = uid_qs.count()
            if count < quantity:
                return response.json(444, '设备UID不足')

            if uid_qs.exists():
                uid_qs = uid_qs[0:quantity]
                if fileType == 'txt':
                    return self.download_txt(uid_qs)
                elif fileType == 'excel':
                    return self.download_excel(uid_qs)
                else:
                    return response.json(444, 'fileType')
            else:
                return response.json(444, '111')
        else:
            return response.json(444, '222')

    def download_txt(self, uid_qs):
        updates = []
        content = ''
        for item in uid_qs:
            content += item['uid__uid']
            content += '\n'
            updates.append(UIDModel(
                id=item['uid__id'],
                uid=item['uid__uid'],
                uid_extra=item['uid__uid_extra'],
                status=2,
                add_time=item['uid__add_time'],
                update_time=item['uid__update_time'],
                area=item['uid__area']
            ))
            if len(updates) % 5000 == 0:
                UIDModel.objects.bulk_update(updates, fields=["status"])
                updates.clear()
            # print(item['uid__uid'])

        if len(updates) > 0:
            UIDModel.objects.bulk_update(updates, fields=["status"])
            updates.clear()

        del updates
        content = content[0:len(content) - 1]
        response = StreamingHttpResponse(content)
        response['Content-Type'] = 'application/octet-stream'
        response['Content-Disposition'] = 'attachment;filename=UID'+time.strftime('-%Y-%m-%d-%H-%M-%S', time.localtime()) + '.txt'
        return response

    def download_excel(self, uid_qs):
        response = HttpResponse(content_type='application/vnd.ms-excel')
        response['Content-Disposition'] = 'attachment; filename=UID' + time.strftime('-%Y-%m-%d-%H-%M-%S', time.localtime()) + '.xls'
        workbook = xlwt.Workbook(encoding='utf-8')
        sheet1 = workbook.add_sheet('UID')
        row1 = [u'设备UID']
        for i in range(0, len(row1)):
            sheet1.write(0, i, row1[i])

        num = 1
        updates = []
        for item in uid_qs:
            uid = item['uid']
            sheet1.write(num, 0, uid)
            num += 1
            updates.append(UIDModel(
                id=item['id'],
                uid=item['uid'],
                uid_extra=item['uid_extra'],
                status=1,
                add_time=item['add_time'],
                update_time=item['update_time'],
                area=item['area']
            ))

        UIDModel.objects.bulk_update(updates, fields=["status"])
        workbook.save(response)
        return response