┌─────────────────────────────────────────────────────────────────────────────┐
│                    AML/KYC PROCESS FLOW                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CUSTOMER IDENTIFICATION                          │   │
│  │  (KYC)                                                              │   │
│  │  • Collect customer information                                     │   │
│  │  • Verify identity (document verification)                         │   │
│  │  • Biometric verification                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CUSTOMER DUE DILIGENCE (CDD)                     │   │
│  │  • Sanctions screening                                              │   │
│  │  • PEP (Politically Exposed Person) screening                      │   │
│  │  • Risk assessment                                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ENHANCED DUE DILIGENCE (EDD)                     │   │
│  │  (For high-risk customers)                                          │   │
│  │  • Additional verification                                          │   │
│  │  • Source of funds verification                                    │   │
│  │  • Enhanced monitoring                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ONGOING MONITORING                               │   │
│  │  • Transaction monitoring                                           │   │
│  │  • Suspicious activity detection                                    │   │
│  │  • Regulatory reporting                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    KYC WORKFLOW                                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. Customer submits application                                           │
│  2. Document capture and OCR                                               │
│  3. Document verification (AI)                                            │
│  4. Biometric verification (facial recognition)                           │
│  5. Sanctions screening                                                   │
│  6. PEP screening                                                         │
│  7. Risk scoring                                                          │
│  8. Decision (approve/reject)                                            │
│  9. Account opening                                                       │
│  10. Ongoing monitoring                                                   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 6, LESSON 2: AML AND KYC AUTOMATION
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("AML AND KYC AUTOMATION IN DIGITAL BANKING")
print("="*70)

# ----------------------------------------------------------------
# PART A: KYC VERIFICATION SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: KYC Verification Simulation")
print("-"*60)

class KYCVerification:
    """Simulate an automated KYC verification system."""
    
    def __init__(self):
        self.verification_log = []
    
    def verify_document(self, document_type, document_data):
        """Simulate document verification."""
        # Simulate document verification
        is_valid = np.random.random() > 0.05  # 95% pass rate
        self.verification_log.append({
            'document_type': document_type,
            'is_valid': is_valid,
            'timestamp': datetime.now().isoformat()
        })
        return is_valid
    
    def verify_biometric(self, biometric_data):
        """Simulate biometric verification."""
        is_match = np.random.random() > 0.02  # 98% pass rate
        self.verification_log.append({
            'biometric_type': 'Face',
            'is_match': is_match,
            'timestamp': datetime.now().isoformat()
        })
        return is_match
    
    def check_sanctions(self, name):
        """Simulate sanctions screening."""
        # Simulated sanctions list
        sanctions = ['John Doe', 'Jane Smith', 'Robert Johnson']
        is_sanctioned = name in sanctions
        self.verification_log.append({
            'type': 'Sanctions',
            'name': name,
            'is_sanctioned': is_sanctioned,
            'timestamp': datetime.now().isoformat()
        })
        return is_sanctioned
    
    def check_pep(self, name):
        """Simulate PEP screening."""
        # Simulated PEP list
        peplist = ['Alex Johnson', 'Maria Rodriguez', 'David Chen']
        is_pep = name in peplist
        self.verification_log.append({
            'type': 'PEP',
            'name': name,
            'is_pep': is_pep,
            'timestamp': datetime.now().isoformat()
        })
        return is_pep
    
    def perform_kyc(self, customer_name, document_data, biometric_data):
        """Perform full KYC verification."""
        # Document verification
        doc_valid = self.verify_document('Passport', document_data)
        
        # Biometric verification
        bio_valid = self.verify_biometric(biometric_data)
        
        # Sanctions check
        sanctions = self.check_sanctions(customer_name)
        
        # PEP check
        pep = self.check_pep(customer_name)
        
        # Determine verification status
        if doc_valid and bio_valid and not sanctions and not pep:
            status = 'Approved'
        elif sanctions:
            status = 'Sanctions Alert'
        elif pep:
            status = 'PEP Alert'
        elif not doc_valid:
            status = 'Document Failed'
        elif not bio_valid:
            status = 'Biometric Failed'
        else:
            status = 'Manual Review Required'
        
        return {
            'customer': customer_name,
            'status': status,
            'document_valid': doc_valid,
            'biometric_valid': bio_valid,
            'sanctions': sanctions,
            'pep': pep
        }

