import cryptocode
from django.core.cache import cache
from rest_framework.decorators import permission_classes, api_view
from .models import UserIdentity
from rest_framework.permissions import AllowAny
from django.contrib.auth.models import User, Group
from rest_framework.response import Response
from django.http import HttpResponse
from django.shortcuts import render
from rest_framework import status, viewsets
from oauth2_provider.models import AccessToken
import json
import requests
import random
import uuid
import cryptocode
from oauth2_provider.contrib.rest_framework import (
    TokenHasReadWriteScope,
    OAuth2Authentication, )
from rest_framework.decorators import authentication_classes
from Authentication.models import ClientToken
from Authentication.sms import send_otp_code
from .serializers import UserIdentitySerializer
from datetime import timedelta

BASE_URL = "https://userbackend.rasadyar.com/api/"

ARTA_CLIENT_ID = 'cpxlBf9GPPnk0nfOMLEa6fZyUrew6Z17wujOUMJr'
ARTA_CLIENT_SECRET = 'ONFoHxBCPOtIUw72QnLL4oa0wOKQNQ6h3Hc8pZrk3qHcR759hmgFn7fJZJMh1nQRWMeRGUHbRoTBFCIQn7OsiKrY7y4JM975T7mjM7WXJs3Ezl30gMAUgfpuEpzJgChz'

CHICKEN_CLIENT_SECRET = '4EK8EAPBOGsUHTeTHpgXrjQwbOQKAnNnQIOHmZa3IlOYVafwV1rmoKHhJE91OmLJ201yp7UkGu5TikiesoZxhNj0FYOyTtC7YtcqvopdBO36e2PSnjuqkLt0yCmaK2ph'
CHICKEN_CLIENT_ID = 'DhL3VMce6p3CBPSTwBg1AJjcaREvddWoOP8G8pHc'

LO_CHICKEN_CLIENT_SECRET = "xqZM6iTDe0XDS1mC8iVhahXqb2TWIZ07mx7yYOZrzTYHyHoFYIpvBm6IcM169fsGZ8uQs3gBHmicgbUMVXwbHyJIaCOeFp9SNK72E4v2OR51om3eH43VMQSK4pEKmMX6"
LO_CHICKEN_CLIENT_ID = "kSHxeTGASY8JsczTinnt5t820clWOKC3X1NHnMOi"

HA_CHICKEN_CLIENT_SECRET = 'l2Gt9AgwOfIneoQU2hamnGYCOiIUdAY2nmLI9eCkNo7wXU6TvNEU93oHtk8IzSHzJc5vVkm9scJaAlWGbzumNenGsQbIESbA1mAsLXWoWSllZKCuGyCBTJtKQ7BhnHZ6'
HA_CHICKEN_CLIENT_ID = 'WwpP780hSemYh8K93MqeuZ3HAir3ahQxDTGG43nG'

DM_CLIENT_ID = '2fDx0CopuiLnRz7YyCQD8nBXKjpxzqZg38Fcl02l'
DM_CLIENT_SECRET = 'PKStjauydu4k157bSaoPVenKHvLVtLI9Upn4JxU7tnHhuHPfAUp1abkfWp55orh7dFCXdE09E5CeWu7vBJsv1VpXz13EBl7OSW2LAceo3ztvq4FNAEVmEEt56cEmQzpF'

INSPECTION_CLIENT_ID = 'R2Ox6eqrXPeh1KbeWLDO5MCapuOFpHDvstOOD1XC'
INSPECTION_CLIENT_SECRET = 'imFgEGkcs248XZkLE7JNMo6mwVkiUMGYUBenBAlgZFwW0lyCYILrmh5Akh8dpHbgpCYaSvuYepFu3WdUXY3ZXPDZq11KbqlrmjHwf8wuW2DUsa0oSDozDv4p9Lx3lJPO'


