"""
Payment Gateway Integration Views
Supports Razorpay for online payments
"""
from django.http import JsonResponse
from django.shortcuts import render
from django.views.decorators.http import require_http_methods
from django.contrib.auth.decorators import login_required
from django.conf import settings
from django.views.decorators.csrf import csrf_exempt
import json
from decimal import Decimal
from .utils import BankAPIClient


@login_required
@require_http_methods(["POST"])
def initiate_payment(request):
    """
    Initiate online payment with Razorpay
    Step 1: Create order on Razorpay
    """
    try:
        data = json.loads(request.body)
        amount = float(data.get('amount', 0))
        order_id = data.get('order_id')
        
        if amount <= 0:
            return JsonResponse({
                'success': False,
                'message': 'Invalid amount'
            }, status=400)
        
        # TODO: Initialize Razorpay client when keys are configured
        # For now, return a placeholder response
        if not settings.RAZORPAY_KEY_ID or not settings.RAZORPAY_KEY_SECRET:
            return JsonResponse({
                'success': False,
                'message': 'Payment gateway not configured yet. Please use Cash on Delivery.',
                'coming_soon': True
            })
        
        # When Razorpay is configured, use this:
        # import razorpay
        # client = razorpay.Client(auth=(settings.RAZORPAY_KEY_ID, settings.RAZORPAY_KEY_SECRET))
        # 
        # razorpay_order = client.order.create({
        #     'amount': int(amount * 100),  # Amount in paise
        #     'currency': 'INR',
        #     'receipt': f'order_{order_id}',
        #     'payment_capture': 1
        # })
        # 
        # return JsonResponse({
        #     'success': True,
        #     'razorpay_order_id': razorpay_order['id'],
        #     'amount': amount,
        #     'currency': 'INR',
        #     'key_id': settings.RAZORPAY_KEY_ID
        # })
        
        # Placeholder response
        return JsonResponse({
            'success': False,
            'message': 'Online payment coming soon! Please use Cash on Delivery for now.',
            'coming_soon': True
        })
        
    except Exception as e:
        return JsonResponse({
            'success': False,
            'message': f'Error initiating payment: {str(e)}'
        }, status=500)


@csrf_exempt
@require_http_methods(["POST"])
def payment_callback(request):
    """
    Handle Razorpay payment callback
    Verify payment signature and update order status
    """
    try:
        data = json.loads(request.body)
        
        razorpay_order_id = data.get('razorpay_order_id')
        razorpay_payment_id = data.get('razorpay_payment_id')
        razorpay_signature = data.get('razorpay_signature')
        
        # TODO: Verify signature when Razorpay is configured
        # import razorpay
        # client = razorpay.Client(auth=(settings.RAZORPAY_KEY_ID, settings.RAZORPAY_KEY_SECRET))
        #
        # params_dict = {
        #     'razorpay_order_id': razorpay_order_id,
        #     'razorpay_payment_id': razorpay_payment_id,
        #     'razorpay_signature': razorpay_signature
        # }
        #
        # try:
        #     client.utility.verify_payment_signature(params_dict)
        #     
        #     # Payment verified successfully
        #     # Update order status in database
        #     from orders.models import Order
        #     order = Order.objects.get(order_number=razorpay_order_id.split('_')[1])
        #     order.is_paid = True
        #     order.payment_id = razorpay_payment_id
        #     order.payment_method = 'online'
        #     order.save()
        #     
        #     return JsonResponse({
        #         'success': True,
        #         'message': 'Payment verified successfully'
        #     })
        # except razorpay.errors.SignatureVerificationError:
        #     return JsonResponse({
        #         'success': False,
        #         'message': 'Payment verification failed'
        #     }, status=400)
        
        return JsonResponse({
            'success': False,
            'message': 'Payment gateway not yet configured'
        })
        
    except Exception as e:
        return JsonResponse({
            'success': False,
            'message': str(e)
        }, status=500)


@login_required
def payment_success(request):
    """Display payment success page"""
    order_id = request.GET.get('order_id')
    return render(request, 'payments/success.html', {'order_id': order_id})


