"""
Payment validation endpoint for processing payment method-specific validations.
Handles QR reference verification, wallet checks, etc.
"""
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status, permissions
from apps.core.utils import error_response
from apps.business.orders.models import Order
from apps.business.wallet.models import Wallet
import logging

logger = logging.getLogger(__name__)


class PaymentValidateAPIView(APIView):
    """
    API endpoint to validate payment method-specific details.
    
    POST /api/v1/web/payment-validate/
    {
        "order_id": "uuid",
        "payment_method": "qr_scan|razorpay|main_wallet|repurchase_wallet|cash_payment",
        "qr_reference": "optional - for qr_scan",
        "razorpay_payment_id": "optional - for razorpay"
    }
    """
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request):
        user = request.user
        
        # Validate required fields
        order_id = request.data.get('order_id')
        payment_method = request.data.get('payment_method', '').lower()
        
        if not order_id:
            return error_response(
                message="Order ID is required.",
                code="ORDER_ID_REQUIRED",
                status_code=status.HTTP_400_BAD_REQUEST
            )
        
        if not payment_method or payment_method not in ['qr_scan', 'main_wallet', 'repurchase_wallet', 'razorpay', 'cash_payment']:
            return error_response(
                message="Invalid payment method.",
                code="INVALID_PAYMENT_METHOD",
                status_code=status.HTTP_400_BAD_REQUEST
            )
        
        # Fetch the order
        try:
            order = Order.objects.get(id=order_id, user=user)
        except Order.DoesNotExist:
            return error_response(
                message="Order not found or does not belong to you.",
                code="ORDER_NOT_FOUND",
                status_code=status.HTTP_404_NOT_FOUND
            )
        
        # Route to appropriate validation
        if payment_method == 'qr_scan':
            return self._validate_qr_scan(user, order, request.data)
        elif payment_method == 'razorpay':
            return self._validate_razorpay(user, order, request.data)
        elif payment_method == 'cash_payment':
            return self._validate_cash_payment(user, order)
        elif payment_method in ['main_wallet', 'repurchase_wallet']:
            return self._validate_wallet(user, order, payment_method)
        
        return error_response(
            message="Unsupported payment method.",
            code="UNSUPPORTED_METHOD",
            status_code=status.HTTP_400_BAD_REQUEST
        )

    def _validate_qr_scan(self, user, order, data):
        """Validate QR scan payment with reference number."""
        qr_reference = data.get('qr_reference', '').strip()
        
        if not qr_reference:
            return error_response(
                message="QR reference is required for QR scan payments.",
                code="QR_REFERENCE_REQUIRED",
                status_code=status.HTTP_400_BAD_REQUEST
            )
        
        if len(qr_reference) < 3:
            return error_response(
                message="QR reference must be at least 3 characters.",
                code="QR_REFERENCE_INVALID",
                status_code=status.HTTP_400_BAD_REQUEST
            )
        
        # Update order with QR reference
        order.qr_reference = qr_reference
        order.payment_method = 'qr_scan'
        order.save(update_fields=['qr_reference', 'payment_method'])
        
        logger.info(f"QR scan payment validated for order {order.id} by user {user.id}")
        
        return Response(
            {
                "success": True,
                "message": "QR reference validated successfully.",
                "data": {
                    "order_id": str(order.id),
                    "qr_reference": qr_reference,
                    "payment_method": "qr_scan"
                }
            },
            status=status.HTTP_200_OK
        )

    def _validate_razorpay(self, user, order, data):
        """Validate Razorpay payment details."""
        razorpay_payment_id = data.get('razorpay_payment_id', '').strip()
        
        if not razorpay_payment_id:
            return error_response(
                message="Razorpay payment ID is required.",
                code="RAZORPAY_PAYMENT_ID_REQUIRED",
                status_code=status.HTTP_400_BAD_REQUEST
            )
        
        # Here you would typically verify the payment with Razorpay API
        # For now, we'll just update the order
        order.payment_method = 'razorpay'
        order.save(update_fields=['payment_method'])
        
        logger.info(f"Razorpay payment validated for order {order.id} by user {user.id}")
        
        return Response(
            {
                "success": True,
                "message": "Razorpay payment validated successfully.",
                "data": {
                    "order_id": str(order.id),
                    "payment_method": "razorpay"
                }
            },
            status=status.HTTP_200_OK
        )

    def _validate_wallet(self, user, order, payment_method):
        """Validate wallet payment (check if user has sufficient balance)."""
        try:
            wallet = Wallet.objects.get(user=user, wallet_type=payment_method)
        except Wallet.DoesNotExist:
            return error_response(
                message=f"Wallet not found for payment method: {payment_method}",
                code="WALLET_NOT_FOUND",
                status_code=status.HTTP_404_NOT_FOUND
            )
        
        # Check balance
        if wallet.balance < order.amount:
            return error_response(
                message=f"Insufficient balance in {payment_method} wallet.",
                code="INSUFFICIENT_BALANCE",
                status_code=status.HTTP_400_BAD_REQUEST
            )
        
        # Update order with payment method
        order.payment_method = payment_method
        order.save(update_fields=['payment_method'])
        
        logger.info(f"Wallet payment ({payment_method}) validated for order {order.id} by user {user.id}")
        
        return Response(
            {
                "success": True,
                "message": f"{payment_method} wallet payment validated successfully.",
                "data": {
                    "order_id": str(order.id),
                    "payment_method": payment_method,
                    "available_balance": str(wallet.balance)
                }
            },
            status=status.HTTP_200_OK
        )

    def _validate_cash_payment(self, user, order):
        """Mark cash payment as submitted for admin review."""
        order.payment_method = 'cash_payment'
        order.status = 'PAYMENT_REVIEW'
        order.save(update_fields=['payment_method', 'status'])

        logger.info(f"Cash payment submitted for review for order {order.id} by user {user.id}")

        return Response(
            {
                "success": True,
                "message": "Cash payment submitted. Awaiting admin confirmation.",
                "data": {
                    "order_id": str(order.id),
                    "payment_method": "cash_payment",
                    "status": "PAYMENT_REVIEW"
                }
            },
            status=status.HTTP_200_OK
        )