# # Create your views here.
# @api_view(["POST"])
# @permission_classes([AllowAny])
# def GernalSendOtp(request):
#     mobile = request.data["mobile"]
#     state = request.data["state"]
#     try:
#         user = User.objects.get(username__exact=mobile)
#         user_identity = UserIdentity.objects.get(user)
#         client = ClientToken.objects.get(key=user_identity.client.key)
#     except User.DoesNotExist:
#         return Response({'is_user': False}, status=status.HTTP_401_UNAUTHORIZED)
#     if len(mobile) < 11 or len(mobile) > 11:
#         return Response(
#             {
#                 "pattern": "wrong",
#             },
#             status=status.HTTP_403_FORBIDDEN,
#         )
#     key = str(uuid.uuid4())
#     rand = random.randint(10000, 99000)
#     cache.set(key, str(rand), timeout=120)
#     if not User.objects.filter(username=mobile).exists():
#         receptor = mobile
#         send_otp_code(receptor, rand)
#         return Response(
#             {
#                 "is_user": False,
#                 "key": key,
#             },
#             status=status.HTTP_404_NOT_FOUND,
#         )
#
#     if state == "forget_password":
#         receptor = mobile
#         send_otp_code(receptor, rand)
#         return Response(
#             {
#                 "is_user": True,
#                 "key": key,
#             },
#             status=status.HTTP_200_OK,
#         )
#
#     elif state == "change_password":
#         receptor = mobile
#         send_otp_code(receptor, rand)
#         return Response(
#             {
#                 "is_user": True,
#                 "key": key,
#             },
#             status=status.HTTP_200_OK,
#         )
#
#     elif state == "":
#         return Response(
#             {
#                 "is_user": True,
#             },
#             status=status.HTTP_200_OK,
#         )

@api_view(["POST"])
@permission_classes([AllowAny])
def send_otp(request):
    # frontend_url = request.headers.get("Origin")
    # frontend_url = request.data.get("frontend_url", frontend_url)
    # if "https://rasadyaar.ir" in frontend_url:
    #     return Response({'result': 'https://rasadyar.net'}, status.HTTP_401_UNAUTHORIZED)
    mobile = request.data["mobile"]
    state = request.data["state"]
    try:
        user = User.objects.get(username__exact=mobile)
        user_identity = UserIdentity.objects.get(user=user)
    except User.DoesNotExist:
        return Response({'is_user': False}, status=status.HTTP_404_NOT_FOUND)
    if len(mobile) < 11 or len(mobile) > 11:
        return Response(
            {
                "pattern": "wrong",
            },
            status=status.HTTP_403_FORBIDDEN,
        )
    key = str(uuid.uuid4())
    rand = random.randint(10000, 99000)
    cache.set(key, str(rand), timeout=120)
    if not User.objects.filter(username=mobile).exists():
        receptor = mobile
        # send_otp_code(receptor, rand)
        return Response(
            {
                "is_user": False,
                "key": key,
            },
            status=status.HTTP_404_NOT_FOUND,
        )

    if state == "forget_password":
        receptor = mobile
        send_otp_code(receptor, rand)
        return Response(
            {
                "is_user": True,
                "key": key,
                "address": user_identity.client.client_web_address,
                "backend": user_identity.client.client_web_address_backend,
                "api_key": user_identity.client.client_token,

            },
            status=status.HTTP_200_OK,
        )

    elif state == "change_password":
        receptor = mobile
        send_otp_code(receptor, rand)
        return Response(
            {
                "is_user": True,
                "key": key,
                "address": user_identity.client.client_web_address,
                "backend": user_identity.client.client_web_address_backend,
                "api_key": user_identity.client.client_token,
            },
            status=status.HTTP_200_OK,
        )

    elif state == "":
        return Response(
            {
                "is_user": True,
                "address": user_identity.client.client_web_address,
                "backend": user_identity.client.client_web_address_backend,
                "api_key": user_identity.client.client_token,

            },
            status=status.HTTP_200_OK,
        )


@api_view(["POST"])
@permission_classes([AllowAny])
def store_send_otp(request):
    mobile = request.data["mobile"]
    key = str(uuid.uuid4())
    rand = random.randint(10000, 99000)
    cache.set(key, str(rand), timeout=120)
    receptor = mobile
    send_otp_code(receptor, rand)

    return Response(
        {
            "key": key,
        },
        status=status.HTTP_200_OK,
    )