# Test KYC verification
kyc = KYCVerification()

# Test customers
customers = [
    ('Alice Brown', 'passport_data_1', 'biometric_data_1'),
    ('John Doe', 'passport_data_2', 'biometric_data_2'),
    ('Maria Rodriguez', 'passport_data_3', 'biometric_data_3'),
    ('Robert Johnson', 'passport_data_4', 'biometric_data_4')
]

for name, doc, bio in customers:
    result = kyc.perform_kyc(name, doc, bio)
    print(f"Customer: {name}")
    print(f"  Status: {result['status']}")
    print(f"  Document: {'✅' if result['document_valid'] else '❌'}")
    print(f"  Biometric: {'✅' if result['biometric_valid'] else '❌'}")
    print(f"  Sanctions: {'⚠️' if result['sanctions'] else '✅'}")
    print(f"  PEP: {'⚠️' if result['pep'] else '✅'}")
    print()

# ----------------------------------------------------------------
# PART B: AML TRANSACTION MONITORING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: AML Transaction Monitoring")
print("-"*60)

# Generate transaction data
np.random.seed(42)
n_transactions = 5000
n_customers = 200

# Generate normal transactions
normal_amounts = np.random.lognormal(3, 0.8, int(n_transactions * 0.95))
normal_times = np.random.normal(12, 4, int(n_transactions * 0.95)).clip(0, 23)
normal_locations = np.random.normal(0, 1, int(n_transactions * 0.95))

# Generate suspicious transactions
suspicious_amounts = np.random.lognormal(6, 1.5, int(n_transactions * 0.05))
suspicious_times = np.random.normal(3, 2, int(n_transactions * 0.05)).clip(0, 23)
suspicious_locations = np.random.normal(10, 5, int(n_transactions * 0.05))

# Combine
amounts = np.concatenate([normal_amounts, suspicious_amounts])
times = np.concatenate([normal_times, suspicious_times])
locations = np.concatenate([normal_locations, suspicious_locations])
is_suspicious = np.concatenate([np.zeros(int(n_transactions * 0.95)), np.ones(int(n_transactions * 0.05))])

# Create DataFrame
transactions = pd.DataFrame({
    'amount': amounts,
    'time': times,
    'location': locations,
    'is_suspicious': is_suspicious,
    'customer_id': np.random.choice(range(1, n_customers + 1), n_transactions)
})

# Shuffle
transactions = transactions.sample(frac=1).reset_index(drop=True)

print(f"Generated {len(transactions)} transactions")
print(f"Suspicious rate: {transactions['is_suspicious'].mean():.4f}")

# ----------------------------------------------------------------
# PART C: ANOMALY DETECTION FOR AML
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Anomaly Detection for AML")
print("-"*60)

# Feature engineering
features = ['amount', 'time', 'location']
X = transactions[features]

# Scale features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Train Isolation Forest
iso_forest = IsolationForest(contamination=0.05, random_state=42)
iso_forest.fit(X_scaled)

# Predict anomalies
predictions = iso_forest.predict(X_scaled)
pred_labels = (predictions == -1).astype(int)

# Evaluate
from sklearn.metrics import confusion_matrix, classification_report

print("AML Anomaly Detection Performance:")
print(classification_report(transactions['is_suspicious'], pred_labels, 
                           target_names=['Normal', 'Suspicious']))

cm = confusion_matrix(transactions['is_suspicious'], pred_labels)
print("\nConfusion Matrix:")
print(pd.DataFrame(cm, columns=['Pred Normal', 'Pred Suspicious'], 
                   index=['Actual Normal', 'Actual Suspicious']))

# ----------------------------------------------------------------
# PART D: AML METRICS DASHBOARD
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: AML Metrics Dashboard")
print("-"*60)

aml_metrics = pd.DataFrame({
    'Metric': [
        'KYC Completion Rate',
        'KYC Average Time',
        'Suspicious Transaction Rate',
        'Alert Closure Rate',
        'False Positive Rate',
        'Sanctions Screening Coverage',
        'PEP Screening Coverage',
        'SAR Filing Rate'
    ],
    'Current Value': [
        '78%',
        '8.5 min',
        '4.2%',
        '65%',
        '25%',
        '92%',
        '88%',
        '95%'
    ],
    'Target Value': [
        '> 95%',
        '< 5 min',
        '< 2%',
        '> 90%',
        '< 5%',
        '> 99%',
        '> 95%',
        '> 99%'
    ],
    'Status': ['🔴', '🔴', '🟡', '🔴', '🔴', '🟡', '🟡', '🟡']
})

