import numpy as np
import re
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass, field
from collections import defaultdict
import hashlib

@dataclass
class RegulatoryRule:
    rule_id: str
    jurisdiction: str
    category: str
    description: str
    thresholds: Dict[str, float]
    effective_date: str
    keywords: List[str] = field(default_factory=list)
    
class RegTechNLP:
    """NLP engine for regulatory text processing."""
    
    def __init__(self):
        self.rule_patterns = {
            'threshold': r'(?:above|over|exceeding|greater than)\s*\$?([\d,]+(?:\.\d+)?)',
            'timeframe': r'(?:within|within)\s*(\d+)\s*(business\s+)?days?',
            'reporting': r'(?:must|shall|required to)\s*(report|file|submit|notify)',
            'record_keeping': r'(?:retain|keep|maintain)\s*(?:records?|documentation)\s*(?:for)\s*(\d+)\s*years?'
        }
        
    def extract_rules(self, text: str) -> List[Dict]:
        rules = []
        
        for rule_type, pattern in self.rule_patterns.items():
            matches = re.finditer(pattern, text, re.IGNORECASE)
            for match in matches:
                rules.append({
                    'type': rule_type,
                    'value': match.group(1) if match.groups() else match.group(),
                    'position': match.span(),
                    'context': text[max(0, match.start()-50):match.end()+50]
                })
        
        return rules
    
    def classify_document(self, text: str) -> Dict[str, float]:
        categories = {
            'aml': ['anti-money laundering', 'suspicious activity', 'currency transaction', 'ctr', 'sar'],
            'kyc': ['know your customer', 'customer identification', 'beneficial ownership', 'cip'],
            'trading': ['market abuse', 'insider trading', 'market manipulation', 'best execution'],
            'capital': ['capital requirements', 'liquidity', 'leverage ratio', 'stress test'],
            'consumer': ['fair lending', 'udap', 'truth in lending', 'ecoa']
        }
        
        scores = {}
        text_lower = text.lower()
        
        for category, keywords in categories.items():
            score = sum(1 for kw in keywords if kw in text_lower)
            scores[category] = min(score / len(keywords), 1.0)
        
        return scores

class TransactionMonitor:
    """Real-time transaction monitoring for AML."""
    
    def __init__(self):
        self.customer_profiles: Dict[str, dict] = {}
        self.transaction_history: Dict[str, List[float]] = defaultdict(list)
        self.alerts: List[dict] = []
        
    def create_profile(self, customer_id: str, risk_level: str, 
                      avg_monthly_volume: float):
        self.customer_profiles[customer_id] = {
            'risk_level': risk_level,
            'avg_monthly_volume': avg_monthly_volume,
            'created_at': len(self.transaction_history)
        }
    
    def analyze_transaction(self, customer_id: str, amount: float, 
                           counterparty: str, timestamp: float) -> dict:
        profile = self.customer_profiles.get(customer_id, {})
        
        risk_score = 0
        reasons = []
        
        if amount > 10000:
            risk_score += 0.3
            reasons.append('large_amount')
        
        history = self.transaction_history[customer_id]
        if len(history) > 0:
            avg = np.mean(history)
            std = np.std(history) if len(history) > 1 else avg * 0.5
            
            if amount > avg + 3 * std:
                risk_score += 0.4
                reasons.append('amount_anomaly')
        
        if len(history) > 0:
            time_since_last = timestamp - (history[-1] if history else 0)
            if time_since_last < 60:
                risk_score += 0.3
                reasons.append('rapid_fire')
        
        if profile.get('risk_level') == 'high':
            risk_score *= 1.5
        
        self.transaction_history[customer_id].append(amount)
        
        if risk_score > 0.5:
            alert = {
                'customer_id': customer_id,
                'amount': amount,
                'risk_score': min(risk_score, 1.0),
                'reasons': reasons,
                'timestamp': timestamp
            }
            self.alerts.append(alert)
        
        return {
            'risk_score': min(risk_score, 1.0),
            'reasons': reasons,
            'flagged': risk_score > 0.5
        }

class ComplianceEngine:
    """Rule-based compliance checking engine."""
    
    def __init__(self):
        self.rules: Dict[str, RegulatoryRule] = {}
        self.controls: Dict[str, dict] = {}
        self.violations: List[dict] = []
        
    def add_rule(self, rule: RegulatoryRule):
        self.rules[rule.rule_id] = rule
    
    def add_control(self, control_id: str, rule_ids: List[str], 
                   implementation_status: str):
        self.controls[control_id] = {
            'rule_ids': rule_ids,
            'status': implementation_status,
            'last_tested': None
        }
    
    def check_compliance(self, transaction_data: Dict) -> List[dict]:
        violations = []
        
        for rule_id, rule in self.rules.items():
            if rule.category == 'aml':
                if transaction_data.get('amount', 0) > rule.thresholds.get('ctr', 10000):
                    if not transaction_data.get('ctr_filed', False):
                        violations.append({
                            'rule_id': rule_id,
                            'violation_type': 'ctr_not_filed',
                            'severity': 'high',
                            'details': f"Transaction of ${transaction_data['amount']:,.2f} requires CTR"
                        })
            
            elif rule.category == 'kyc':
                if transaction_data.get('customer_age_days', 0) < 30:
                    if transaction_data.get('enhanced_due_diligence', False) is False:
                        violations.append({
                            'rule_id': rule_id,
                            'violation_type': 'new_customer_no_edd',
                            'severity': 'medium',
                            'details': "New customer without enhanced due diligence"
                        })
        
        return violations
    
    def calculate_coverage(self) -> float:
        required_rules = set(self.rules.keys())
        covered_rules = set()
        
        for control in self.controls.values():
            covered_rules.update(control['rule_ids'])
        
        if not required_rules:
            return 1.0
        
        return len(covered_rules.intersection(required_rules)) / len(required_rules)