@api_view(["POST"])
@permission_classes([AllowAny])
def change_user_mobile(request):
    first_mobile = request.data["first_mobile_number"]
    second_mobile = request.data["second_mobile_number"]
    user = User.objects.get(username=first_mobile)
    user.username = second_mobile
    user.save()
    # user_identity=UserIdentity.objects.get(mobile=first_mobile)
    # user_identity.mobile=second_mobile
    # user_identity.save()

    return Response({"result": "number changed"}, status=status.HTTP_200_OK)


@api_view(["POST"])
@permission_classes([AllowAny])
def check_otp(request):
    key = request.data["key"]
    code = cache.get(key)
    if request.data["code"] == code:
        return Response(
            {
                "code": True,
            },
            status=status.HTTP_200_OK,
        )
    else:
        return Response(
            {
                "code": False,
            },
            status=status.HTTP_403_FORBIDDEN,
        )


@api_view(["POST"])
@permission_classes([AllowAny])
# @permission_classes([TokenHasReadWriteScope])
@authentication_classes([OAuth2Authentication])
def change_password(request):
    username = request.data["username"]
    password = request.data["password"]
    user = User.objects.get(username=username)
    user.password = cryptocode.encrypt(password, password)
    user.save()

    return Response({"password": "changed"}, status=status.HTTP_200_OK)


@api_view(["POST"])
@permission_classes([AllowAny])
def register(request):
    # if 'role' in request.data.keys() and 'tenant' in request.data.keys():
    #     request.data.pop('role')
    #     request.data.pop('tenant')

    username = request.data["username"]
    password = request.data["password"]
    api_key = request.data["api_key"]
    client = ClientToken.objects.get(client_token=api_key)
    if User.objects.filter(username__exact=username).exists():
        return Response({"result": "user exist"}, status=status.HTTP_400_BAD_REQUEST)

    if 'first_name' in request.data.keys() and 'last_name' in request.data.keys():
        user = User(
            username=username, password=cryptocode.encrypt(password, password), first_name=request.data['first_name'],
            last_name=request.data['last_name']
        )
    else:

        user = User(
            username=username, password=cryptocode.encrypt(password, password)
        )
    user.save()
    # if 'role' in request.data.keys():
    #     group = Group.objects.get(name__exact=request.data['role'])
    if not UserIdentity.objects.filter(user=user):
        user_identity = UserIdentity(
            user=user,
            client=client
        )
        user_identity.save()
        if 'national_code' in request.data.keys():
            user_identity.national_id = request.data['national_code']
        if 'first_name' in request.data.keys() and 'last_name' in request.data.keys():
            user_identity.first_name = request.data['first_name']
            user_identity.last_name = request.data['last_name']
        user_identity.mobile = request.data['username']
        user_identity.save()

        # user_identity.role.add(group)
    data = {
        "username": str(user.username),
        "password": user.password,
        "client_id": client.client_id,
        "client_secret": client.client_secret,
        "grant_type": "client_credentials",
        # "scope": "read"
        "scope": "read write",
    }
    r = requests.post(url=BASE_URL + "token/", data=json.dumps(data), verify=False)
    access = AccessToken.objects.get(token=r.json()["access_token"])
    access.user = user
    access.save()
    dict_info = {
        "access_token": r.json()["access_token"],
        "expires_in": r.json()["expires_in"],
        "token_type": r.json()["token_type"],
        "scope": r.json()["scope"],
        "expire_time": access.expires,
    }
    # r.json()["expire_time"]=access.expires
    return Response(dict_info, status=status.HTTP_200_OK)


@api_view(["POST"])
@permission_classes([AllowAny])
def register_all(request):
    username = request.data["username"]
    password = request.data["password"]
    api_key = request.data["api_key"]
    client = ClientToken.objects.get(client_token=api_key)
    if User.objects.filter(username__exact=username).exists():
        pass

    else:
        if 'first_name' in request.data.keys() and 'last_name' in request.data.keys():
            user = User(
                username=username, password=password, first_name=request.data['first_name'],
                last_name=request.data['last_name']
            )
        else:
            user = User(
                username=username, password=password
            )
        user.save()
        if not UserIdentity.objects.filter(user=user):
            user_identity = UserIdentity(
                user=user,
                client=client
            )
            user_identity.save()
            if 'national_code' in request.data.keys():
                user_identity.national_id = request.data['national_code']
            if 'first_name' in request.data.keys() and 'last_name' in request.data.keys():
                user_identity.first_name = request.data['first_name']
                user_identity.last_name = request.data['last_name']
            user_identity.mobile = request.data['username']
            user_identity.save()

        return Response("ok", status=status.HTTP_200_OK)


