import logging
import traceback
from typing import Any

from drf_spectacular.utils import extend_schema, extend_schema_view
from rest_framework import status
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.views import APIView

from engine.payments.docs.drf.views import DEPOSIT_SCHEMA
from engine.payments.models import Transaction
from engine.payments.serializers import DepositSerializer, TransactionProcessSerializer

logger = logging.getLogger(__name__)


@extend_schema_view(**DEPOSIT_SCHEMA)
class DepositView(APIView):
    """Handles deposit operations.

    This class provides an API endpoint to handle deposit transactions.
    It supports the creation of a deposit transaction after validating the
    provided data. If the user is not authenticated, an appropriate response
    is returned. On successful validation and execution, a response
    with the transaction details is provided.

    Attributes:
        No attributes are declared at the class-level for this view.

    Methods:
        post: Processes the deposit request, validates the request data, ensures
        user authentication, and creates a transaction.
    """

    def post(self, request: Request, *args: list[Any], **kwargs: dict[Any, Any]) -> Response:
        logger.debug(request.__dict__)
        serializer = DepositSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        if not request.user.is_authenticated:
            return Response(data=serializer.errors, status=status.HTTP_401_UNAUTHORIZED)

        # noinspection PyUnresolvedReferences
        transaction = Transaction.objects.create(
            balance=request.user.payments_balance, amount=serializer.validated_data["amount"], currency="EUR"
        )

        return Response(TransactionProcessSerializer(transaction).data, status=status.HTTP_303_SEE_OTHER)


@extend_schema(exclude=True)
class CallbackAPIView(APIView):
    """
    Handles incoming callback requests to the API.

    This class processes and routes incoming HTTP POST requests to the appropriate
    gateway handler based on the provided gateway parameter. It is designed to handle
    callback events coming from external systems and provide an appropriate HTTP response
    indicating success or failure.

    Attributes:
        No additional attributes are defined for this class beyond what is
        inherited from APIView.

    Methods:
        post(request, *args, **kwargs): Processes POST requests and routes them
        based on the specified gateway. Handles exceptions gracefully by returning
        a server error response if an unknown gateway or other issues occur.
    """

    def post(self, request: Request, *args: list[Any], **kwargs: dict[Any, Any]) -> Response:
        try:
            transaction = Transaction.objects.get(uuid=kwargs.get("uuid"))
            gateway = transaction.gateway.get_integration_class_object()
            gateway.process_callback(request.data)
            return Response(status=status.HTTP_202_ACCEPTED)
        except Exception as e:
            return Response(
                status=status.HTTP_500_INTERNAL_SERVER_ERROR, data={"error": f"{e}; {traceback.format_exc()}"}
            )