┌─────────────────────────────────────────────────────────────────────────────┐
│                    AML/CFT THREE LINES OF DEFENCE                           │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1ST LINE: BUSINESS OPERATIONS                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Customer onboarding and KYC                                      │   │
│  │ • Transaction monitoring                                            │   │
│  │ • Customer due diligence (CDD)                                      │   │
│  │ • Enhanced due diligence (EDD) for high-risk customers             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2ND LINE: COMPLIANCE & RISK MANAGEMENT                                    │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • AML policy and procedures                                         │   │
│  │ • Risk assessment                                                   │   │
│  │ • Training and awareness                                           │   │
│  │ • Compliance monitoring                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3RD LINE: INTERNAL AUDIT                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Independent review of AML program                                 │   │
│  │ • Testing of controls                                               │   │
│  │ • Reporting to board/management                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    RISK-BASED APPROACH                                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. IDENTIFY RISKS                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Geographic risk (high-risk jurisdictions)                          │   │
│  │ • Customer risk (PEPs, high-risk profiles)                          │   │
│  │ • Product risk (high-risk products/services)                         │   │
│  │ • Delivery channel risk (online, anonymous)                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. ASSESS AND PRIORITISE                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Likelihood of money laundering/terrorist financing                │   │
│  │ • Impact of potential misuse                                        │   │
│  │ • Prioritise highest risks                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. MITIGATE RISKS                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Implement controls proportionate to risk                        │   │
│  │ • Enhanced due diligence for high risk                              │   │
│  │ • Simplified due diligence for low risk                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 5, LESSON 3: AML/CFT AND COMPLIANCE
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from typing import Dict, List, Tuple
import random
import hashlib
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("AML/CFT AND COMPLIANCE")
print("="*70)

# ----------------------------------------------------------------
# PART A: RISK ASSESSMENT SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Customer Risk Assessment")
print("-"*60)

class CustomerRiskAssessment:
    """
    Simulated AML risk assessment for customers.
    """
    def __init__(self):
        self.risk_factors = {
            'jurisdiction_risk': {'High': 3, 'Medium': 2, 'Low': 1},
            'transaction_volume': {'High': 3, 'Medium': 2, 'Low': 1},
            'transaction_frequency': {'High': 3, 'Medium': 2, 'Low': 1},
            'pep_status': {'Yes': 3, 'No': 1},
            'source_of_funds': {'Verified': 1, 'Unverified': 3},
            'unusual_activity': {'Yes': 3, 'No': 1}
        }
    
    def assess(self, customer_data: Dict) -> Dict:
        """Assess customer risk based on multiple factors."""
        score = 0
        max_score = 0
        details = {}
        
        for factor, value in customer_data.items():
            if factor in self.risk_factors:
                factor_score = self.risk_factors[factor].get(value, 1)
                score += factor_score
                max_score += 3
                details[factor] = factor_score
        
        risk_percentage = score / max_score if max_score > 0 else 0
        risk_level = self._get_risk_level(risk_percentage)
        
        return {
            'risk_score': score,
            'risk_percentage': risk_percentage,
            'risk_level': risk_level,
            'details': details
        }
    
    def _get_risk_level(self, percentage: float) -> str:
        if percentage > 0.7:
            return 'High'
        elif percentage > 0.4:
            return 'Medium'
        else:
            return 'Low'

# Simulate risk assessments
assessor = CustomerRiskAssessment()

customers = [
    {'jurisdiction_risk': 'Low', 'transaction_volume': 'Low', 'transaction_frequency': 'Low',
     'pep_status': 'No', 'source_of_funds': 'Verified', 'unusual_activity': 'No'},
    {'jurisdiction_risk': 'High', 'transaction_volume': 'High', 'transaction_frequency': 'High',
     'pep_status': 'Yes', 'source_of_funds': 'Unverified', 'unusual_activity': 'No'},
    {'jurisdiction_risk': 'Medium', 'transaction_volume': 'High', 'transaction_frequency': 'Medium',
     'pep_status': 'No', 'source_of_funds': 'Unverified', 'unusual_activity': 'Yes'}
]

print("Customer Risk Assessments:")
for i, customer in enumerate(customers):
    result = assessor.assess(customer)
    print(f"\nCustomer {i+1}: Risk Level = {result['risk_level']}")
    print(f"  Score: {result['risk_score']} ({result['risk_percentage']:.0%})")
    print("  Factors:")
    for factor, score in result['details'].items():
        print(f"    {factor}: {score}/3")

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

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