@api_view(["POST"])
@permission_classes([AllowAny])
def login(request):
    username = request.data['username']
    password = (request.data['password'],)
    api_key = request.data["api_key"]
    roles = []
    roles_from_request = []
    client = ClientToken.objects.get(client_token=api_key)
    try:
        user = User.objects.get(username__exact=username)
    except User.DoesNotExist:
        return Response({'is_user': False}, status=status.HTTP_401_UNAUTHORIZED)

    if 'role' in request.data.keys():
        if type(request.data['role']) is list:
            roles_from_request = request.data['role']
        else:
            roles_from_request.append(request.data['role'])

    if 'user_key' in request.data.keys():
        for item in roles_from_request:
            group = Group.objects.get(name__exact=item)
            if not UserIdentity.objects.filter(user=user, role=group):
                if not UserIdentity.objects.filter(user=user).exists():
                    user_identity = UserIdentity()
                else:
                    user_identity = UserIdentity.objects.get(user=user)
                user_identity.user = user
                user_identity.key = request.data['user_key']
                user_identity.client = client
                user_identity.save()
                user_identity.role.add(group)
            else:
                user_identity = UserIdentity.objects.get(user=user)
                user_identity.key = request.data['user_key']
                user_identity.client = client
                user_identity.save()
        for item in user_identity.role.all():
            roles.append(item.name)
    decrypted_password = cryptocode.decrypt(user.password, password[0])
    if decrypted_password != password[0]:
        return Response({'password': 'wrong'}, status=status.HTTP_401_UNAUTHORIZED)
    data = {
        "username": username,
        "password": password,
        "client_id": client.client_id,
        "client_secret": client.client_secret,
        "grant_type": "client_credentials",
        "scope": "read write",
    }
    r = requests.post(url=BASE_URL + "token/", data=json.dumps(data), verify=False)
    access = AccessToken.objects.get(token=r.json()["access_token"])
    access.user = user
    access.save()
    dict_info = {
        "access_token": r.json()["access_token"],
        "expires_in": r.json()["expires_in"],
        "token_type": r.json()["token_type"],
        "scope": r.json()["scope"],
        "expire_time": access.expires,
        "role": roles
    }
    return Response(dict_info, status=status.HTTP_200_OK)


