#!/usr/bin/env python
"""
Fix unprocessed M-Pesa payment
Find transaction by trans_id pattern and process it if borrower matches
"""
import os
import sys
import django
from pathlib import Path

def setup_django():
    """Setup Django environment"""
    script_dir = Path(__file__).resolve().parent
    
    manage_py = script_dir / 'manage.py'
    if not manage_py.exists():
        manage_py = script_dir.parent / 'manage.py'
    
    if manage_py.exists():
        with open(manage_py, 'r') as f:
            content = f.read()
            if 'DJANGO_SETTINGS_MODULE' in content:
                import re
                match = re.search(r"os\.environ\.setdefault\(['\"]DJANGO_SETTINGS_MODULE['\"],\s*['\"]([^'\"]+)['\"]", content)
                if match:
                    os.environ.setdefault('DJANGO_SETTINGS_MODULE', match.group(1))
    
    settings_modules = [
        'config.settings',
        'settings',
        'project.settings',
        'branchsystem.settings',
        'branch_system.settings',
    ]
    
    for settings_module in settings_modules:
        try:
            os.environ.setdefault('DJANGO_SETTINGS_MODULE', settings_module)
            django.setup()
            print(f"✓ Django setup successful with settings: {settings_module}")
            return True
        except Exception as e:
            continue
    
    print("✗ Error: Could not setup Django. Please set DJANGO_SETTINGS_MODULE")
    return False

def normalize_phone(phone):
    """Normalize phone number for comparison - handles all Kenyan formats"""
    if not phone:
        return None
    
    # Remove all non-digits and spaces
    clean = ''.join(filter(str.isdigit, str(phone)))
    
    if not clean:
        return None
    
    # Handle Kenyan phone number formats:
    # 07XXXXXXXX, 01XXXXXXXX, 2547XXXXXXXX, +2547XXXXXXXX
    if clean.startswith('254') and len(clean) >= 12:
        # Already in international format: 254...
        return '+' + clean
    elif clean.startswith('0') and len(clean) >= 9:
        # Local format: 07XXXXXXXX or 01XXXXXXXX
        # Convert 0 -> +254 (e.g., 0712345678 -> +254712345678)
        return '+254' + clean[1:]
    elif len(clean) >= 9:
        # Assume it's already in correct format if it has enough digits
        if not clean.startswith('+'):
            return '+' + clean
        return clean
    else:
        # Return as-is if format is unclear
        return phone

