"""
Property-Based Tests for Report Export Functionality

This module contains property-based tests for the report export service,
validating universal correctness properties across all inputs.

Feature: comprehensive-reports-and-fixes
"""

from hypothesis import given, strategies as st, settings, assume
from hypothesis.extra.django import TestCase
from decimal import Decimal
from datetime import date, datetime, timedelta
from django.test import RequestFactory
from django.contrib.auth import get_user_model
from django.http import HttpResponse
from io import BytesIO
import openpyxl
from PyPDF2 import PdfReader

from reports.export_service import ReportExportService
from loans.models import Loan, LoanProduct, LoanApplication
from users.models import Branch

User = get_user_model()


class ExportPropertyTests(TestCase):
    """
    Property-based tests for export functionality.
    
    These tests verify universal properties that should hold for all valid inputs.
    """
    
    def setUp(self):
        """Set up test data"""
        self.export_service = ReportExportService()
        self.factory = RequestFactory()
        
        # Create or get test branch
        self.branch, _ = Branch.objects.get_or_create(
            code='TB001',
            defaults={
                'name': 'Test Branch',
                'is_main_branch': False
            }
        )
        
        # Create test user
        self.user, _ = User.objects.get_or_create(
            username='testuser_export',
            defaults={
                'email': 'test@example.com',
                'first_name': 'Test',
                'last_name': 'User',
                'phone_number': '0700000000',
                'branch': self.branch
            }
        )
        
        # Create test loan product
        self.loan_product, _ = LoanProduct.objects.get_or_create(
            name='Test Product',
            defaults={
                'product_type': 'boost',
                'description': 'Test product for testing',
                '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': ['daily', 'weekly', 'monthly']
            }
        )
    
    @given(
        num_loans=st.integers(min_value=1, max_value=50),
        principal=st.decimals(min_value=1000, max_value=100000, places=2),
    )
    @settings(max_examples=50, deadline=None)
    def test_property_4_export_completeness(self, num_loans, principal):
        """
        Feature: comprehensive-reports-and-fixes, Property 4: Export Completeness
        
        For any filtered report data set, when exported to PDF or Excel, 
        the export should contain all records from the filtered set without 
        truncation or omission.
        
        Validates: Requirements 1.9, 1.10, 1.12, 7.10, 7.11
        """
        # Create test loans
        loans_data = []
        for i in range(num_loans):
            loan_data = {
                'loan_number': f'LN{i:04d}',
                'borrower_name': f'Borrower {i}',
                'phone_number': f'07000000{i:02d}',
                'disbursement_date': date.today() - timedelta(days=i),
                'principal_amount': principal,
                'interest_amount': principal * Decimal('0.10'),
                'processing_fee': principal * Decimal('0.05'),
                'total_amount': principal * Decimal('1.15'),
                'amount_paid': Decimal('0.00'),
                'outstanding_amount': principal * Decimal('1.15'),
            }
            loans_data.append(loan_data)
        
        report_data = {'loans': loans_data}
        filters = {'period': 'total'}
        
        # Test Excel export completeness
        excel_response = self.export_service.export_to_excel(
            report_data, 'disbursed_loans', filters
        )
        
        # Verify response is valid
        self.assertIsInstance(excel_response, HttpResponse)
        self.assertEqual(
            excel_response['Content-Type'],
            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
        )
        
        # Parse Excel content
        excel_content = BytesIO(excel_response.content)
        workbook = openpyxl.load_workbook(excel_content)
        sheet = workbook.active
        
        # Count data rows (excluding headers and metadata)
        data_rows = 0
        for row in sheet.iter_rows(min_row=1):
            # Look for loan numbers in the row
            for cell in row:
                if cell.value and isinstance(cell.value, str) and cell.value.startswith('LN'):
                    data_rows += 1
                    break
        
        # Property: All loans should be in the export
        self.assertEqual(
            data_rows, num_loans,
            f"Excel export should contain all {num_loans} loans, found {data_rows}"
        )
        
        # Test PDF export completeness
        pdf_response = self.export_service.export_to_pdf(
            report_data, 'disbursed_loans', filters
        )
        
        # Verify response is valid
        self.assertIsInstance(pdf_response, HttpResponse)
        self.assertEqual(pdf_response['Content-Type'], 'application/pdf')
        
        # Parse PDF content
        pdf_content = BytesIO(pdf_response.content)
        pdf_reader = PdfReader(pdf_content)
        
        # Extract text from all pages
        pdf_text = ''
        for page in pdf_reader.pages:
            pdf_text += page.extract_text()
        
        # Property: All loan numbers should appear in PDF
        for loan in loans_data:
            self.assertIn(
                loan['loan_number'], pdf_text,
                f"Loan {loan['loan_number']} should appear in PDF export"
            )
    
    @given(
        currency_amount=st.decimals(min_value=0, max_value=1000000, places=2),
    )
    @settings(max_examples=50, deadline=None)
    def test_property_22_pdf_formatting_standards(self, currency_amount):
        """
        Feature: comprehensive-reports-and-fixes, Property 22: PDF Formatting Standards
        
        For any PDF export, the document should include headers, footers, page numbers,
        consistent styling, properly formatted currency (thousand separators, 2 decimal places),
        and consistently formatted dates.
        
        Validates: Requirements 7.1, 7.2, 7.4, 7.5, 7.6, 7.7, 7.8
        """
        # Create test loan data with the given amount
        loan_data = {
            'loan_number': 'LN0001',
            'borrower_name': 'Test Borrower',
            'phone_number': '0700000000',
            'disbursement_date': date.today(),
            'principal_amount': currency_amount,
            'interest_amount': currency_amount * Decimal('0.10'),
            'processing_fee': currency_amount * Decimal('0.05'),
            'total_amount': currency_amount * Decimal('1.15'),
            'amount_paid': Decimal('0.00'),
            'outstanding_amount': currency_amount * Decimal('1.15'),
        }
        
        report_data = {'loans': [loan_data]}
        filters = {'period': 'today', 'start_date': date.today(), 'end_date': date.today()}
        
        # Generate PDF
        pdf_response = self.export_service.export_to_pdf(
            report_data, 'disbursed_loans', filters
        )
        
        # Verify response is valid
        self.assertIsInstance(pdf_response, HttpResponse)
        self.assertEqual(pdf_response['Content-Type'], 'application/pdf')
        
        # Parse PDF content
        pdf_content = BytesIO(pdf_response.content)
        pdf_reader = PdfReader(pdf_content)
        
        # Extract text from all pages
        pdf_text = ''
        for page in pdf_reader.pages:
            pdf_text += page.extract_text()
        
        # Property: Currency should be formatted with "KES" prefix and 2 decimal places
        formatted_currency = self.export_service.format_currency(currency_amount)
        self.assertIn('KES', formatted_currency)
        self.assertRegex(formatted_currency, r'KES\s+[\d,]+\.\d{2}')
        
        # Property: Date should be formatted consistently
        formatted_date = self.export_service.format_date(date.today())
        self.assertRegex(formatted_date, r'\d{4}-\d{2}-\d{2}')
        
        # Property: Report title should be present
        self.assertIn('Disbursed Loans Report', pdf_text)
        
        # Property: Generation date should be present
        self.assertIn('Generated', pdf_text)
        
        # Property: Filter metadata should be present
        self.assertIn('Applied Filters', pdf_text)
    
    @given(
        num_loans=st.integers(min_value=1, max_value=30),
    )
    @settings(max_examples=50, deadline=None)
    def test_property_23_excel_completeness(self, num_loans):
        """
        Feature: comprehensive-reports-and-fixes, Property 23: Excel Completeness
        
        For any report exported to Excel, the spreadsheet should include all visible
        columns from the web view with the same filters and sorting applied.
        
        Validates: Requirements 7.3, 7.10, 7.11
        """
        # Create test loans
        loans_data = []
        expected_columns = [
            'loan_number', 'borrower_name', 'phone_number', 'disbursement_date',
            'principal_amount', 'interest_amount', 'processing_fee', 'total_amount',
            'amount_paid', 'outstanding_amount'
        ]
        
        for i in range(num_loans):
            loan_data = {
                'loan_number': f'LN{i:04d}',
                'borrower_name': f'Borrower {i}',
                'phone_number': f'07000000{i:02d}',
                'disbursement_date': date.today() - timedelta(days=i),
                'principal_amount': Decimal('10000.00'),
                'interest_amount': Decimal('1000.00'),
                'processing_fee': Decimal('500.00'),
                'total_amount': Decimal('11500.00'),
                'amount_paid': Decimal('0.00'),
                'outstanding_amount': Decimal('11500.00'),
            }
            loans_data.append(loan_data)
        
        report_data = {'loans': loans_data}
        filters = {'period': 'total'}
        
        # Generate Excel export
        excel_response = self.export_service.export_to_excel(
            report_data, 'disbursed_loans', filters
        )
        
        # Parse Excel content
        excel_content = BytesIO(excel_response.content)
        workbook = openpyxl.load_workbook(excel_content)
        sheet = workbook.active
        
        # Find header row (look for "Loan Number" or similar)
        header_row_idx = None
        for idx, row in enumerate(sheet.iter_rows(min_row=1, max_row=20), start=1):
            for cell in row:
                if cell.value and 'Loan Number' in str(cell.value):
                    header_row_idx = idx
                    break
            if header_row_idx:
                break
        
        # Property: Header row should exist
        self.assertIsNotNone(header_row_idx, "Excel should have a header row")
        
        # Property: All data rows should be present
        data_row_count = 0
        if header_row_idx:
            for row in sheet.iter_rows(min_row=header_row_idx + 1):
                # Check if row has loan number
                if row[0].value and str(row[0].value).startswith('LN'):
                    data_row_count += 1
        
        self.assertEqual(
            data_row_count, num_loans,
            f"Excel should contain all {num_loans} data rows"
        )
    
    @given(
        report_type=st.sampled_from(['disbursed_loans', 'loans_due', 'processing_fees']),
        num_loans=st.integers(min_value=1, max_value=20),
    )
    @settings(max_examples=50, deadline=None)
    def test_property_24_report_standards_consistency(self, report_type, num_loans):
        """
        Feature: comprehensive-reports-and-fixes, Property 24: Report Standards Consistency
        
        For any page with sorting, filtering, or report generation functionality,
        the same report generation standards (formatting, completeness, metadata)
        should be applied.
        
        Validates: Requirements 7.12
        """
        # Create test loans
        loans_data = []
        for i in range(num_loans):
            loan_data = {
                'loan_number': f'LN{i:04d}',
                'borrower_name': f'Borrower {i}',
                'phone_number': f'07000000{i:02d}',
                'disbursement_date': date.today() - timedelta(days=i),
                'principal_amount': Decimal('10000.00'),
                'interest_amount': Decimal('1000.00'),
                'processing_fee': Decimal('500.00'),
                'total_amount': Decimal('11500.00'),
                'amount_paid': Decimal('0.00'),
                'outstanding_amount': Decimal('11500.00'),
                'due_date': date.today() + timedelta(days=30),
            }
            loans_data.append(loan_data)
        
        report_data = {'loans': loans_data}
        filters = {'period': 'total'}
        
        # Generate PDF for this report type
        pdf_response = self.export_service.export_to_pdf(
            report_data, report_type, filters
        )
        
        # Property: All report types should return valid PDF responses
        self.assertIsInstance(pdf_response, HttpResponse)
        self.assertEqual(pdf_response['Content-Type'], 'application/pdf')
        
        # Parse PDF
        pdf_content = BytesIO(pdf_response.content)
        pdf_reader = PdfReader(pdf_content)
        pdf_text = ''
        for page in pdf_reader.pages:
            pdf_text += page.extract_text()
        
        # Property: All reports should have consistent metadata
        self.assertIn('Generated', pdf_text, "All reports should show generation date")
        self.assertIn('Report', pdf_text, "All reports should have 'Report' in title")
        
        # Generate Excel for this report type
        excel_response = self.export_service.export_to_excel(
            report_data, report_type, filters
        )
        
        # Property: All report types should return valid Excel responses
        self.assertIsInstance(excel_response, HttpResponse)
        self.assertEqual(
            excel_response['Content-Type'],
            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
        )
        
        # Property: All Excel exports should have proper filename
        self.assertIn('attachment', excel_response['Content-Disposition'])
        self.assertIn('.xlsx', excel_response['Content-Disposition'])
    
    @given(
        num_loans=st.integers(min_value=1, max_value=20),
    )
    @settings(max_examples=50, deadline=None)
    def test_property_35_excel_export_round_trip(self, num_loans):
        """
        Feature: comprehensive-reports-and-fixes, Property 35: Excel Export Round-Trip
        
        For any valid report data object, serializing to Excel then parsing the Excel
        should produce equivalent data with the same values.
        
        Validates: Requirements 10.6
        """
        # Create test loans with specific values
        loans_data = []
        for i in range(num_loans):
            loan_data = {
                'loan_number': f'LN{i:04d}',
                'borrower_name': f'Borrower {i}',
                'phone_number': f'07000000{i:02d}',
                'disbursement_date': date.today() - timedelta(days=i),
                'principal_amount': Decimal('10000.00') + Decimal(i),
                'interest_amount': Decimal('1000.00'),
                'processing_fee': Decimal('500.00'),
                'total_amount': Decimal('11500.00') + Decimal(i),
                'amount_paid': Decimal('0.00'),
                'outstanding_amount': Decimal('11500.00') + Decimal(i),
            }
            loans_data.append(loan_data)
        
        report_data = {'loans': loans_data}
        filters = {'period': 'total'}
        
        # Generate Excel export
        excel_response = self.export_service.export_to_excel(
            report_data, 'disbursed_loans', filters
        )
        
        # Parse Excel content
        excel_content = BytesIO(excel_response.content)
        workbook = openpyxl.load_workbook(excel_content)
        sheet = workbook.active
        
        # Find header row and extract data
        header_row_idx = None
        for idx, row in enumerate(sheet.iter_rows(min_row=1, max_row=20), start=1):
            for cell in row:
                if cell.value and 'Loan Number' in str(cell.value):
                    header_row_idx = idx
                    break
            if header_row_idx:
                break
        
        # Extract loan numbers from Excel
        excel_loan_numbers = []
        if header_row_idx:
            for row in sheet.iter_rows(min_row=header_row_idx + 1):
                loan_number = row[0].value
                if loan_number and str(loan_number).startswith('LN'):
                    excel_loan_numbers.append(str(loan_number))
        
        # Property: All original loan numbers should be in Excel
        original_loan_numbers = [loan['loan_number'] for loan in loans_data]
        for loan_number in original_loan_numbers:
            self.assertIn(
                loan_number, excel_loan_numbers,
                f"Loan number {loan_number} should be in Excel export"
            )
        
        # Property: Excel should have same number of loans as original
        self.assertEqual(
            len(excel_loan_numbers), num_loans,
            "Excel should contain same number of loans as original data"
        )


