# coding=utf-8

from django.db import transaction
from django.db.models import Sum

from rest_framework.views import APIView
from rest_framework_jwt.views import VerifyJSONWebToken,RefreshJSONWebToken
from rest_framework.serializers import ValidationError
from rest_framework.decorators import action

from utils import response_ok, response_error
from utils.permission import IsCustomer, IsEmployee
from utils.custom_modelviewset import CustomModelViewSet

from apps.customer.serializers import WechatLoginSerializer, WechatBindSerializer, CustomerSerializer
from apps.customer.models import Customer
from apps.customer.filters import CustomerFilter
from apps.order.models import Order
from apps.log.models import BizLog
from apps.base import Formater


class WxLoginView(APIView):
    serializer_class = WechatLoginSerializer

    def post(self, request, *args, **kwargs):
        ser = self.serializer_class(data=request.data)
        if ser.is_valid():
            return response_ok(ser.validated_data)
        else:
            return response_error('参数错误')


class WxBindView(APIView):
    serializer_class = WechatBindSerializer

    def post(self, request, *args, **kwargs):
        ser = self.serializer_class(data=request.data)
        if ser.is_valid():
            return response_ok(ser.validated_data)
        else:
            return response_error('参数错误')


class SetUserInfoView(APIView):
    permission_classes = [IsCustomer, ]

    def post(self, request, *args, **kwargs):
        appid = request.POST.get('appid')
        openid = request.POST.get('openid')
        encryptedData = request.POST.get('encryptedData')
        iv = request.POST.get('iv')

        with transaction.atomic():
            face, name = request.customer.setInfo(appid, openid, encryptedData, iv)
        return response_ok({'face': face, 'name': name})


class CustomerHomeView(APIView):
    permission_classes = [IsCustomer, ]

    def get(self, request):
        customer = self.request.customer
        rows = Order.objects.filter(customer=customer)

        item = {
            'point': '%.2f' % customer.points,
            'balance': Formater.formatValueShow(customer.balance),
            'wait_pay': rows.filter(status=Order.WAIT_PAY).count(),
            'wait_dispatch': rows.filter(status=Order.WAIT_DISPATCH).count(),
            'dispatch': rows.filter(status=Order.CONFIRM_DISPATCH).count(),
        }

        return response_ok(item)


class CustomerRefreshTokenView(RefreshJSONWebToken):
    def post(self, request, *args, **kwargs):
        try:
            ser = self.serializer_class(data=request.data)
            if ser.is_valid(raise_exception=True):
                return response_ok({'token': ser.validated_data['token']})
        except ValidationError as e:
            return response_error(u'登录状态失效，请重新登录[' + e.detail['error'][0] + ']')


class CustomerVerifyTokenView(VerifyJSONWebToken):
    def post(self, request, *args, **kwargs):
        try:
            ser = self.serializer_class(data=request.data)
            if ser.is_valid(raise_exception=True):
                return response_ok({'token': ser.validated_data['token']})
        except ValidationError as e:
            return response_error(u'登录状态失效，请重新登录[' + e.detail['error'][0] + ']')


class CustomerViewSet(CustomModelViewSet):
    permission_classes = [IsEmployee, ]
    queryset = Customer.objects.filter()
    serializer_class = CustomerSerializer

    def filter_queryset(self, queryset):
        queryset = queryset.filter()
        f = CustomerFilter(self.request.GET, queryset=queryset)
        return f.qs

    def list(self, request, *args, **kwargs):
        footer = {}
        queryset = self.filter_queryset(self.get_queryset())
        total_row = queryset.aggregate(
            balance=Sum('balance'), points=Sum('points'), success_count=Sum('success_count'),
            total_amount=Sum('total_amount'), total_point=Sum('total_point')
        )
        footer['total_balance'] = Formater.formatValueShow(total_row['balance'] or 0)
        footer['total_points'] = str(total_row['points'] or 0)
        footer['total_success_count'] = str(total_row['success_count'] or 0)
        footer['all_total_amount'] = Formater.formatValueShow(total_row['total_amount'] or 0)
        footer['all_total_point'] = str(total_row['total_point'] or 0)

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response({'data': serializer.data, 'footer': footer})
        serializer = self.get_serializer(queryset, many=True)
        return response_ok({'data': serializer.data, 'footer': footer})

    @action(methods=['get'], detail=False)
    def export(self, request):
        queryset = self.filter_queryset(self.queryset)
        serializer = self.get_serializer(queryset, many=True)
        return response_ok(serializer.data)