/home/liman/liman-backend/limanAuth/ Current File: /home/liman/liman-backend/limanAuth/views.py
import datetime
import json
import random

import requests
from django.db.models import Sum
from django.http import JsonResponse
from rest_framework.response import Response
from rest_framework.decorators import permission_classes as permissionclasses
# Create your views here.
from rest_framework import viewsets, status
from rest_framework.decorators import api_view
from rest_framework.permissions import IsAuthenticated

from accounting.models import Document, DocumentItem
from limanAuth.models import Customer, Porter, User, Vertex
from limanAuth.serializers import CustomerSerializer, PorterSerializer, UserSerializer
from utility.messenger.Messenger import Messenger
from utility.table_engine.src.table_engine import TableEngine
from permissions.permissions import PermissionLevel


class CustomerView(viewsets.ModelViewSet):
    serializer_class = CustomerSerializer
    queryset = Customer.objects.all()
    http_method_names = ['get', 'post', 'patch']

    def get_queryset(self):
        user = self.request.user
        return Customer.objects.filter(porters__user__id=user.pk)

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Customer.objects.filter(porters__user__id=request.user.pk),
            request.bodyDict).init_cols(
            ["user__id", "user__first_name", "user__full_name", "user__last_name",
             ]).execute()
        for item in table_engine['rows'][0]:
            item['depit'] = CustomerSerializer.get_debit(Customer.objects.get(pk=item['user']))
            item['get_conversation_count'] = CustomerSerializer.get_conversation_count(
                Customer.objects.get(pk=item['user']))
            item['get_docs_count'] = CustomerSerializer.get_docs_count(Customer.objects.get(pk=item['user']))
        return JsonResponse(table_engine)

    def create(self, request):
        _inp = request.dict
        user = User.objects.filter(mobile=_inp['mobile']).first()
        if not user:
            user = User.objects.create(mobile=_inp['mobile'], user_type=2)
            user.save()
        else:
            return Response(data={"error": "مشتری قبلا ثبت شده است."}, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        serialized_user = UserSerializer(instance=user, data=_inp)
        if serialized_user.is_valid():
            serialized_user.save()
            customer = Customer.objects.create(user=serialized_user.instance)
            customer.save()
            customer = CustomerSerializer(instance=customer, data=_inp)
            if customer.is_valid():
                customer.save()
                request.user.porter.customers.add(customer.instance)
                customer.instance.porters.add(request.user.porter)
                CustomerView.tahseab_customer(customer.instance)
                return Response(data=customer.data, status=status.HTTP_200_OK)
            else:
                customer.instance.delete()
                user.instance.delete()
                return Response(data=customer.errors, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        else:
            serialized_user.instance.delete()
            return Response(data=serialized_user.errors, status=status.HTTP_422_UNPROCESSABLE_ENTITY)

    def partial_update(self, request, pk):
        try:
            _inp = request.dict
            user = User.objects.filter(pk=pk).first()
            if not user:
                return Response(status=404, data="user not found")
            serializer = UserSerializer(instance=user, data=_inp, partial=True)
            if serializer.is_valid(raise_exception=True):
                serializer.save()
                customer = Customer.objects.get(user=user)
                customer_serializer = CustomerSerializer(instance=customer, data=_inp, partial=True)
                if customer_serializer.is_valid(raise_exception=True):
                    customer_serializer.save()
                    CustomerView.tahseab_customer(customer=customer)
            return Response(serializer.data)
        except Exception as e:
            return Response(str(e), status=422)

    @staticmethod
    def tahseab_customer(customer):
        user = customer.user
        last_doc = Document.objects.filter(user=customer.user).order_by("-created_at").first()
        tahesab_payload = {
            "code": user.id,
            "name": user.first_name + ' ' + user.last_name,
            "Tel": user.mobile,
            "Tel2": (user.phone[0] if user.phone and len(user.phone) else ''),
            "gorooh": getattr(customer.group, 'tahesab_id', ''),
            "Pic": getattr(customer.user, 'profile_img', ''),
            "City": getattr(customer.user.city, 'name', None),
            "BDate": user.birth_date.strftime('YYYY-MM-DDThh:mm') if user.birth_date else None,
            "Moaref": (
                customer.porters.first().user.first_name + ' ' + customer.porters.first().user.last_name if customer.porters.first() else ''),
            "Email": user.email,
            "PostalCode": user.postcode,
            "ShSh": user.national_code,
            "ModatT": int(customer.max_period),
            "EDate": datetime.date.today().strftime('YYYY-MM-DDThh:mm'),
            "Moaref_C": getattr(customer.porters.first(), 'tahesab_id', None),
            "add": user.address,
            "LastSanad": last_doc.created_at.strftime('YYYY-MM-DDThh:mm') if last_doc else None,
            "ShEghtesadi": customer.economical_number,
            "Arz": getattr(customer.first_currency, 'id', ''),
        }
        if not customer.tahesab_id:
            url = 'http://31.7.68.158:81/api/moshtarian/'
            r = requests.post(json=tahesab_payload, url=url)
        else:
            print("update")
            url = f'http://31.7.68.158:81/api/moshtarian/{customer.tahesab_id}/'
            r = requests.patch(json=tahesab_payload, url=url)

        print(r.status_code)
        print(r.content)
        if r.status_code == 201  and not customer.tahesab_id:
            print(json.loads(r.content)['ID'])
            customer.tahesab_id = json.loads(r.content)['ID']
            customer.save()
        return r.status_code


class PorterView(viewsets.ModelViewSet):
    serializer_class = PorterSerializer
    queryset = Porter.objects.all()
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Porter.objects.filter(customers__user__id=request.user.pk),
            request.bodyDict).init_cols(
            ["user__id", "user__first_name", "user__full_name", "user__last_name",
             ]).execute()

        return JsonResponse(table_engine)


class AdminPorterView(viewsets.ModelViewSet):
    serializer_class = PorterSerializer
    queryset = Porter.objects.all()
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']
    access_level = 100

    def partial_update(self, request, pk=None):
        try:
            user = User.objects.get(pk=pk)
            serialized_user = UserSerializer(user, data=request.dict, partial=True)
            if serialized_user.is_valid():
                serialized_user.save()
            else:
                response = dict(
                    status=dict(message="تغیرات ذخیره نشد.", type='error'),
                    user=serialized_user.errors
                )
                return Response(response, status.HTTP_422_UNPROCESSABLE_ENTITY)
            user = Porter.objects.get(user=user)
            serialized_user = PorterSerializer(user, data=request.dict, partial=True)
            if serialized_user.is_valid():
                serialized_user.save()
                response = dict(
                    status=dict(message="تغیرات با موفقیت ثبت شد.", type='success'),
                    user=serialized_user.data
                )
                return Response(response, status.HTTP_200_OK)
            else:
                response = dict(
                    status=dict(message="تغیرات ذخیره نشد.", type='error'),
                    user=serialized_user.errors
                )
                return Response(response, status.HTTP_422_UNPROCESSABLE_ENTITY)
        except Exception as e:
            return Response(data=str(e), status=status.HTTP_422_UNPROCESSABLE_ENTITY)

    def create(self, request):
        _inp = request.dict
        user = User.objects.filter(mobile=_inp['mobile']).first()
        if not user:
            user = User.objects.create(mobile=_inp['mobile'], user_type=3)
            user.save()
        else:
            if Porter.objects.filter(user=user).first():
                return Response(data={"error": "شماره قبلا استفاده شده است."}, status=422)
        serialized_user = UserSerializer(instance=user, data=_inp)
        if serialized_user.is_valid():
            serialized_user.save()
            porter = Porter.objects.create(user=serialized_user.instance)
            porter.save()
            porter = PorterSerializer(instance=porter, data=_inp)
            if porter.is_valid():
                porter.save()
                return Response(data=porter.data, status=status.HTTP_200_OK)
            else:
                serialized_user.instance.delete()
                porter.instance.delete()
                return Response(data=porter.errors, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        else:
            serialized_user.instance.delete()
            return Response(data=serialized_user.errors, status=status.HTTP_422_UNPROCESSABLE_ENTITY)

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Porter.objects.all(),
            request.bodyDict).init_cols(
            ["user__id", "user__first_name", "user__full_name", "user__last_name",
             ]).execute()

        return JsonResponse(table_engine)


class AdminCustomerView(viewsets.ModelViewSet):
    serializer_class = CustomerSerializer
    queryset = Customer.objects.all()
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']
    access_level = 100

    def get_queryset(self):
        return Customer.objects.all()

    def create(self, request):
        _inp = request.dict
        user = User.objects.filter(mobile=_inp['mobile']).first()
        if not user:
            user = User.objects.create(mobile=_inp['mobile'], user_type=3)
            user.save()
        else:
            if Customer.objects.filter(user=user).first():
                return Response(data={"error": "شماره قبلا استفاده شده است."}, status=422)
        serialized_user = UserSerializer(instance=user, data=_inp)
        if serialized_user.is_valid():
            serialized_user.save()
            customer = Customer.objects.create(user=serialized_user.instance)
            customer.save()
            customer = CustomerSerializer(instance=customer, data=_inp)
            if customer.is_valid():
                customer.save()
                CustomerView.tahseab_customer(customer.instance)
                return Response(data=customer.data, status=status.HTTP_200_OK)
            else:
                serialized_user.instance.delete()
                customer.instance.delete()
                return Response(data=customer.errors, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        else:
            user.delete()
            return Response(data=serialized_user.errors, status=status.HTTP_422_UNPROCESSABLE_ENTITY)

    def partial_update(self, request, pk=None):
        try:
            user = User.objects.get(pk=pk)
            serialized_user = UserSerializer(user, data=request.dict, partial=True)
            if serialized_user.is_valid():
                serialized_user.save()
            else:
                response = dict(
                    status=dict(message="تغیرات ذخیره نشد.", type='error'),
                    user=serialized_user.errors
                )
                return Response(response, status.HTTP_422_UNPROCESSABLE_ENTITY)
            user = Customer.objects.get(user=user)
            serialized_user = CustomerSerializer(user, data=request.dict, partial=True)
            if serialized_user.is_valid():
                serialized_user.save()
                CustomerView.tahseab_customer(user)
                response = dict(
                    status=dict(message="تغیرات با موفقیت ثبت شد.", type='success'),
                    user=serialized_user.data
                )
                return Response(response, status.HTTP_200_OK)
            else:
                response = dict(
                    status=dict(message="تغیرات ذخیره نشد.", type='error'),
                    user=serialized_user.errors
                )
                return Response(response, status.HTTP_422_UNPROCESSABLE_ENTITY)
        except Exception as e:
            return Response(data=str(e), status=status.HTTP_422_UNPROCESSABLE_ENTITY)

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Customer.objects.all(),
            request.bodyDict).init_cols(
            ["user__id", "user__first_name", "user__full_name", "user__last_name",
             ]).execute()

        return JsonResponse(table_engine)


class AdminUserView(viewsets.ModelViewSet):
    serializer_class = UserSerializer
    queryset = User.objects.all()
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']
    access_level = 100

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            User.objects.all(),
            request.bodyDict).init_cols(
            ["id", "first_name", "full_name", "last_name",
             ]).execute()
        for item in table_engine['rows'][0]:
            table_engine['rows'][0][table_engine['rows'][0].index(item)] = UserSerializer(
                instance=User.objects.get(pk=item['id'])).data
            return JsonResponse(table_engine)


