import asyncio
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime
import json

@dataclass
class ProcessedDocument:
    document_id: str
    document_type: str
    extracted_data: Dict
    confidence_scores: Dict[str, float]
    validation_status: str
    processing_time: float
    exceptions: List[str]

class IntelligentDocumentProcessor:
    """
    Enterprise-grade document processing with AI extraction,
    validation, and exception handling.
    """
    
    def __init__(self, config: Dict):
        self.config = config
        self.validation_rules = self._load_validation_rules()
        self.processing_stats = {
            'total_processed': 0,
            'successful': 0,
            'exceptions': 0,
            'avg_processing_time': 0
        }
    
    async def process_document_batch(self, documents: List[bytes]) -> List[ProcessedDocument]:
        """Process multiple documents in parallel for maximum throughput."""
        tasks = [self.process_single_document(doc, idx) 
                for idx, doc in enumerate(documents)]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        # Update statistics
        self._update_processing_stats(results)
        
        return [r for r in results if isinstance(r, ProcessedDocument)]
    
    async def process_single_document(self, document: bytes, doc_id: str) -> ProcessedDocument:
        """
        Process a single document with comprehensive error handling.
        
        Steps:
        1. Classify document type
        2. Extract relevant fields
        3. Validate extracted data
        4. Handle exceptions
        5. Route for human review if needed
        """
        start_time = datetime.now()
        exceptions = []
        
        try:
            # Step 1: Classify document type
            doc_type = await self._classify_document(document)
            
            # Step 2: Extract fields based on document type
            extraction_template = self._get_extraction_template(doc_type)
            extracted_data = await self._extract_fields(document, extraction_template)
            
            # Step 3: Validate extracted data
            validation_result = self._validate_data(extracted_data, doc_type)
            
            # Step 4: Apply business rules
            if validation_result['is_valid']:
                processed_data = self._apply_business_rules(extracted_data, doc_type)
            else:
                exceptions.extend(validation_result['errors'])
                processed_data = extracted_data
            
            # Step 5: Calculate confidence scores
            confidence_scores = self._calculate_confidence(extracted_data)
            
            # Determine if human review is needed
            needs_review = (
                min(confidence_scores.values()) < 0.85 or
                len(exceptions) > 0 or
                doc_type in self.config['always_review_types']
            )
            
            processing_time = (datetime.now() - start_time).total_seconds()
            
            return ProcessedDocument(
                document_id=f"DOC-{doc_id}-{datetime.now().strftime('%Y%m%d%H%M%S')}",
                document_type=doc_type,
                extracted_data=processed_data,
                confidence_scores=confidence_scores,
                validation_status='REVIEW_REQUIRED' if needs_review else 'VALIDATED',
                processing_time=processing_time,
                exceptions=exceptions
            )
            
        except Exception as e:
            # Log error and create exception document
            return ProcessedDocument(
                document_id=f"DOC-{doc_id}-ERROR",
                document_type='UNKNOWN',
                extracted_data={},
                confidence_scores={},
                validation_status='ERROR',
                processing_time=(datetime.now() - start_time).total_seconds(),
                exceptions=[str(e)]
            )
    
    async def _classify_document(self, document: bytes) -> str:
        """Use AI to classify document type with 98% accuracy."""
        # Simulate AI classification
        # In production, use your ML model or AI service
        await asyncio.sleep(0.1)  # Simulate processing
        return 'INVOICE'  # Example return
    
    async def _extract_fields(self, document: bytes, template: Dict) -> Dict:
        """Extract fields using OCR + NLP with field-level confidence."""
        # Simulate field extraction
        await asyncio.sleep(0.2)  # Simulate processing
        
        # Example extraction for invoice
        return {
            'invoice_number': 'INV-2024-1234',
            'vendor_name': 'Acme Corporation',
            'total_amount': 15750.00,
            'due_date': '2024-02-15',
            'line_items': [
                {'description': 'Professional Services', 'amount': 15000.00},
                {'description': 'Travel Expenses', 'amount': 750.00}
            ],
            'tax_amount': 1417.50,
            'currency': 'USD'
        }
    
    def _validate_data(self, data: Dict, doc_type: str) -> Dict:
        """Apply validation rules with detailed error reporting."""
        errors = []
        warnings = []
        
        rules = self.validation_rules.get(doc_type, {})
        
        for field, rule in rules.items():
            if field not in data and rule.get('required', False):
                errors.append(f"Missing required field: {field}")
            elif field in data:
                value = data[field]
                
                # Type validation
                if 'type' in rule and not isinstance(value, rule['type']):
                    errors.append(f"Invalid type for {field}: expected {rule['type']}")
                
                # Range validation
                if 'min' in rule and value < rule['min']:
                    errors.append(f"{field} below minimum: {value} < {rule['min']}")
                
                # Format validation
                if 'format' in rule and not self._validate_format(value, rule['format']):
                    errors.append(f"Invalid format for {field}: {value}")
                
                # Business rule validation
                if 'custom_validator' in rule:
                    custom_result = rule['custom_validator'](value, data)
                    if not custom_result['valid']:
                        errors.append(custom_result['error'])
        
        return {
            'is_valid': len(errors) == 0,
            'errors': errors,
            'warnings': warnings
        }
    
    def _apply_business_rules(self, data: Dict, doc_type: str) -> Dict:
        """Apply business logic transformations and enrichments."""
        processed = data.copy()
        
        # Example business rules for invoices
        if doc_type == 'INVOICE':
            # Auto-calculate if missing
            if 'subtotal' not in processed and 'line_items' in processed:
                processed['subtotal'] = sum(item['amount'] for item in processed['line_items'])
            
            # Apply tax calculation if needed
            if 'tax_amount' not in processed and 'subtotal' in processed:
                processed['tax_amount'] = processed['subtotal'] * 0.09  # 9% tax
            
            # Set payment terms if not specified
            if 'payment_terms' not in processed:
                processed['payment_terms'] = 'NET30'
            
            # Add processing metadata
            processed['processed_date'] = datetime.now().isoformat()
            processed['approval_required'] = processed.get('total_amount', 0) > 10000
        
        return processed
    
    def _calculate_confidence(self, data: Dict) -> Dict[str, float]:
        """Calculate field-level confidence scores."""
        # Simulate confidence calculation
        # In production, get these from your AI/ML extraction service
        confidence = {}
        for field in data:
            if isinstance(data[field], (int, float)):
                confidence[field] = 0.95  # High confidence for numbers
            elif isinstance(data[field], str) and len(data[field]) > 10:
                confidence[field] = 0.88  # Medium confidence for long text
            else:
                confidence[field] = 0.92  # Default confidence
        
        return confidence
    
    def _load_validation_rules(self) -> Dict:
        """Load validation rules for different document types."""
        return {
            'INVOICE': {
                'invoice_number': {'required': True, 'type': str, 'format': 'invoice_regex'},
                'vendor_name': {'required': True, 'type': str},
                'total_amount': {'required': True, 'type': float, 'min': 0},
                'due_date': {'required': True, 'format': 'date'},
                'currency': {'required': True, 'format': 'currency_code'}
            },
            'PURCHASE_ORDER': {
                'po_number': {'required': True, 'type': str},
                'vendor_id': {'required': True, 'type': str},
                'delivery_date': {'required': True, 'format': 'date'},
                'total_amount': {'required': True, 'type': float, 'min': 0}
            }
        }
    
    def _update_processing_stats(self, results: List):
        """Update real-time processing statistics."""
        for result in results:
            if isinstance(result, ProcessedDocument):
                self.processing_stats['total_processed'] += 1
                if result.validation_status != 'ERROR':
                    self.processing_stats['successful'] += 1
                if result.exceptions:
                    self.processing_stats['exceptions'] += 1
    
    def get_processing_metrics(self) -> Dict:
        """Get comprehensive processing metrics for monitoring."""
        total = self.processing_stats['total_processed']
        if total == 0:
            return self.processing_stats
        
        return {
            **self.processing_stats,
            'success_rate': self.processing_stats['successful'] / total,
            'exception_rate': self.processing_stats['exceptions'] / total,
            'documents_per_minute': total / (self.processing_stats.get('runtime_minutes', 1))
        }


# Usage Example
async def main():
    # Initialize processor with configuration
    processor = IntelligentDocumentProcessor({
        'always_review_types': ['CONTRACT', 'LEGAL_DOCUMENT'],
        'confidence_threshold': 0.85,
        'parallel_processing_limit': 10
    })
    
    # Simulate processing a batch of documents
    documents = [b"invoice_pdf_data_1", b"invoice_pdf_data_2", b"invoice_pdf_data_3"]
    
    # Process documents
    results = await processor.process_document_batch(documents)
    
    # Output results
    for doc in results:
        print(f"\nDocument: {doc.document_id}")
        print(f"Type: {doc.document_type}")
        print(f"Status: {doc.validation_status}")
        print(f"Processing Time: {doc.processing_time:.2f}s")
        print(f"Extracted Data: {json.dumps(doc.extracted_data, indent=2)}")
        if doc.exceptions:
            print(f"Exceptions: {doc.exceptions}")
    
    # Get performance metrics
    metrics = processor.get_processing_metrics()
    print(f"\nProcessing Metrics:")
    print(f"Success Rate: {metrics.get('success_rate', 0):.2%}")
    print(f"Documents/Minute: {metrics.get('documents_per_minute', 0):.0f}")

# Run the example
# asyncio.run(main())