from django.shortcuts import render
from django.utils import timezone
from rest_framework.views import APIView
from rest_framework import serializers
from rest_framework.response import Response
from django.db import transaction
from apps.jwt_auth.models import JwtToken as JwtTokenModel, CUserRoleLoginOpt
from apps.cuser.models import CuserRole as CuserRoleModel, RoleType as RoleTypeModel
from apps.customer.models import Customer as CustomerModel, CustomerResponsible as CustomerResponsibleModel
from rest_framework_simplejwt.tokens import RefreshToken, AccessToken, Token
from rest_framework_simplejwt.authentication import JWTAuthentication
from apps.workspace.models import Workspace as WorkspaceModel
from apps.jwt_auth.services import login_by_username, login_by_mobile, verify_mobile_and_get_token
from django.contrib.auth import get_user_model
from rest_framework import status
CUser = get_user_model()

# Create your views here.


class VerifyMobileAndGetTokenView(APIView):

    class InputSerializer(serializers.Serializer):
        mobile = serializers.IntegerField(required=True)
        opt = serializers.IntegerField(required=True)


    class OutputSerializer(serializers.ModelSerializer):

        class CUserRoleSerializer(serializers.ModelSerializer):

            class RoleTypeSerializer(serializers.ModelSerializer):
                class Meta:
                    model = RoleTypeModel
                    fields = ('role_name', )

            role_type = RoleTypeSerializer()

            class Meta:
                model = CuserRoleModel
                fields = ('name_family', 'title', 'role_type')

        cuser_role = CUserRoleSerializer()

        class Meta:
            model = CUserRoleLoginOpt
            fields = ('cuser_role', 'expire', 'uuid')

    def post(self, request):
        serializer = self.InputSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        print("ok")

        login_opts = verify_mobile_and_get_token(**serializer.validated_data)

        print("ok2")

        response_data = self.OutputSerializer(login_opts, many=True).data

        return Response(response_data)


class LoginByMobileView(APIView):

    class InputSerializer(serializers.Serializer):
        mobile = serializers.IntegerField(required=True)

    def post(self, request):
        serializer = self.InputSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        login_by_mobile(**serializer.validated_data)

        output = {
            "result": {
                "mobile": serializer.validated_data.get('mobile'),
                "message": "opt code send"
            }
        }

        return Response(output)


class LoginByUserView(APIView):

    class InputSerializer(serializers.Serializer):
        username = serializers.CharField(required=True)
        password = serializers.CharField(required=True)

    class OutputSerializer(serializers.ModelSerializer):

        class CUserRoleSerializer(serializers.ModelSerializer):

            class RoleTypeSerializer(serializers.ModelSerializer):
                class Meta:
                    model = RoleTypeModel
                    fields = ('role_name', )

            role_type = RoleTypeSerializer()

            class Meta:
                model = CuserRoleModel
                fields = ('name_family', 'title', 'role_type')

        cuser_role = CUserRoleSerializer()

        class Meta:
            model = CUserRoleLoginOpt
            fields = ('cuser_role', 'expire', 'uuid')

    def post(self, request):
        serializer = self.InputSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        username = serializer.validated_data.get('username')
        password = serializer.validated_data.get('password')

        login_opts = login_by_username(username=username, password=password)

        response_data = self.OutputSerializer(login_opts, many=True).data

        return Response(response_data)