class TransactionMonitor:
    """
    Simulated transaction monitoring for suspicious activity.
    """
    def __init__(self):
        self.transactions = []
        self.suspicious_transactions = []
        self.thresholds = {
            'large_amount': 50000,
            'high_frequency': 10,  # per day
            'unusual_destination': 'HighRisk',
            'structuring': 10000  # Below reporting threshold
        }
    
    def add_transaction(self, customer_id: str, amount: float, 
                        destination: str, timestamp: str) -> Dict:
        """Add a transaction and check for suspicious activity."""
        tx = {
            'customer_id': customer_id,
            'amount': amount,
            'destination': destination,
            'timestamp': timestamp,
            'tx_hash': hashlib.sha256(f"{customer_id}{amount}{timestamp}".encode()).hexdigest()[:16]
        }
        self.transactions.append(tx)
        
        # Check for suspicious activity
        flags = self._check_suspicious(tx)
        if flags:
            tx['flags'] = flags
            self.suspicious_transactions.append(tx)
        
        return tx
    
    def _check_suspicious(self, tx: Dict) -> List[str]:
        """Check for suspicious activity indicators."""
        flags = []
        
        # Large transaction
        if tx['amount'] > self.thresholds['large_amount']:
            flags.append('Large Amount')
        
        # Unusual destination
        if tx['destination'] == self.thresholds['unusual_destination']:
            flags.append('Unusual Destination')
        
        # Structuring (multiple small transactions)
        recent_txs = [t for t in self.transactions 
                     if t['customer_id'] == tx['customer_id'] and 
                     t['amount'] < self.thresholds['structuring']]
        if len(recent_txs) > self.thresholds['high_frequency']:
            flags.append('High Frequency (Potential Structuring)')
        
        # Round amounts (often associated with illicit activity)
        if tx['amount'] % 1000 == 0 and tx['amount'] > 10000:
            flags.append('Round Amount')
        
        return flags
    
    def get_suspicious_report(self) -> pd.DataFrame:
        """Generate suspicious activity report."""
        if not self.suspicious_transactions:
            return pd.DataFrame()
        
        data = []
        for tx in self.suspicious_transactions:
            data.append({
                'Customer': tx['customer_id'],
                'Amount': tx['amount'],
                'Destination': tx['destination'],
                'Flags': ', '.join(tx['flags']),
                'TX Hash': tx['tx_hash'][:8] + '...'
            })
        return pd.DataFrame(data)

# Simulate transactions
monitor = TransactionMonitor()

print("Simulating transaction monitoring...")
customers = ['C001', 'C002', 'C003']
destinations = ['Normal', 'HighRisk', 'Normal', 'Normal', 'HighRisk']

# Generate transactions
for i in range(50):
    customer = random.choice(customers)
    amount = random.uniform(100, 75000)
    destination = random.choice(destinations)
    timestamp = f"2024-01-{random.randint(1, 15):02d} {random.randint(0, 23):02d}:{random.randint(0, 59):02d}"
    
    tx = monitor.add_transaction(customer, amount, destination, timestamp)
    
    # Print suspicious transactions
    if 'flags' in tx:
        print(f"\n⚠️ Suspicious Transaction Detected:")
        print(f"  Customer: {customer}")
        print(f"  Amount: ${amount:,.2f}")
        print(f"  Flags: {', '.join(tx['flags'])}")

# Generate suspicious activity report
print(f"\nSuspicious Activity Report:")
suspicious_df = monitor.get_suspicious_report()
if not suspicious_df.empty:
    print(suspicious_df.to_string(index=False))
else:
    print("  No suspicious transactions detected")

# ----------------------------------------------------------------
# PART C: TRAVEL RULE COMPLIANCE
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Travel Rule Compliance")
print("-"*60)