class UserIdentityViewSet(viewsets.ModelViewSet):
    queryset = UserIdentity.objects.all()
    serializer_class = UserIdentitySerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        pass

    def retrieve(self, request, *args, **kwargs):
        pass

    def create(self, request, *args, **kwargs):
        edit_type = request.data['type']
        request.data.pop('type')

        if edit_type == 'check_user':
            # return Response({'sss': 'exist'}, status=status.HTTP_201_CREATED)
            # if user exists in system
            if self.queryset.filter(
                    mobile=request.data['value']
            ).exists() or self.queryset.filter(
                national_id=request.data['value']
            ).exists():

                if self.queryset.filter(
                        mobile=request.data['value']
                ).exists():
                    # contains user object
                    user = self.queryset.get(
                        mobile=request.data['value'],
                    )

                if self.queryset.filter(
                        national_id=request.data['value']
                ).exists():
                    # contains user object
                    user = self.queryset.get(
                        national_id=request.data['value'],
                    )
                serializer = self.serializer_class(user)
                return Response(serializer.data, status=status.HTTP_200_OK)
            return Response(status=status.HTTP_404_NOT_FOUND)

    def update(self, request, *args, **kwargs):

        # contains user identity object
        user_identity = UserIdentity.objects.get(key=request.data['userprofile_key'])
        request.data.pop('userprofile_key')  # remove user key from data

        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            identity_obj = serializer.update(validated_data=request.data, instance=user_identity)
            serializer = self.serializer_class(identity_obj)
            return Response(serializer.data, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def destroy(self, request, *args, **kwargs):
        pass


@api_view(["GET"])
@permission_classes([AllowAny])
def Find_User(request):
    data = request.GET["data"]
    if UserIdentity.objects.filter(mobile=data).exists():
        user = UserIdentity.objects.get(mobile=data)
    elif UserIdentity.objects.filter(national_id=data).exists():
        user = UserIdentity.objects.get(national_id=data)
    else:
        return Response({"result": "user not found"}, status=status.HTTP_401_UNAUTHORIZED)

    return Response({
        "firstname": user.first_name,
        "lastname": user.last_name,
        "national_id": user.national_id,
        "mobile": user.mobile,
        "city": user.city,
        "province": user.province,
    })


@api_view(["POST"])
@permission_classes([AllowAny])
def Identity(request):
    user = UserIdentity.objects.get(user__username=request.data["mobile"])
    user.mobile = request.data["mobile"]
    user.first_name = request.data["first_name"]
    user.last_name = request.data["last_name"]
    user.national_id = request.data["national_id"]
    user.city = request.data["city"]
    user.province = request.data["province"]
    user.save()
    return Response({"mobile": user.mobile, "first_name": user.first_name, "last_name": user.last_name})


@api_view(["GET"])
@permission_classes([AllowAny])
def NumberOfActiveUsers(request):
    from datetime import datetime
    now=datetime.now().date()
    access = AccessToken.objects.filter(expires__date__gte=now)
    return Response({"number_of_active_users":len(access)})


@api_view(["GET"])
@permission_classes([AllowAny])
def remove_access_token(request):
    import datetime
    token=request.GET.get('token')
    now = datetime.datetime.now()
    accesses = AccessToken.objects.filter(created__date__gte=now.date() - timedelta(days=3))
    if token is not None:
        accesses=accesses.filter(token=token)
    for access in accesses:
        access.expires = now - timedelta(days=2)
        access.save()
    return Response("ok",status=status.HTTP_200_OK)


@api_view(["GET"])
@permission_classes([AllowAny])
def check_user_exists(request):
    mobile = request.GET.get('mobile')

    if not mobile:
        return Response(
            {"error": "mobile parameter is required"},
            status=status.HTTP_400_BAD_REQUEST
        )

    try:
        user = User.objects.get(username__exact=mobile)
        return Response(
            {
                "exists": True,
                "mobile": mobile,
                "user_id": user.id
            },
            status=status.HTTP_404_NOT_FOUND
        )
    except User.DoesNotExist:
        return Response(
            {
                "exists": False,
                "mobile": mobile
            },
            status=status.HTTP_200_OK
        )


@api_view(["POST"])
@permission_classes([AllowAny])
def remove_user_role(request):
    mobile = request.data.get('mobile')
    role = request.data.get('role')

    if not mobile:
        return Response(
            {"error": "mobile parameter is required"},
            status=status.HTTP_400_BAD_REQUEST
        )

    if not role:
        return Response(
            {"error": "role parameter is required"},
            status=status.HTTP_400_BAD_REQUEST
        )

    try:
        user = User.objects.get(username__exact=mobile)
    except User.DoesNotExist:
        return Response(
            {"error": "user not found"},
            status=status.HTTP_404_NOT_FOUND
        )

    try:
        user_identity = UserIdentity.objects.get(user=user)
    except UserIdentity.DoesNotExist:
        return Response(
            {"error": "user identity not found"},
            status=status.HTTP_404_NOT_FOUND
        )

    try:
        group = Group.objects.get(name__exact=role)
    except Group.DoesNotExist:
        return Response(
            {"error": "role not found"},
            status=status.HTTP_404_NOT_FOUND
        )

    if user_identity.role.filter(id=group.id).exists():
        user_identity.role.remove(group)
        return Response(
            {
                "result": "role removed successfully",
                "mobile": mobile,
                "role": role
            },
            status=status.HTTP_200_OK
        )
    else:
        return Response(
            {
                "error": "user does not have this role",
                "mobile": mobile,
                "role": role
            },
            status=status.HTTP_400_BAD_REQUEST
        )