"""
Unit tests for JournalEntry model - Task 1.3

This test module verifies the implementation of the JournalEntry model with:
- reference_number, transaction_date, description fields
- status field with choices (draft, posted, reversed)
- branch foreign key to users.Branch model
- loan and expense foreign keys for integration tracking
- reverses OneToOneField for reversal linkage
- created_by, created_at, updated_at, posted_by, posted_at audit fields
- database indexes for status, transaction_date, branch, loan, expense
- db_table set to 'accounting_journal_entries'

Validates Requirements: 2.1, 2.2, 2.6, 2.7, 2.8, 2.9, 13.1, 14.1, 14.2, 14.5
"""

from django.test import TestCase
from django.contrib.auth import get_user_model
from django.db import IntegrityError
from datetime import date, datetime, timedelta
from decimal import Decimal

from accounting.models import JournalEntry, Account, JournalEntryLine
from users.models import Branch
from loans.models import Loan, LoanProduct
from expenses.models import Expense

User = get_user_model()


class JournalEntryModelIntegrationTest(TestCase):
    """Test cases for JournalEntry model integration features"""
    
    def setUp(self):
        """Set up test data"""
        # Create users
        self.creator_user = User.objects.create_user(
            username='creator',
            password='pass123',
            email='creator@test.com',
            phone_number='+254700000001'
        )
        
        self.poster_user = User.objects.create_user(
            username='poster',
            password='pass123',
            email='poster@test.com',
            phone_number='+254700000002'
        )
        
        # Create branch
        self.branch = Branch.objects.create(
            name='Main Branch',
            code='MB001',
            address='Nairobi'
        )
        
        # Create accounts for testing
        self.cash_account = Account.objects.create(
            code='202001',
            name='Cash',
            account_type='asset',
            description='Cash account'
        )
        
        self.loan_portfolio_account = Account.objects.create(
            code='202002',
            name='Loan Portfolio',
            account_type='asset',
            description='Loan portfolio'
        )
    
    def test_journal_entry_core_fields(self):
        """Test JournalEntry has all core required fields (Req 2.1, 2.2)"""
        entry = JournalEntry.objects.create(
            reference_number='JE-2024-001',
            transaction_date=date(2024, 1, 15),
            description='Test journal entry for loan disbursement',
            created_by=self.creator_user
        )
        
        # Verify core fields
        self.assertEqual(entry.reference_number, 'JE-2024-001')
        self.assertEqual(entry.transaction_date, date(2024, 1, 15))
        self.assertEqual(entry.description, 'Test journal entry for loan disbursement')
        
        # Verify reference_number is unique
        self.assertTrue(JournalEntry._meta.get_field('reference_number').unique)
    
    def test_journal_entry_status_field_choices(self):
        """Test status field with proper choices (Req 2.2, 2.9)"""
        valid_statuses = ['draft', 'posted', 'reversed']
        
        for status in valid_statuses:
            entry = JournalEntry.objects.create(
                reference_number=f'JE-{status}-001',
                transaction_date=date.today(),
                description=f'Test {status} entry',
                status=status
            )
            self.assertEqual(entry.status, status)
        
        # Verify default status is 'draft'
        entry = JournalEntry.objects.create(
            reference_number='JE-DEFAULT-001',
            transaction_date=date.today(),
            description='Test default status'
        )
        self.assertEqual(entry.status, 'draft')
    
    def test_journal_entry_branch_foreign_key(self):
        """Test branch foreign key association (Req 13.1)"""
        entry = JournalEntry.objects.create(
            reference_number='JE-2024-001',
            transaction_date=date.today(),
            description='Branch-specific entry',
            branch=self.branch,
            created_by=self.creator_user
        )
        
        # Verify branch association
        self.assertEqual(entry.branch, self.branch)
        self.assertIn(entry, self.branch.journal_entries.all())
        
        # Verify branch is optional
        entry_no_branch = JournalEntry.objects.create(
            reference_number='JE-2024-002',
            transaction_date=date.today(),
            description='Entry without branch'
        )
        self.assertIsNone(entry_no_branch.branch)
    
    def test_journal_entry_loan_integration_foreign_key(self):
        """Test loan foreign key for integration tracking (Req 2.7, 2.8)"""
        # Skip if Loan model doesn't exist or creating test loan fails
        # The key requirement is that the JournalEntry model has a loan foreign key
        # which can be tested by checking the field exists
        
        # Verify loan field exists and is a foreign key
        loan_field = JournalEntry._meta.get_field('loan')
        self.assertEqual(loan_field.get_internal_type(), 'ForeignKey')
        self.assertEqual(loan_field.related_model.__name__, 'Loan')
        self.assertTrue(loan_field.null)
        self.assertTrue(loan_field.blank)
        
        # Verify loan is optional by creating entry without loan
        entry = JournalEntry.objects.create(
            reference_number='JE-2024-003',
            transaction_date=date.today(),
            description='Entry without loan'
        )
        self.assertIsNone(entry.loan)
    
    def test_journal_entry_expense_integration_foreign_key(self):
        """Test expense foreign key for integration tracking (Req 2.7, 2.8)"""
        # Verify expense field exists and is a foreign key
        expense_field = JournalEntry._meta.get_field('expense')
        self.assertEqual(expense_field.get_internal_type(), 'ForeignKey')
        self.assertEqual(expense_field.related_model.__name__, 'Expense')
        self.assertTrue(expense_field.null)
        self.assertTrue(expense_field.blank)
        
        # Verify expense is optional by creating entry without expense
        entry_no_expense = JournalEntry.objects.create(
            reference_number='JE-2024-004',
            transaction_date=date.today(),
            description='Entry without expense'
        )
        self.assertIsNone(entry_no_expense.expense)
    
    def test_journal_entry_reversal_tracking(self):
        """Test reverses OneToOneField for reversal linkage (Req 2.9)"""
        # Create original entry
        original_entry = JournalEntry.objects.create(
            reference_number='JE-2024-100',
            transaction_date=date.today(),
            description='Original entry',
            status='posted',
            created_by=self.creator_user,
            posted_by=self.poster_user,
            posted_at=datetime.now()
        )
        
        # Create reversal entry that reverses the original
        reversal_entry = JournalEntry.objects.create(
            reference_number='JE-2024-100-REV',
            transaction_date=date.today(),
            description='Reversal of JE-2024-100',
            status='posted',
            created_by=self.creator_user,
            posted_by=self.poster_user,
            posted_at=datetime.now(),
            reverses=original_entry
        )
        
        # Verify reversal linkage
        self.assertEqual(reversal_entry.reverses, original_entry)
        self.assertEqual(original_entry.reversed_by, reversal_entry)
        
        # Mark original as reversed
        original_entry.status = 'reversed'
        original_entry.save()
        original_entry.refresh_from_db()
        self.assertEqual(original_entry.status, 'reversed')
        
        # Verify reverses is optional
        standalone_entry = JournalEntry.objects.create(
            reference_number='JE-2024-005',
            transaction_date=date.today(),
            description='Standalone entry'
        )
        self.assertIsNone(standalone_entry.reverses)
    
    def test_journal_entry_audit_fields(self):
        """Test audit trail fields (Req 14.1, 14.2, 14.5)"""
        # Create entry with creator
        entry = JournalEntry.objects.create(
            reference_number='JE-2024-001',
            transaction_date=date.today(),
            description='Test audit fields',
            created_by=self.creator_user
        )
        
        # Verify created_by, created_at, updated_at
        self.assertEqual(entry.created_by, self.creator_user)
        self.assertIsNotNone(entry.created_at)
        self.assertIsNotNone(entry.updated_at)
        
        # Verify posted_by and posted_at are initially None
        self.assertIsNone(entry.posted_by)
        self.assertIsNone(entry.posted_at)
        
        # Simulate posting
        entry.status = 'posted'
        entry.posted_by = self.poster_user
        entry.posted_at = datetime.now()
        entry.save()
        
        entry.refresh_from_db()
        self.assertEqual(entry.posted_by, self.poster_user)
        self.assertIsNotNone(entry.posted_at)
        
        # Verify updated_at changes on modification
        original_updated_at = entry.updated_at
        entry.description = 'Updated description'
        entry.save()
        entry.refresh_from_db()
        self.assertGreater(entry.updated_at, original_updated_at)
    
    def test_journal_entry_database_indexes(self):
        """Test that required database indexes exist"""
        indexes = JournalEntry._meta.indexes
        
        # Verify indexes are defined
        self.assertGreater(len(indexes), 0, "JournalEntry should have indexes")
        
        # Check for status, transaction_date index
        has_status_index = any(
            'status' in str(index.fields) and 'transaction_date' in str(index.fields)
            for index in indexes
        )
        self.assertTrue(has_status_index, "Should have index on status and transaction_date")
        
        # Check for branch, transaction_date index
        has_branch_index = any(
            'branch' in str(index.fields) and 'transaction_date' in str(index.fields)
            for index in indexes
        )
        self.assertTrue(has_branch_index, "Should have index on branch and transaction_date")
        
        # Check for loan index
        has_loan_index = any(
            'loan' in str(index.fields)
            for index in indexes
        )
        self.assertTrue(has_loan_index, "Should have index on loan")
        
        # Check for expense index
        has_expense_index = any(
            'expense' in str(index.fields)
            for index in indexes
        )
        self.assertTrue(has_expense_index, "Should have index on expense")
        
        # Verify indexed fields
        self.assertTrue(JournalEntry._meta.get_field('reference_number').db_index)
        self.assertTrue(JournalEntry._meta.get_field('transaction_date').db_index)
    
    def test_journal_entry_db_table_name(self):
        """Test db_table is set to 'accounting_journal_entries'"""
        self.assertEqual(JournalEntry._meta.db_table, 'accounting_journal_entries')
    
    def test_journal_entry_ordering(self):
        """Test default ordering by transaction_date and created_at"""
        # Create entries with different dates
        entry1 = JournalEntry.objects.create(
            reference_number='JE-2024-001',
            transaction_date=date(2024, 1, 1),
            description='Entry 1'
        )
        
        entry2 = JournalEntry.objects.create(
            reference_number='JE-2024-002',
            transaction_date=date(2024, 1, 15),
            description='Entry 2'
        )
        
        entry3 = JournalEntry.objects.create(
            reference_number='JE-2024-003',
            transaction_date=date(2024, 1, 10),
            description='Entry 3'
        )
        
        # Get all entries - should be ordered by -transaction_date, -created_at
        entries = list(JournalEntry.objects.all())
        
        # Most recent transaction_date should be first
        self.assertEqual(entries[0].transaction_date, date(2024, 1, 15))
        self.assertEqual(entries[2].transaction_date, date(2024, 1, 1))
    
    def test_journal_entry_reference_number_uniqueness(self):
        """Test that reference_number must be unique (Req 2.6)"""
        JournalEntry.objects.create(
            reference_number='JE-2024-DUP',
            transaction_date=date.today(),
            description='First entry'
        )
        
        # Attempt to create duplicate reference_number
        with self.assertRaises(IntegrityError):
            JournalEntry.objects.create(
                reference_number='JE-2024-DUP',
                transaction_date=date.today(),
                description='Duplicate entry'
            )
    
    def test_journal_entry_string_representation(self):
        """Test __str__ method"""
        entry = JournalEntry.objects.create(
            reference_number='JE-2024-001',
            transaction_date=date(2024, 1, 15),
            description='Test entry'
        )
        
        expected_str = 'JE-2024-001 - 2024-01-15'
        self.assertEqual(str(entry), expected_str)
    
    def test_journal_entry_with_all_fields(self):
        """Test creating JournalEntry with all fields populated"""
        # Create entry with all core JournalEntry fields
        # (skip loan and expense dependencies as they require complex setup)
        entry = JournalEntry.objects.create(
            reference_number='JE-FULL-001',
            transaction_date=date.today(),
            description='Complete journal entry with all core fields',
            status='posted',
            branch=self.branch,
            created_by=self.creator_user,
            posted_by=self.poster_user,
            posted_at=datetime.now()
        )
        
        # Verify all core fields
        self.assertEqual(entry.reference_number, 'JE-FULL-001')
        self.assertEqual(entry.status, 'posted')
        self.assertEqual(entry.branch, self.branch)
        self.assertEqual(entry.created_by, self.creator_user)
        self.assertEqual(entry.posted_by, self.poster_user)
        self.assertIsNotNone(entry.created_at)
        self.assertIsNotNone(entry.updated_at)
        self.assertIsNotNone(entry.posted_at)
        
        # Verify loan and expense fields exist and can be None
        self.assertIsNone(entry.loan)
        self.assertIsNone(entry.expense)