class TravelRule:
    """
    Simulated Travel Rule compliance for VASPs.
    """
    def __init__(self):
        self.records = []
        self.threshold = 3000  # USD/EUR equivalent
    
    def process_transaction(self, originator: Dict, beneficiary: Dict, amount: float) -> Dict:
        """Process a transaction with Travel Rule compliance."""
        transaction = {
            'transaction_id': hashlib.sha256(f"{originator['name']}{beneficiary['name']}{amount}".encode()).hexdigest()[:16],
            'originator': originator,
            'beneficiary': beneficiary,
            'amount': amount,
            'travel_rule_applicable': amount >= self.threshold,
            'compliance_status': 'Pending'
        }
        
        if transaction['travel_rule_applicable']:
            # Verify information completeness
            missing_info = []
            for field in ['name', 'account', 'address']:
                if not originator.get(field):
                    missing_info.append(f"originator.{field}")
                if not beneficiary.get(field):
                    missing_info.append(f"beneficiary.{field}")
            
            if missing_info:
                transaction['compliance_status'] = 'Incomplete'
                transaction['missing_info'] = missing_info
                print(f"⚠️ Travel Rule Info Incomplete: {', '.join(missing_info)}")
            else:
                transaction['compliance_status'] = 'Compliant'
                print(f"✅ Travel Rule Compliant")
        else:
            print(f"ℹ️ Below threshold - Travel Rule not applicable")
        
        self.records.append(transaction)
        return transaction
    
    def get_compliance_report(self) -> pd.DataFrame:
        """Generate compliance report."""
        data = []
        for rec in self.records:
            data.append({
                'TX ID': rec['transaction_id'][:8] + '...',
                'Originator': rec['originator']['name'],
                'Beneficiary': rec['beneficiary']['name'],
                'Amount': rec['amount'],
                'Applicable': rec['travel_rule_applicable'],
                'Status': rec['compliance_status']
            })
        return pd.DataFrame(data)

# Simulate Travel Rule
travel_rule = TravelRule()

print("Travel Rule Compliance Simulation:")
transactions = [
    {
        'originator': {'name': 'Alice Johnson', 'account': '0x123...', 'address': 'US'},
        'beneficiary': {'name': 'Bob Smith', 'account': '0x456...', 'address': 'UK'},
        'amount': 5000
    },
    {
        'originator': {'name': 'Charlie Brown', 'account': '0x789...', 'address': 'Germany'},
        'beneficiary': {'name': 'Diana Ross', 'account': '0x321...', 'address': 'France'},
        'amount': 2500
    },
    {
        'originator': {'name': 'Eve Wilson', 'account': '0x654...', 'address': 'Singapore'},
        'beneficiary': {'name': 'Frank Davis', 'address': 'US'},  # Missing account
        'amount': 10000
    }
]

for tx in transactions:
    print(f"\nProcessing transaction: ${tx['amount']:,.2f}")
    travel_rule.process_transaction(tx['originator'], tx['beneficiary'], tx['amount'])

print("\nTravel Rule Compliance Report:")
print(travel_rule.get_compliance_report().to_string(index=False))

# ----------------------------------------------------------------
# PART D: AML COMPLIANCE FRAMEWORK
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: AML Compliance Framework")
print("-"*60)

aml_framework = {
    "Governance": {
        "Requirements": [
            "AML Policy approved by Board",
            "Compliance Officer appointed",
            "Regular reporting to management",
            "Independent audit of AML program"
        ]
    },
    "Customer Due Diligence": {
        "Requirements": [
            "KYC procedures in place",
            "Risk-based approach",
            "Enhanced due diligence for high risk",
            "Ongoing monitoring of customer relationships"
        ]
    },
    "Transaction Monitoring": {
        "Requirements": [
            "Real-time monitoring system",
            "Suspicious activity detection",
            "Alert management process",
            "Case management for investigations"
        ]
    },
    "Reporting": {
        "Requirements": [
            "Suspicious activity reporting",
            "Travel Rule compliance",
            "Threshold reporting",
            "Regulatory submissions"
        ]
    },
    "Training": {
        "Requirements": [
            "Initial training for all staff",
            "Annual refresher training",
            "Specialised training for compliance team",
            "Record of training completion"
        ]
    }
}

for area, details in aml_framework.items():
    print(f"\n{area.upper()}:")
    for req in details['Requirements']:
        print(f"  □ {req}")

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

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

print("""
AML/CFT and Compliance – Key Takeaways:

1. AML/CFT prevents money laundering and terrorist financing in digital assets.
2. FATF Recommendations provide global standards for VASPs.
3. Travel Rule requires sharing transaction information between VASPs.
4. KYC involves identification, verification, screening, and risk assessment.
5. Enhanced due diligence (EDD) is required for high-risk customers.
6. Transaction monitoring detects suspicious activity through red flags.
7. Reporting obligations include SARs, Travel Rule, and threshold reports.

Compliance Program Framework:
  - Establish governance and policy.
  - Implement customer due diligence procedures.
  - Deploy transaction monitoring systems.
  - Maintain record-keeping and reporting.
  - Train staff regularly.
  - Conduct independent audits.
  - Stay updated on regulatory changes.
""")