print("AML Metrics Dashboard:")
print(aml_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART E: AML REGULATORY REQUIREMENTS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: AML Regulatory Requirements")
print("-"*60)

aml_regulations = pd.DataFrame({
    'Requirement': [
        'Customer Identification',
        'Customer Due Diligence',
        'Enhanced Due Diligence',
        'Transaction Monitoring',
        'Record Keeping',
        'Suspicious Activity Reporting',
        'Sanctions Screening',
        'PEP Screening'
    ],
    'Status': ['✅', '✅', '🟡', '✅', '✅', '🟡', '✅', '🟡'],
    'Technology': [
        'KYC, Biometrics',
        'Risk Scoring',
        'EDD Workflow',
        'AI/ML',
        'Document Management',
        'Case Management',
        'Screening Tools',
        'PEP Data'
    ],
    'Owner': ['Compliance', 'Compliance', 'Compliance', 'Compliance', 'Compliance', 'Compliance', 'Compliance', 'Compliance']
})

print("AML Regulatory Requirements:")
print(aml_regulations.to_string(index=False))

# ----------------------------------------------------------------
# PART F: AML STRATEGY RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: AML Strategy Recommendations")
print("-"*60)

strategy = {
    "1. KYC Automation": {
        "Actions": [
            "Implement AI-powered document verification.",
            "Use biometrics for identity verification.",
            "Automate sanctions and PEP screening.",
            "Enable real-time risk scoring."
        ],
        "Priority": "High",
        "Timeline": "0-6 months"
    },
    "2. AML Transaction Monitoring": {
        "Actions": [
            "Implement AI-powered transaction monitoring.",
            "Use machine learning for anomaly detection.",
            "Reduce false positives.",
            "Enable real-time alerts."
        ],
        "Priority": "High",
        "Timeline": "0-12 months"
    },
    "3. Case Management": {
        "Actions": [
            "Implement automated case management.",
            "Enable workflow automation.",
            "Use AI for investigation triage.",
            "Integrate with reporting systems."
        ],
        "Priority": "Medium",
        "Timeline": "6-12 months"
    },
    "4. Reporting": {
        "Actions": [
            "Automate SAR filing.",
            "Implement regulatory reporting.",
            "Enable audit trails.",
            "Ensure record keeping compliance."
        ],
        "Priority": "High",
        "Timeline": "0-12 months"
    },
    "5. Compliance Culture": {
        "Actions": [
            "Conduct regular AML training.",
            "Establish compliance culture.",
            "Engage with regulators.",
            "Continuous improvement."
        ],
        "Priority": "Medium",
        "Timeline": "Ongoing"
    }
}

for item, details in strategy.items():
    print(f"\n{item}:")
    for action in details['Actions']:
        print(f"  • {action}")
    print(f"  Priority: {details['Priority']}")
    print(f"  Timeline: {details['Timeline']}")

# ----------------------------------------------------------------
# PART G: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART G: Summary and Recommendations")
print("="*70)

print("""
AML and KYC Automation – Key Takeaways:

1. AML and KYC are critical for regulatory compliance in banking.
2. AI-powered AML improves detection, reduces false positives, and enables real-time monitoring.
3. KYC automation includes document verification, biometrics, sanctions screening, and PEP screening.
4. Key metrics: KYC completion rate, suspicious transaction rate, alert closure rate, false positive rate.
5. Regulatory requirements: customer identification, CDD, EDD, transaction monitoring, reporting.
6. Roadmap: KYC automation → AML monitoring → case management → reporting → culture.

Recommendations:
  - Implement AI-powered KYC automation.
  - Deploy machine learning for AML transaction monitoring.
  - Reduce false positives with AI models.
  - Automate regulatory reporting.
  - Conduct regular AML training.
  - Engage with regulators proactively.
""")

print("="*70)
print("END OF LESSON 2 – MODULE 6")
print("="*70)