from __future__ import absolute_import

from rest_framework.decorators import api_view
from rest_framework.decorators import permission_classes
from rest_framework.permissions import AllowAny, IsAuthenticated
from rest_framework.status import HTTP_200_OK, HTTP_400_BAD_REQUEST, HTTP_403_FORBIDDEN, HTTP_201_CREATED, \
    HTTP_401_UNAUTHORIZED
from rest_framework.response import Response
from rest_framework.authtoken.models import Token

from django.db import transaction
from django.conf import settings

from social.apps.django_app.utils import psa
from push_notifications.models import GCMDevice, APNSDevice

from .utils import success_response, error_response, compose_validation_error_message
from ..models import ApplicationUser, Country, PasswordResetToken, get_default_country
from ..serializers import CreateUserSerializer, SignInSerializer, UpdateProfileSerializer, ChangePasswordSerializer, \
    UserInfoSerializer, NotificationDeviceSerializer
from ..utils import register_device
from ..tasks import send_password_reset_email, send_welcome_email


@api_view(['POST'])
@permission_classes([AllowAny])
def api_signup(request):
    user_serializer = CreateUserSerializer(data=request.data)
    notif_serializer = NotificationDeviceSerializer(data=request.data)

    if user_serializer.is_valid():

        if notif_serializer.is_valid():
            device_type = notif_serializer.validated_data.get('device_type', None)
            registration_id = notif_serializer.validated_data.get('registration_id', None)
        else:
            notif_error_message = compose_validation_error_message(notif_serializer)
            return error_response(notif_error_message, status=HTTP_400_BAD_REQUEST)

        user = user_serializer.save()
        token = user.update_token().key

        if device_type and registration_id:
            register_device(device_type=device_type, registration_id=registration_id, user=user)

        info_serializer = UserInfoSerializer(user)
        send_welcome_email.apply_async(args=[user], countdown=settings.WELCOME_EMAIL_DELAY)
        return success_response("Registration complete.", data={'token': token, 'user': info_serializer.data},
                                status=HTTP_201_CREATED)

    user_error_message = compose_validation_error_message(user_serializer)
    return error_response(user_error_message, status=HTTP_400_BAD_REQUEST)


@api_view(['POST'])
@permission_classes([AllowAny])
def api_signin(request):
    serializer = SignInSerializer(data=request.data)
    notif_serializer = NotificationDeviceSerializer(data=request.data)

    if serializer.is_valid():
        email = serializer.validated_data['login']
        password = serializer.validated_data['password']

        if notif_serializer.is_valid():
            device_type = notif_serializer.validated_data['device_type']
            registration_id = notif_serializer.validated_data['registration_id']
        else:
            notif_error_message = compose_validation_error_message(notif_serializer)
            return error_response(notif_error_message, status=HTTP_400_BAD_REQUEST)

        user = ApplicationUser.objects.filter(email__exact=email).first()

        if user is None:
            return error_response("User does not exists or password is not correct.", status=HTTP_400_BAD_REQUEST)

        if user.disabled:
            return error_response('Account has been deactivated. Confirm email address to continue using service.',
                                 status=HTTP_400_BAD_REQUEST)

        if user.check_password(password):
            register_device(device_type=device_type, registration_id=registration_id, user=user)

            info_serializer = UserInfoSerializer(user)
            return success_response('Success', status=HTTP_200_OK,
                                    data={
                                        'token': user.update_token().key,
                                        'user': info_serializer.data,
                                    }, )
        else:
            return error_response('User does not exists or password is not correct.', HTTP_400_BAD_REQUEST)

    else:
        message = compose_validation_error_message(serializer)
        return error_response(message, status=HTTP_400_BAD_REQUEST)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def api_user_info(request):
    user = request.user
    info_serializer = UserInfoSerializer(user)
    return success_response('Success', status=HTTP_200_OK, data={'user': info_serializer.data,})


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def api_signout(request):
    device = None
    user = request.user
    device_type = request.DATA.get('device_type', None)
    if not device_type:
        return error_response("No device type.", status=HTTP_400_BAD_REQUEST)

    try:
        with transaction.atomic():
            request.auth.delete()
            GCMDevice.objects.filter(user=user).delete()
            APNSDevice.objects.filter(user=user).delete()
        return success_response("Log out complete.", status=HTTP_200_OK)
    except KeyError:
        msg = "Wrong JSON format."
    except Token.DoesNotExist:
        msg = "Bad token."
    return error_response(msg, status=HTTP_400_BAD_REQUEST)


@api_view(['POST'])
@permission_classes([AllowAny, ])
def api_password_reset_request(request):
    email = request.data.get('email', None)

    if not email:
        return error_response('Email is required.', status=HTTP_400_BAD_REQUEST)

    try:
        user = ApplicationUser.objects.get(email=email)
        if user.is_facebook_account:
            return error_response("Sorry, you can't reset your password because this email "
                                  "is linked to the facebook account.")
        Token.objects.filter(user=user).delete()
    except ApplicationUser.DoesNotExist:
        return error_response('User with this email does not exist.', status=HTTP_400_BAD_REQUEST)

    token, created = PasswordResetToken.objects.get_or_create(user=user)
    send_password_reset_email.delay(user=user)

    return success_response('Email with password reset link has been sent.', status=HTTP_200_OK)


@api_view(['POST'])
@permission_classes((AllowAny,))
@psa('social:complete')
def api_facebook_login(request, backend):
    data = request.DATA
    access_token = data.get('access_token')
    device_type = data.get('device_type', None)
    registration_id = data.get('registration_id', None)

    country_code = data.get('country')
    if country_code:
        try:
            country = Country.objects.get(code__iexact=country_code)
        except Country.DoesNotExist:
            country = get_default_country()
    else:
        country = get_default_country()

    try:
        user = request.backend.do_auth(access_token, country=country)
        user.confirmed = True
        user.is_facebook_account = True
        user.save()

        register_device(device_type=device_type, registration_id=registration_id, user=user)
        serializer = UserInfoSerializer(user)
        response_data = {"token": user.update_token().key, "user": serializer.data}
        return success_response(data=response_data, status=HTTP_201_CREATED)
    except Exception:
        return error_response("Authentication error", HTTP_401_UNAUTHORIZED)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def api_set_timezone(request):
    data = request.DATA
    user = request.user
    timezone = data.get('timezone', None)

    if not timezone:
        content = {"status": "error", "message": "No timezone"}
        return Response(content, 400)
    else:
        user.timezone = timezone
        user.save()
        content = {"status": "ok", "message": "Timezone successful updated"}
        return Response(content, 200)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def api_update_profile(request):
    user = request.user
    serializer = UpdateProfileSerializer(user, data=request.data)
    if serializer.is_valid():
        serializer.save()
        return success_response("Profile has been updated.", HTTP_200_OK)
    else:
        message = compose_validation_error_message(serializer)
        return error_response(message, HTTP_400_BAD_REQUEST)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def api_change_password(request):
    user = request.user
    serializer = ChangePasswordSerializer(instance=user, data=request.data, context={'user': user})
    if serializer.is_valid():
        serializer.save()
        return success_response("Password changed successfully.", HTTP_200_OK)
    else:
        message = compose_validation_error_message(serializer)
        return error_response(message, HTTP_400_BAD_REQUEST)