"""
Unit tests for overdue loan status functionality.

Feature: comprehensive-reports-and-fixes
Task: 7.4 Write unit tests for overdue status
"""

from django.test import TestCase, Client
from django.utils import timezone
from datetime import timedelta, date, datetime
from decimal import Decimal
from loans.models import Loan, LoanProduct, LoanApplication
from users.models import CustomUser, Branch
from django.contrib.auth.hashers import make_password
import uuid


class OverdueStatusUnitTests(TestCase):
    """Unit tests for overdue loan status filtering and display"""
    
    def setUp(self):
        """Set up test data"""
        # Create a test branch
        self.branch = Branch.objects.create(
            name="Test Branch",
            code=f"TB{uuid.uuid4().hex[:6]}",
            address="Test Address"
        )
        
        # Create a test user (borrower)
        self.borrower = CustomUser.objects.create(
            username=f"testuser_{uuid.uuid4().hex[:8]}",
            email=f"test_{uuid.uuid4().hex[:8]}@example.com",
            first_name="Test",
            last_name="User",
            phone_number=f"+2547{uuid.uuid4().hex[:8]}",
            role="borrower",
            branch=self.branch,
            password=make_password("testpass123")
        )
        
        # Create an admin user for testing
        self.admin_user = CustomUser.objects.create(
            username=f"admin_{uuid.uuid4().hex[:8]}",
            email=f"admin_{uuid.uuid4().hex[:8]}@example.com",
            first_name="Admin",
            last_name="User",
            phone_number=f"+2547{uuid.uuid4().hex[:8]}",
            role="admin",
            branch=self.branch,
            password=make_password("adminpass123"),
            is_staff=True,
            is_superuser=True
        )
        
        # Create a test loan product
        self.loan_product = LoanProduct.objects.create(
            name=f"Test Product {uuid.uuid4().hex[:6]}",
            product_type="boost",
            description="Test loan product",
            min_amount=Decimal('1000.00'),
            max_amount=Decimal('100000.00'),
            interest_rate=Decimal('10.00'),
            processing_fee=Decimal('5.00'),
            min_duration=7,
            max_duration=90,
            duration_months=1,
            available_repayment_methods=['monthly']
        )
        
        # Create test client
        self.client = Client()
    
    def test_overdue_filter_with_various_loan_states(self):
        """
        Test that overdue filter returns correct loans with various states
        
        Validates: Requirements 8.5
        """
        current_date = timezone.now().date()
        
        # Create an overdue active loan
        overdue_app = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('10000.00'),
            requested_duration=30,
            status='approved'
        )
        overdue_loan = Loan.objects.create(
            application=overdue_app,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('10000.00'),
            interest_amount=Decimal('1000.00'),
            processing_fee=Decimal('500.00'),
            total_amount=Decimal('11500.00'),
            disbursement_date=current_date - timedelta(days=40),
            due_date=current_date - timedelta(days=10),
            duration_days=30,
            status='active'
        )
        
        # Create a paid loan (should not be overdue)
        paid_app = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('5000.00'),
            requested_duration=30,
            status='approved'
        )
        paid_loan = Loan.objects.create(
            application=paid_app,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('5000.00'),
            interest_amount=Decimal('500.00'),
            processing_fee=Decimal('250.00'),
            total_amount=Decimal('5750.00'),
            disbursement_date=current_date - timedelta(days=40),
            due_date=current_date - timedelta(days=10),
            duration_days=30,
            status='paid'
        )
        
        # Create an active loan not yet due (should not be overdue)
        active_app = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('8000.00'),
            requested_duration=30,
            status='approved'
        )
        active_loan = Loan.objects.create(
            application=active_app,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('8000.00'),
            interest_amount=Decimal('800.00'),
            processing_fee=Decimal('400.00'),
            total_amount=Decimal('9200.00'),
            disbursement_date=current_date,
            due_date=current_date + timedelta(days=30),
            duration_days=30,
            status='active'
        )
        
        # Test the overdue filter
        overdue_loans = Loan.objects.filter(
            status='active',
            due_date__lt=current_date
        )
        
        # Verify only the overdue active loan is returned
        self.assertIn(overdue_loan, overdue_loans)
        self.assertNotIn(paid_loan, overdue_loans)
        self.assertNotIn(active_loan, overdue_loans)
        self.assertEqual(overdue_loans.count(), 1)
    
    def test_days_overdue_calculation(self):
        """
        Test that days overdue is calculated correctly
        
        Validates: Requirements 8.5
        """
        current_date = timezone.now().date()
        days_past = 15
        
        # Create an overdue loan
        application = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('10000.00'),
            requested_duration=30,
            status='approved'
        )
        loan = Loan.objects.create(
            application=application,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('10000.00'),
            interest_amount=Decimal('1000.00'),
            processing_fee=Decimal('500.00'),
            total_amount=Decimal('11500.00'),
            disbursement_date=current_date - timedelta(days=45),
            due_date=current_date - timedelta(days=days_past),
            duration_days=30,
            status='active'
        )
        
        # Calculate days overdue
        calculated_days = loan.get_simple_days_overdue()
        
        # Verify the calculation
        self.assertEqual(calculated_days, days_past)
    
    def test_overdue_visual_indicators_display(self):
        """
        Test that overdue loans display visual indicators in templates
        
        Validates: Requirements 8.5
        """
        current_date = timezone.now().date()
        
        # Create an overdue loan
        application = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('10000.00'),
            requested_duration=30,
            status='approved'
        )
        loan = Loan.objects.create(
            application=application,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('10000.00'),
            interest_amount=Decimal('1000.00'),
            processing_fee=Decimal('500.00'),
            total_amount=Decimal('11500.00'),
            disbursement_date=datetime.combine(current_date - timedelta(days=40), datetime.min.time()),
            due_date=datetime.combine(current_date - timedelta(days=10), datetime.min.time()),
            duration_days=30,
            status='active'
        )
        
        # Verify the loan is marked as overdue
        self.assertTrue(loan.is_overdue)
        self.assertGreater(loan.days_overdue, 0)
    
    def test_overdue_loans_in_collection_reports(self):
        """
        Test that overdue loans appear in collection reports
        
        Validates: Requirements 8.5
        """
        current_date = timezone.now().date()
        
        # Create multiple overdue loans
        for i in range(3):
            application = LoanApplication.objects.create(
                borrower=self.borrower,
                loan_product=self.loan_product,
                requested_amount=Decimal('10000.00'),
                requested_duration=30,
                status='approved'
            )
            Loan.objects.create(
                application=application,
                loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
                borrower=self.borrower,
                principal_amount=Decimal('10000.00'),
                interest_amount=Decimal('1000.00'),
                processing_fee=Decimal('500.00'),
                total_amount=Decimal('11500.00'),
                disbursement_date=current_date - timedelta(days=40),
                due_date=current_date - timedelta(days=10 + i),
                duration_days=30,
                status='active'
            )
        
        # Query overdue loans (as would be done in collection reports)
        overdue_loans = Loan.objects.filter(
            status='active',
            due_date__lt=current_date
        )
        
        # Verify all 3 overdue loans are returned
        self.assertEqual(overdue_loans.count(), 3)
        
        # Verify they all have days_overdue > 0
        for loan in overdue_loans:
            self.assertGreater(loan.get_simple_days_overdue(), 0)
    
    def test_overdue_filter_option_in_status_dropdown(self):
        """
        Test that 'Overdue' option appears in status dropdown
        
        Validates: Requirements 5.1, 5.2
        """
        # This is a template test - we verify the filter works in the view
        # The actual dropdown is tested via integration tests
        
        # Test that the overdue filter parameter works
        overdue_loans = Loan.objects.filter(
            status='active',
            due_date__lt=timezone.now().date()
        )
        
        # This should not raise an error
        self.assertIsNotNone(overdue_loans)
    
    def test_zero_days_overdue_for_future_due_date(self):
        """
        Test that loans with future due dates have 0 days overdue
        
        Validates: Requirements 5.5
        """
        current_date = timezone.now().date()
        
        # Create a loan with future due date
        application = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('10000.00'),
            requested_duration=30,
            status='approved'
        )
        loan = Loan.objects.create(
            application=application,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('10000.00'),
            interest_amount=Decimal('1000.00'),
            processing_fee=Decimal('500.00'),
            total_amount=Decimal('11500.00'),
            disbursement_date=datetime.combine(current_date, datetime.min.time()),
            due_date=datetime.combine(current_date + timedelta(days=30), datetime.min.time()),
            duration_days=30,
            status='active'
        )
        
        # Verify days overdue is 0
        self.assertEqual(loan.get_simple_days_overdue(), 0)
        self.assertFalse(loan.is_overdue)
    
    def test_zero_days_overdue_for_paid_loans(self):
        """
        Test that paid loans have 0 days overdue even if past due date
        
        Validates: Requirements 5.3
        """
        current_date = timezone.now().date()
        
        # Create a paid loan with past due date
        application = LoanApplication.objects.create(
            borrower=self.borrower,
            loan_product=self.loan_product,
            requested_amount=Decimal('10000.00'),
            requested_duration=30,
            status='approved'
        )
        loan = Loan.objects.create(
            application=application,
            loan_number=f"LOAN-{uuid.uuid4().hex[:8]}",
            borrower=self.borrower,
            principal_amount=Decimal('10000.00'),
            interest_amount=Decimal('1000.00'),
            processing_fee=Decimal('500.00'),
            total_amount=Decimal('11500.00'),
            disbursement_date=current_date - timedelta(days=40),
            due_date=current_date - timedelta(days=10),
            duration_days=30,
            status='paid'
        )
        
        # Verify days overdue is 0 for paid loan
        self.assertEqual(loan.get_simple_days_overdue(), 0)