class Authenticator:
    class SmsAuth:
        @staticmethod
        def verify(user, code):
            result = user.sms_token == str(code)
            print(result)
            if result:
                user.sms_token = ''
                user.save()
                return True
            return False

        @staticmethod
        def send(user, type='token'):
            try:
                sms_token = random.randint(1000, 9999)
                user.sms_token = sms_token
                user.save()
                result = Messenger.send_sms_to_phone_number(phone_number=user.mobile,
                                                            pattern='limanLogin',
                                                            tokens={'token': sms_token})
                return result
            except Exception as e:
                print(e)
                return e


def calc_ranking(user_id, type):
    debit_gold = DocumentItem.objects.filter(document__deposit=False, negotiable__slug="gold",
                                             document__accepted=True).values('document__created_at__date').order_by(
        'document__created_at__date').annotate(sum=Sum('weight')).all()
    total = 0
    total_amount = 0
    for item in debit_gold:
        days_count = (datetime.date.today() - item['document__created_at__date']).days
        total += days_count * item['sum']
        total_amount += item['sum']
    debit_gold_vertex = float(total / total_amount) if total_amount else 0
    payed_gold = DocumentItem.objects.filter(document__deposit=True, negotiable__slug="gold",
                                             document__accepted=True).values('document__created_at__date').order_by(
        'document__created_at__date').annotate(sum=Sum('weight')).all()
    total = 0
    total_amount = 0
    for item in payed_gold:
        days_count = (datetime.date.today() - item['document__created_at__date']).days
        total += days_count * item['sum']
        total_amount += item['sum']
    payed_gold_vertex = float(total / total_amount) if total_amount else 0

    gold_vertex = debit_gold_vertex - payed_gold_vertex
    debit_cash = DocumentItem.objects.filter(document__deposit=False, negotiable__slug="cash",
                                             document__accepted=True).values('document__created_at__date').order_by(
        'document__created_at__date').annotate(sum=Sum('weight'))
    total = 0
    total_amount = 0
    for item in debit_cash:
        days_count = (datetime.date.today() - item['document__created_at__date']).days
        total += days_count * item['sum']
        total_amount += item['sum']
    debit_cash_vertex = float(total / total_amount) if total_amount else 0

    payed_cash = DocumentItem.objects.filter(document__deposit=True, negotiable__slug="cash",
                                             document__accepted=True).values('document__created_at__date').order_by(
        'document__created_at__date').annotate(sum=Sum('weight'))
    total = 0
    total_amount = 0
    for item in payed_cash:
        days_count = (datetime.date.today() - item['document__created_at__date']).days
        total += days_count * item['sum']
        total_amount += item['sum']
    payed_cash_vertex = float(total / total_amount) if total_amount else 0

    cash_vertex = debit_cash_vertex - payed_cash_vertex

    _rank = Vertex.objects.create(
        gold_vertex=gold_vertex,
        rial_vertex=cash_vertex,
        customer_id=user_id if type == 'customer' else None
    )
    return True