def find_and_process_transaction():
    """Find and process the unprocessed transaction"""
    from loans.models import MpesaTransaction
    from payments.models import MpesaCallback
    from django.contrib.auth import get_user_model
    from django.utils import timezone
    from datetime import datetime
    
    User = get_user_model()
    
    print("\n" + "="*70)
    print("FINDING UNPROCESSED M-PESA TRANSACTION")
    print("="*70)
    
    # First, check callbacks for unprocessed confirmation callbacks
    print("\nChecking M-Pesa callbacks...")
    callbacks = MpesaCallback.objects.filter(
        callback_type='confirmation',
        processed=False
    ).order_by('-created_at')[:10]
    
    transactions = []
    
    for callback in callbacks:
        print(f"\n--- Callback: {callback.id} ---")
        print(f"Created: {callback.created_at}")
        print(f"Processed: {callback.processed}")
        print(f"Has transaction: {callback.transaction is not None}")
        
        # Check if callback has transaction
        if callback.transaction:
            transaction = callback.transaction
            print(f"Transaction ID: {transaction.trans_id}")
            print(f"Transaction Status: {transaction.status}")
            print(f"Borrower: {transaction.borrower or 'Not matched'}")
            
            if not transaction.borrower:
                transactions.append(transaction)
        else:
            # Try to extract transaction data from callback
            print("⚠ Callback has no linked transaction, checking raw data...")
            raw_data = callback.raw_data
            
            # Parse JSON if raw_data is a string
            if raw_data and isinstance(raw_data, str):
                try:
                    import json
                    raw_data = json.loads(raw_data)
                except:
                    print("⚠ Could not parse raw_data as JSON")
                    continue
            
            if raw_data and isinstance(raw_data, dict):
                trans_id = raw_data.get('TransID') or raw_data.get('TransId')
                if trans_id:
                    # Try to find or create transaction
                    try:
                        transaction, created = MpesaTransaction.objects.get_or_create(
                            trans_id=trans_id,
                            defaults={
                                'transaction_type': raw_data.get('TransactionType', 'Pay Bill'),
                                'amount': float(raw_data.get('TransAmount', 0)),
                                'phone_number': raw_data.get('MSISDN', '')[:17],  # Truncate if too long
                                'msisdn': raw_data.get('MSISDN', '')[:17],
                                'trans_time': raw_data.get('TransTime'),
                                'business_short_code': raw_data.get('BusinessShortCode'),
                                'bill_ref_number': raw_data.get('BillRefNumber'),
                                'invoice_number': raw_data.get('InvoiceNumber'),
                                'org_account_balance': raw_data.get('OrgAccountBalance'),
                                'third_party_trans_id': raw_data.get('ThirdPartyTransID'),
                                'first_name': raw_data.get('FirstName'),
                                'middle_name': raw_data.get('MiddleName'),
                                'last_name': raw_data.get('LastName'),
                                'raw_confirmation_data': raw_data,
                                'status': 'confirmed'
                            }
                        )
                        callback.transaction = transaction
                        callback.save()
                        
                        if created:
                            print(f"✓ Created transaction: {transaction.trans_id}")
                        else:
                            print(f"✓ Found existing transaction: {transaction.trans_id}")
                        
                        if not transaction.borrower:
                            transactions.append(transaction)
                    except Exception as e:
                        print(f"✗ Error creating transaction: {e}")
    
    # Also search for transactions directly
    if not transactions:
        print("\nSearching for transactions with trans_id pattern 'TK5019CLK2'...")
        direct_transactions = MpesaTransaction.objects.filter(
            trans_id__icontains='TK5019CLK2'
        )
        if direct_transactions.exists():
            transactions.extend(list(direct_transactions))
        
        if not transactions:
            print("\nSearching for recent unprocessed transactions...")
            direct_transactions = MpesaTransaction.objects.filter(
                status__in=['pending', 'confirmed', 'pending_approval'],
                borrower__isnull=True
            ).order_by('-created_at')[:5]
            transactions.extend(list(direct_transactions))
    
    if not transactions:
        print("\n✗ No unprocessed transactions found")
        return
    
    print(f"\n{'='*70}")
    print(f"Found {len(transactions)} unprocessed transaction(s)")
    print(f"{'='*70}")
    
    for transaction in transactions:
        print(f"\n--- Transaction: {transaction.trans_id} ---")
        print(f"Amount: KES {transaction.amount}")
        print(f"Phone: {transaction.phone_number or transaction.msisdn}")
        print(f"Bill Ref (ID): {transaction.bill_ref_number}")
        print(f"Status: {transaction.status}")
        print(f"Borrower: {transaction.borrower or 'Not matched'}")
        
        # Normalize phone from transaction
        tx_phone = transaction.msisdn or transaction.phone_number
        tx_phone_normalized = normalize_phone(tx_phone)
        tx_id_number = transaction.bill_ref_number
        
        print(f"\nNormalized phone: {tx_phone_normalized}")
        print(f"ID number from payment: {tx_id_number}")
        
        # Try to find borrower
        borrower = None
        match_method = None
        
        # Method 1: Match by ID number AND phone
        if tx_id_number and tx_phone_normalized:
            try:
                borrower_by_id = User.objects.get(id_number=tx_id_number, role='borrower')
                borrower_phone_normalized = normalize_phone(borrower_by_id.phone_number)
                
                print(f"\nFound borrower by ID: {borrower_by_id.get_full_name()}")
                print(f"  Borrower phone: {borrower_by_id.phone_number} (normalized: {borrower_phone_normalized})")
                print(f"  Payment phone: {tx_phone} (normalized: {tx_phone_normalized})")
                
                if borrower_phone_normalized == tx_phone_normalized:
                    borrower = borrower_by_id
                    match_method = "ID number and phone number"
                    print("  ✓ Phone numbers match!")
                else:
                    print("  ⚠ Phone numbers don't match exactly")
                    # Still use this borrower if ID matches
                    borrower = borrower_by_id
                    match_method = "ID number (phone differs)"
            except User.DoesNotExist:
                print(f"\n⚠ No borrower found with ID number: {tx_id_number}")
        
        # Method 2: Match by phone only if ID didn't work
        if not borrower and tx_phone_normalized:
            # Generate all possible phone variants for Kenyan numbers
            phone_variants = set()
            phone_variants.add(tx_phone_normalized)
            
            # If normalized format is +254..., generate variants
            if tx_phone_normalized.startswith('+254') and len(tx_phone_normalized) > 4:
                phone_variants.add(tx_phone_normalized[1:])  # Remove +: 254...
                phone_variants.add('0' + tx_phone_normalized[4:])  # Local: 07... or 01...
            # If format is 254..., add variants
            elif tx_phone_normalized.startswith('254') and len(tx_phone_normalized) > 3:
                phone_variants.add('+' + tx_phone_normalized)  # Add +
                phone_variants.add('0' + tx_phone_normalized[3:])  # Local: 07... or 01...
            # If format is 07... or 01..., add variants
            elif tx_phone_normalized.startswith('0') and len(tx_phone_normalized) >= 9:
                phone_variants.add('+254' + tx_phone_normalized[1:])  # International: +2547...
                phone_variants.add('254' + tx_phone_normalized[1:])  # Without +
            
            # Also try the original phone from transaction
            if tx_phone:
                phone_variants.add(tx_phone)
                phone_variants.add(normalize_phone(tx_phone))
            
            print(f"\nTrying phone variants: {list(phone_variants)[:5]}...")  # Show first 5
            
            for variant in phone_variants:
                try:
                    borrower = User.objects.get(phone_number=variant, role='borrower')
                    match_method = f"Phone number ({variant})"
                    print(f"\n✓ Found borrower by phone: {borrower.get_full_name()}")
                    break
                except User.DoesNotExist:
                    continue
                except User.MultipleObjectsReturned:
                    borrowers = User.objects.filter(phone_number=variant, role='borrower')
                    borrower = borrowers.first()
                    match_method = f"Phone number ({variant}) - multiple found, using first"
                    print(f"\n⚠ Multiple borrowers with phone {variant}, using first: {borrower.get_full_name()}")
                    break
        
        if borrower:
            print(f"\n" + "="*70)
            print(f"MATCH FOUND!")
            print("="*70)
            print(f"Borrower: {borrower.get_full_name()}")
            print(f"Phone: {borrower.phone_number}")
            print(f"ID Number: {borrower.id_number}")
            print(f"Match Method: {match_method}")
            print(f"\nLinking transaction to borrower...")
            
            # Link transaction to borrower
            transaction.borrower = borrower
            transaction.processing_notes = f"Manually matched by {match_method}"
            transaction.save()
            
            print("✓ Transaction linked to borrower")
            
            # Process the payment
            print("\nProcessing payment...")
            try:
                success = transaction.process_payment()
                transaction.refresh_from_db()
                
                if success:
                    print("✓ Payment processed successfully!")
                    if transaction.repayment:
                        print(f"✓ Repayment created: {transaction.repayment.id}")
                    if hasattr(transaction, 'unconfirmed_payment'):
                        print(f"⚠ Note: UnconfirmedPayment record exists: {transaction.unconfirmed_payment.id}")
                else:
                    print("⚠ Payment processing returned False")
                    print(f"Processing notes: {transaction.processing_notes}")
            except Exception as e:
                print(f"✗ Error processing payment: {e}")
                import traceback
                traceback.print_exc()
            
            return  # Process only the first matching transaction
    
    print("\n⚠ No matching borrower found for any transaction")

def main():
    """Main function"""
    print("="*70)
    print("FIX UNPROCESSED M-PESA PAYMENT")
    print("="*70)
    
    if not setup_django():
        sys.exit(1)
    
    find_and_process_transaction()
    
    print("\n" + "="*70)
    print("DONE")
    print("="*70)

if __name__ == '__main__':
    main()
