"""
Simple Performance Tests for Reports System

Tests query optimization and caching functionality without requiring
large dataset creation.
"""

from django.test import TestCase
from django.contrib.auth import get_user_model
from django.utils import timezone
from datetime import timedelta
from decimal import Decimal

from loans.models import Loan, LoanApplication, LoanProduct
from users.models import CustomUser, Branch
from reports.query_optimizer import QueryOptimizer
from reports.cache_service import CacheService
from reports.filter_service import ReportFilterService

User = get_user_model()


class SimplePerformanceTestCase(TestCase):
    """Simple performance tests for query optimization and caching"""
    
    def setUp(self):
        """Set up minimal test data"""
        # Create test branch
        self.branch = Branch.objects.create(
            name='Test Branch',
            code='TB001',
            is_active=True
        )
        
        # Create test loan product
        self.loan_product = LoanProduct.objects.create(
            name='Test Product',
            interest_rate=10.0,
            processing_fee_rate=2.0,
            is_active=True
        )
        
        # Create test borrower
        self.borrower = User.objects.create_user(
            username='test_borrower',
            email='borrower@test.com',
            password='testpass123',
            role='borrower',
            first_name='Test',
            last_name='Borrower',
            phone_number='0700000001',
            branch=self.branch
        )
        
        # Create test loan application
        self.application = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('10000.00'),
            status='approved'
        )
        
        # Create test loan
        self.loan = Loan.objects.create(
            borrower=self.borrower,
            application=self.application,
            loan_number='LN000001',
            principal_amount=Decimal('10000.00'),
            interest_amount=Decimal('1000.00'),
            processing_fee=Decimal('200.00'),
            total_amount=Decimal('11200.00'),
            disbursement_date=timezone.now().date() - timedelta(days=30),
            due_date=timezone.now().date() + timedelta(days=30),
            status='active',
            is_deleted=False,
            is_rolled_over=False
        )
    
    def test_query_optimizer_loans_queryset(self):
        """Test that query optimizer properly adds select_related and prefetch_related"""
        # Get optimized queryset
        optimized_qs = QueryOptimizer.get_optimized_loans_queryset()
        
        # Check that queryset is valid
        self.assertIsNotNone(optimized_qs)
        
        # Fetch a loan and verify related data is accessible without additional queries
        loan = optimized_qs.first()
        if loan:
            # These should not trigger additional queries due to select_related
            borrower_name = loan.borrower.get_full_name()
            branch_name = loan.borrower.branch.name if loan.borrower.branch else None
            product_name = loan.application.loan_product.name if loan.application else None
            
            self.assertIsNotNone(borrower_name)
            print(f"✓ Query optimizer working: {borrower_name}, {branch_name}, {product_name}")
    
    def test_query_optimizer_clients_queryset(self):
        """Test that query optimizer properly optimizes client querysets"""
        # Get optimized queryset
        optimized_qs = QueryOptimizer.get_optimized_clients_queryset()
        
        # Check that queryset is valid
        self.assertIsNotNone(optimized_qs)
        
        # Fetch a client and verify related data is accessible
        client = optimized_qs.first()
        if client:
            branch_name = client.branch.name if client.branch else None
            loans_count = client.loans.count()
            
            self.assertIsNotNone(client)
            print(f"✓ Client query optimizer working: {client.username}, loans: {loans_count}")
    
    def test_cache_service_basic_operations(self):
        """Test basic cache service operations"""
        # Test cache key generation
        cache_key = CacheService.generate_cache_key('test_prefix', 'arg1', 'arg2', key='value')
        self.assertIsNotNone(cache_key)
        self.assertIn('test_prefix', cache_key)
        print(f"✓ Cache key generated: {cache_key}")
        
        # Test cache set and get
        test_data = {'test': 'data', 'value': 123}
        success = CacheService.set_cached_data(cache_key, test_data, timeout=60)
        self.assertTrue(success)
        
        cached_data = CacheService.get_cached_data(cache_key)
        self.assertEqual(cached_data, test_data)
        print(f"✓ Cache set and get working: {cached_data}")
        
        # Test cache invalidation
        success = CacheService.invalidate_cache(cache_key)
        self.assertTrue(success)
        
        cached_data = CacheService.get_cached_data(cache_key)
        self.assertIsNone(cached_data)
        print("✓ Cache invalidation working")
    
    def test_cache_service_client_metrics(self):
        """Test caching of client metrics"""
        # Define a simple calculator function
        call_count = [0]  # Use list to allow modification in nested function
        
        def calculate_metrics():
            call_count[0] += 1
            return {
                'total_clients': 10,
                'active_portfolio': 5,
                'avg_score': 75.5
            }
        
        # First call should execute calculator
        result1 = CacheService.get_or_set_client_metrics(
            str(self.branch.id),
            calculate_metrics,
            timeout=60
        )
        self.assertEqual(call_count[0], 1)
        self.assertEqual(result1['total_clients'], 10)
        print(f"✓ First call executed calculator: {result1}")
        
        # Second call should use cache
        result2 = CacheService.get_or_set_client_metrics(
            str(self.branch.id),
            calculate_metrics,
            timeout=60
        )
        self.assertEqual(call_count[0], 1)  # Should still be 1 (not called again)
        self.assertEqual(result2, result1)
        print("✓ Second call used cache (calculator not called)")
        
        # Invalidate and verify
        CacheService.invalidate_client_metrics(str(self.branch.id))
        
        result3 = CacheService.get_or_set_client_metrics(
            str(self.branch.id),
            calculate_metrics,
            timeout=60
        )
        self.assertEqual(call_count[0], 2)  # Should be called again
        print("✓ After invalidation, calculator called again")
    
    def test_filter_service_with_optimization(self):
        """Test that filter service works with optimized querysets"""
        # Get base queryset
        base_qs = Loan.objects.all()
        
        # Apply optimization
        optimized_qs = QueryOptimizer.get_optimized_loans_queryset(base_qs)
        
        # Apply filters
        filtered_qs = ReportFilterService.apply_loan_status_filter(
            optimized_qs,
            exclude_rolled_over=True,
            exclude_deleted=True
        )
        
        # Verify results
        count = filtered_qs.count()
        self.assertGreaterEqual(count, 0)
        print(f"✓ Filter service works with optimized queryset: {count} loans")
        
        # Apply date range filter
        filtered_qs = ReportFilterService.apply_date_range_filter(
            filtered_qs,
            start_date=timezone.now().date() - timedelta(days=60),
            end_date=timezone.now().date(),
            date_field='disbursement_date'
        )
        
        count = filtered_qs.count()
        self.assertGreaterEqual(count, 0)
        print(f"✓ Date range filter works: {count} loans")
    
    def test_optimize_for_report_type(self):
        """Test report-type-specific optimization"""
        base_qs = Loan.objects.all()
        
        # Test different report types
        report_types = ['loans_due', 'processing_fees', 'interest_income', 'delinquent']
        
        for report_type in report_types:
            optimized_qs = QueryOptimizer.optimize_for_report_type(base_qs, report_type)
            self.assertIsNotNone(optimized_qs)
            print(f"✓ Optimization for {report_type} report working")


# Run tests
if __name__ == '__main__':
    import django
    from django.core.management import call_command
    django.setup()
    call_command('test', 'reports.test_performance_simple', verbosity=2)