class CustomTokenObtainPairView(APIView):

    class InputSerializer(serializers.Serializer):
        uuid_opt = serializers.CharField(required=True)

    class OutputSerializer(serializers.Serializer):
        access = serializers.CharField(required=True)
        refresh = serializers.CharField(required=True)

    def post(self, request):
        serializer = self.InputSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        uuid_opt = serializer.validated_data.get('uuid_opt')

        try:
            user_login_opt = CUserRoleLoginOpt.objects.get(uuid=uuid_opt)
            user = user_login_opt.cuser_role.cuser
            cuser_role = user_login_opt.cuser_role

            if user_login_opt:
                refresh = RefreshToken.for_user(user)

                #if 'user_id' in refresh:
                #    del refresh['user_id']
                #print(cuser_role.uuid)


                try:
                    customerObj = CustomerModel.objects.get(cuser_role__uuid=str(cuser_role.uuid))

                    #workspace = WorkspaceModel.objects.get(cuser_role_owner__uuid=str(cuser_role.uuid))

                    workspace = customerObj.sys_ws
                except:
                    operator = CustomerResponsibleModel.objects.get(cuser_role=cuser_role)
                    workspace = operator.sys_ws

                refresh['workspace_uuid'] = str(workspace.uuid)

                refresh['cuser_role_uuid'] = str(cuser_role.uuid)

                refresh['user_uuid'] = str(user.uuid)

                #print(str(refresh))

                try:
                    jwt_db = JwtTokenModel(refresh=str(refresh), access=str(refresh.access_token),
                                           cuser=user, cuser_role=cuser_role)
                    jwt_db.save()

                    CUserRoleLoginOpt.objects.filter(cuser_role__cuser=user).delete()

                except Exception as exp:
                    return Response({'error': str(exp)})

                new_token_data = {
                    'refresh': str(refresh),
                    'access': str(refresh.access_token),
                }

                out_data = self.OutputSerializer(data=new_token_data)
                out_data.is_valid(raise_exception=True)

                return Response(out_data.data)
            else:
                return Response({"error": 'userpass is not True'})
        except CUserRoleLoginOpt.DoesNotExist:
            return Response({"error": 'Token not valid'})
        except Exception as exp:
            return Response({"error": 'user or pass is not true 2'})


class CustomTokenRefreshView(APIView):

    class InputSerializer(serializers.Serializer):
        refresh = serializers.CharField(required=True)

    class OutputSerializer(serializers.Serializer):
        access = serializers.CharField(required=True)
        refresh = serializers.CharField(required=True)

    def post(self, request):
        with transaction.atomic():
            try:

                serializer = self.InputSerializer(data=request.data)
                serializer.is_valid(raise_exception=True)

                refresh_token = serializer.validated_data.get('refresh')

                print(refresh_token)

                # check: token is valid?
                ref_token = RefreshToken(token=refresh_token)

                print("ref")

                # first token must exists in whitelist and not blocked
                token_exist = JwtTokenModel.objects.get(refresh=str(refresh_token))

                print("exsist")

                token_is_blocked = JwtTokenModel.objects.get(refresh=str(refresh_token)).is_blocked

                print("yess")

                if token_exist and token_is_blocked is False:
                    JwtTokenModel.objects.get(refresh=str(refresh_token)).delete()
                else:
                    raise ValueError('refresh token is not in whitelist or blocked!')

                user_uuid = ref_token.payload.get('user_uuid')
                user_id = ref_token.payload.get('user_id')
                cuser_role_uuid = ref_token.payload.get('cuser_role_uuid')

                token_exp_timestamp = ref_token.payload.get('exp')
                token_exp = timezone.make_aware(timezone.datetime.fromtimestamp(token_exp_timestamp), timezone.utc)
                user = CUser.objects.get(id=user_id)
                cuser_role = CuserRoleModel.objects.get(uuid=cuser_role_uuid)


                print("OKH###")

                if ref_token:
                    new_token = RefreshToken.for_user(user)

                    #if 'user_id' in new_token:
                        #del new_token['user_id']

                    new_token['user_uuid'] = str(user.uuid)
                    new_token['cuser_role_uuid'] = str(cuser_role.uuid)

                    print("OKOKKO 555")

                    #workspace = WorkspaceModel.objects.get(cuser_role_owner__uuid=str(cuser_role.uuid))

                    try:
                        customerObj = CustomerModel.objects.get(cuser_role__uuid=str(cuser_role.uuid))
                        new_token['workspace_uuid'] = str(customerObj.sys_ws.uuid)
                    except:
                        operator = CustomerResponsibleModel.objects.get(cuser_role__uuid=str(cuser_role.uuid))
                        new_token['workspace_uuid'] = str(operator.sys_ws.uuid)


                    new_access_token = new_token.access_token

                    new_token_data = {
                        'refresh': str(new_token),
                        'access': str(new_access_token),
                    }

                    print("OKOKKO")

                    new_token_obj = JwtTokenModel(refresh=str(new_token),
                                                  access=str(new_token_data.get('access')),
                                                  expire=token_exp,
                                                  cuser=user,
                                                  cuser_role=cuser_role
                                                  )

                    print("OKOKKO 222")
                    new_token_obj.save()
                    out_data = self.OutputSerializer(data=new_token_data)
                    out_data.is_valid(raise_exception=True)
                    return Response(out_data.data)

            except Exception as e:
                transaction.set_rollback(True)
                return Response({"error": str(e)})