class RegulatoryChangeMonitor:
    """Monitor and assess impact of regulatory changes."""
    
    def __init__(self):
        self.changes: List[dict] = []
        self.impact_scores: Dict[str, float] = {}
        
    def register_change(self, change_id: str, jurisdiction: str, 
                       description: str, affected_areas: List[str],
                       deadline: str):
        change = {
            'change_id': change_id,
            'jurisdiction': jurisdiction,
            'description': description,
            'affected_areas': affected_areas,
            'deadline': deadline,
            'status': 'new'
        }
        self.changes.append(change)
        
        impact = self._assess_impact(change)
        self.impact_scores[change_id] = impact
        
        return impact
    
    def _assess_impact(self, change: dict) -> float:
        complexity_score = len(change['affected_areas']) * 0.2
        
        areas_to_business_impact = {
            'trading': 0.9,
            'lending': 0.8,
            'payments': 0.7,
            'reporting': 0.6,
            'operations': 0.5
        }
        
        business_impact = max(
            areas_to_business_impact.get(area, 0.3) 
            for area in change['affected_areas']
        )
        
        return min(complexity_score * business_impact, 1.0)
    
    def get_priority_queue(self) -> List[dict]:
        return sorted(
            self.changes,
            key=lambda c: self.impact_scores.get(c['change_id'], 0),
            reverse=True
        )

class RegTechSystem:
    """Complete RegTech compliance system."""
    
    def __init__(self):
        self.nlp = RegTechNLP()
        self.transaction_monitor = TransactionMonitor()
        self.compliance_engine = ComplianceEngine()
        self.change_monitor = RegulatoryChangeMonitor()
        self.audit_log: List[dict] = []
    
    def process_regulation(self, text: str, jurisdiction: str) -> dict:
        rules = self.nlp.extract_rules(text)
        categories = self.nlp.classify_document(text)
        
        self._log_audit('regulation_processed', {
            'jurisdiction': jurisdiction,
            'rules_extracted': len(rules),
            'categories': categories
        })
        
        return {
            'rules': rules,
            'categories': categories,
            'requires_action': len(rules) > 0
        }
    
    def monitor_transaction(self, customer_id: str, amount: float,
                           counterparty: str) -> dict:
        result = self.transaction_monitor.analyze_transaction(
            customer_id, amount, counterparty, len(self.transaction_monitor.transaction_history[customer_id])
        )
        
        if result['flagged']:
            self._log_audit('transaction_flagged', {
                'customer_id': customer_id,
                'amount': amount,
                'risk_score': result['risk_score']
            })
        
        return result
    
    def get_compliance_status(self) -> dict:
        coverage = self.compliance_engine.calculate_coverage()
        pending_changes = self.change_monitor.get_priority_queue()
        open_alerts = len(self.transaction_monitor.alerts)
        
        return {
            'coverage': coverage,
            'pending_regulatory_changes': len(pending_changes),
            'open_alerts': open_alerts,
            'violations': len(self.compliance_engine.violations)
        }
    
    def _log_audit(self, event_type: str, details: dict):
        self.audit_log.append({
            'event_type': event_type,
            'details': details,
            'timestamp': len(self.audit_log)
        })

# Example usage
if __name__ == "__main__":
    system = RegTechSystem()
    
    regulation_text = """
    Financial institutions must file a Currency Transaction Report (CTR) for 
    any cash transaction exceeding $10,000 within 15 business days. Suspicious 
    Activity Reports (SARs) must be filed within 30 days of detection for 
    transactions of $5,000 or more that suggest potential money laundering.
    """
    
    result = system.process_regulation(regulation_text, 'US')
    print(f"Rules extracted: {len(result['rules'])}")
    print(f"Categories: {result['categories']}")
    
    system.transaction_monitor.create_profile('CUST001', 'low', 5000)
    system.transaction_monitor.create_profile('CUST002', 'high', 50000)
    
    transactions = [
        ('CUST001', 8000, 'MERCHANT_A'),
        ('CUST001', 15000, 'MERCHANT_B'),
        ('CUST002', 25000, 'MERCHANT_C'),
        ('CUST001', 500, 'MERCHANT_D'),
    ]
    
    print("\nTransaction Monitoring:")
    for customer_id, amount, counterparty in transactions:
        result = system.monitor_transaction(customer_id, amount, counterparty)
        status = "FLAGGED" if result['flagged'] else "CLEARED"
        print(f"  {customer_id}: ${amount:,.2f} - {status} (Risk: {result['risk_score']:.2f})")
    
    coverage = system.compliance_engine.calculate_coverage()
    print(f"\nCompliance Coverage: {coverage*100:.1f}%")
    
    change_id = system.change_monitor.register_change(
        'CHG001', 'EU', 'DORA Operational Resilience Requirements',
        ['operations', 'reporting', 'technology'], '2025-01-17'
    )
    print(f"\nRegulatory Change Impact: {system.change_monitor.impact_scores['CHG001']:.2f}")
    
    status = system.get_compliance_status()
    print(f"\nSystem Status:")
    print(f"  Coverage: {status['coverage']*100:.1f}%")
    print(f"  Open Alerts: {status['open_alerts']}")
    print(f"  Pending Changes: {status['pending_regulatory_changes']}")