@login_required  
def payment_failed(request):
    """Display payment failure page"""
    return render(request, 'payments/failed.html')


# Stripe Integration (Alternative payment gateway)
@login_required
@require_http_methods(["POST"])
def create_stripe_payment_intent(request):
    """
    Create Stripe Payment Intent for online payments
    """
    try:
        data = json.loads(request.body)
        amount = float(data.get('amount', 0))
        
        if amount <= 0:
            return JsonResponse({
                'success': False,
                'message': 'Invalid amount'
            }, status=400)
        
        # TODO: Initialize Stripe when keys are configured
        if not settings.STRIPE_SECRET_KEY:
            return JsonResponse({
                'success': False,
                'message': 'Payment gateway not configured yet',
                'coming_soon': True
            })
        
        # When Stripe is configured:
        # import stripe
        # stripe.api_key = settings.STRIPE_SECRET_KEY
        #
        # intent = stripe.PaymentIntent.create(
        #     amount=int(amount * 100),  # Amount in cents
        #     currency='inr',
        #     metadata={'order_id': data.get('order_id')}
        # )
        #
        # return JsonResponse({
        #     'success': True,
        #     'client_secret': intent.client_secret,
        #     'publishable_key': settings.STRIPE_PUBLIC_KEY
        # })
        
        return JsonResponse({
            'success': False,
            'message': 'Coming soon!',
            'coming_soon': True
        })
        
    except Exception as e:
        return JsonResponse({
            'success': False,
            'message': str(e)
        }, status=500)


# Financial Dashboard Views (Placeholders)
def financial_dashboard(request):
    """Financial dashboard - placeholder"""
    return JsonResponse({'message': 'Financial dashboard coming soon'})


def profit_loss_report(request):
    """Profit & Loss report - placeholder"""
    return JsonResponse({'message': 'Profit & Loss report coming soon'})


def balance_sheet(request):
    """Balance sheet - placeholder"""
    return JsonResponse({'message': 'Balance sheet coming soon'})


def tax_summary(request):
    """Tax summary - placeholder"""
    return JsonResponse({'message': 'Tax summary coming soon'})


def budget_tracking(request):
    """Budget tracking - placeholder"""
    return JsonResponse({'message': 'Budget tracking coming soon'})


@login_required
@require_http_methods(["POST"])
def bank_initiate_transfer(request):
    try:
        data = json.loads(request.body)
        account_number = (data.get('account_number') or '').strip()
        ifsc = (data.get('ifsc') or '').strip()
        name = (data.get('name') or '').strip()
        amount = Decimal(str(data.get('amount') or '0'))
        reference = (data.get('reference') or '').strip()
        if not account_number or not ifsc or amount <= 0:
            return JsonResponse({'success': False, 'message': 'Invalid payload'}, status=400)
        client = BankAPIClient()
        resp = client.initiate_transfer(account_number, ifsc, name, amount, reference)
        if resp.get('success') is False and 'status_code' not in resp:
            return JsonResponse({'success': False, 'message': resp.get('message')}, status=400)
        return JsonResponse({'success': True, 'data': resp})
    except Exception as e:
        return JsonResponse({'success': False, 'message': str(e)}, status=500)


@login_required
@require_http_methods(["POST"])
def bank_verify_account(request):
    try:
        data = json.loads(request.body)
        account_number = (data.get('account_number') or '').strip()
        ifsc = (data.get('ifsc') or '').strip()
        name = (data.get('name') or '').strip()
        if not account_number or not ifsc:
            return JsonResponse({'success': False, 'message': 'Invalid payload'}, status=400)
        client = BankAPIClient()
        resp = client.verify_account(account_number, ifsc, name)
        if resp.get('success') is False and 'status_code' not in resp:
            return JsonResponse({'success': False, 'message': resp.get('message')}, status=400)
        return JsonResponse({'success': True, 'data': resp})
    except Exception as e:
        return JsonResponse({'success': False, 'message': str(e)}, status=500)
