from django.db.models import Q

from oauth2_provider.contrib.rest_framework import TokenHasScope, IsAuthenticatedOrTokenHasScope
from rest_framework import generics, permissions
from rest_framework.response import Response

from apps.transactions.models import Transaction
from apps.transactions.serializers import TransactionSerializer, ServiceTransactionSerializer


def get_application_client_id(request):
    try:
        application = request.auth.application
        if application:
            application_client_id = application.client_id
        else:
            application_client_id = request.auth.detail.get('client_id')
    except:
        application_client_id = None
    return application_client_id


class TransactionList(generics.ListCreateAPIView):
    permission_classes = [permissions.IsAuthenticated, IsAuthenticatedOrTokenHasScope]
    serializer_class = TransactionSerializer
    required_scopes = []

    def get_queryset(self):
        user = self.request.user
        return Transaction.objects.filter(Q(payee=user) | Q(payer=user)).all()

    def perform_create(self, serializer):
        user = self.request.user
        serializer.save(payee=user, application_client_id=get_application_client_id(self.request))


class TransactionDetail(generics.RetrieveAPIView):
    permission_classes = [permissions.IsAuthenticated, IsAuthenticatedOrTokenHasScope]
    serializer_class = TransactionSerializer
    lookup_field = 'uuid'
    required_scopes = []

    def get_queryset(self):
        user = self.request.user
        return Transaction.objects.filter(Q(payee=user) | Q(payer=user) | Q(payer__isnull=True)).all()


class TransactionPay(generics.RetrieveAPIView):
    permission_classes = [permissions.IsAuthenticated, IsAuthenticatedOrTokenHasScope]
    serializer_class = TransactionSerializer
    lookup_field = 'uuid'
    required_scopes = []

    def get_queryset(self):
        user = self.request.user
        return Transaction.objects.filter(Q(payer=user) | Q(payer__isnull=True)).all()

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.pay(payer=self.request.user)
        serializer = self.get_serializer(instance)
        return Response(serializer.data)


class TransactionReceipt(generics.RetrieveAPIView):
    permission_classes = [permissions.IsAuthenticated, IsAuthenticatedOrTokenHasScope]
    serializer_class = TransactionSerializer
    lookup_field = 'uuid'
    required_scopes = []

    def get_queryset(self):
        user = self.request.user
        return Transaction.objects.filter(payer=user).all()

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.receipt()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)


class ServiceTransactionSubmit(generics.CreateAPIView):
    permission_classes = [IsAuthenticatedOrTokenHasScope]
    serializer_class = ServiceTransactionSerializer
    required_scopes = ['transaction.submit']

    def get_queryset(self):
        # TODO: check if application_client_id is None
        application_client_id = get_application_client_id(self.request)
        return Transaction.objects.filter(application_client_id=application_client_id).all()

    def perform_create(self, serializer):
        user = self.request.auth.application.user
        serializer.save(user=user, application_client_id=get_application_client_id(self.request))


class ServiceTransactionVerify(generics.RetrieveAPIView):
    permission_classes = [IsAuthenticatedOrTokenHasScope]
    serializer_class = ServiceTransactionSerializer
    lookup_field = 'uuid'
    required_scopes = ['transaction.verify']

    def get_queryset(self):
        # TODO: check if application_client_id is None
        application_client_id = get_application_client_id(self.request)
        return Transaction.objects.filter(application_client_id=application_client_id).all()

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.verify()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)