class ExportFormattingPropertyTests(TestCase):
    """Property tests for export formatting functions"""
    
    def setUp(self):
        """Set up test service"""
        self.export_service = ReportExportService()
    
    @given(
        amount=st.decimals(min_value=0, max_value=10000000, places=2),
    )
    @settings(max_examples=50, deadline=None)
    def test_currency_formatting_always_has_two_decimals(self, amount):
        """
        Currency formatting should always produce exactly 2 decimal places.
        
        Validates: Requirements 7.6, 9.5
        """
        formatted = self.export_service.format_currency(amount)
        
        # Property: Should have "KES" prefix
        self.assertIn('KES', formatted)
        
        # Property: Should have exactly 2 decimal places
        self.assertRegex(formatted, r'KES\s+[\d,]+\.\d{2}$')
    
    @given(
        test_date=st.dates(min_value=date(2020, 1, 1), max_value=date(2030, 12, 31)),
    )
    @settings(max_examples=50, deadline=None)
    def test_date_formatting_consistency(self, test_date):
        """
        Date formatting should be consistent across all dates.
        
        Validates: Requirements 7.7
        """
        formatted = self.export_service.format_date(test_date)
        
        # Property: Should match YYYY-MM-DD format
        self.assertRegex(formatted, r'\d{4}-\d{2}-\d{2}')
        
        # Property: Should be parseable back to a date
        parsed_date = datetime.strptime(formatted, '%Y-%m-%d').date()
        self.assertEqual(parsed_date, test_date)