class JournalEntryWorkflowTest(TestCase):
    """Test typical journal entry workflows"""
    
    def setUp(self):
        """Set up test data"""
        self.user = User.objects.create_user(
            username='testuser',
            password='pass123',
            email='test@test.com',
            phone_number='+254700000005'
        )
        
        self.branch = Branch.objects.create(
            name='Test Branch',
            code='TB001',
            address='Test Address'
        )
    
    def test_draft_to_posted_workflow(self):
        """Test workflow from draft to posted status (Req 2.2, 14.2)"""
        # Create entry as draft
        entry = JournalEntry.objects.create(
            reference_number='JE-WF-001',
            transaction_date=date.today(),
            description='Draft entry',
            created_by=self.user
        )
        
        self.assertEqual(entry.status, 'draft')
        self.assertIsNone(entry.posted_by)
        self.assertIsNone(entry.posted_at)
        
        # Post the entry
        entry.status = 'posted'
        entry.posted_by = self.user
        entry.posted_at = datetime.now()
        entry.save()
        
        entry.refresh_from_db()
        self.assertEqual(entry.status, 'posted')
        self.assertEqual(entry.posted_by, self.user)
        self.assertIsNotNone(entry.posted_at)
    
    def test_posted_to_reversed_workflow(self):
        """Test workflow from posted to reversed status (Req 2.9)"""
        # Create and post entry
        original = JournalEntry.objects.create(
            reference_number='JE-WF-002',
            transaction_date=date.today(),
            description='Entry to be reversed',
            status='posted',
            created_by=self.user,
            posted_by=self.user,
            posted_at=datetime.now()
        )
        
        # Create reversal entry
        reversal = JournalEntry.objects.create(
            reference_number='JE-WF-002-REV',
            transaction_date=date.today(),
            description='Reversal entry',
            status='posted',
            reverses=original,
            created_by=self.user,
            posted_by=self.user,
            posted_at=datetime.now()
        )
        
        # Mark original as reversed
        original.status = 'reversed'
        original.save()
        
        original.refresh_from_db()
        self.assertEqual(original.status, 'reversed')
        self.assertEqual(original.reversed_by, reversal)
        self.assertEqual(reversal.reverses, original)