┌─────────────────────────────────────────────────────────────────────────────┐
│                    DIGITAL IDENTITY LIFECYCLE                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ONBOARDING (KYC)                                 │   │
│  │  (Identity verification, document verification)                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    AUTHENTICATION                                   │   │
│  │  (Login, transaction authorisation)                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    AUTHORISATION                                    │   │
│  │  (Access control, permissions)                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MONITORING                                       │   │
│  │  (Fraud detection, anomaly detection)                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    UPDATE & RETIREMENT                              │   │
│  │  (Profile updates, account closure)                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    MULTI-FACTOR AUTHENTICATION                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FACTOR 1: SOMETHING YOU KNOW                     │   │
│  │  (Password)                                                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    +                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FACTOR 2: SOMETHING YOU HAVE                     │   │
│  │  (OTP via SMS/App, Hardware Token)                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    +                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FACTOR 3: SOMETHING YOU ARE                      │   │
│  │  (Fingerprint, Face ID)                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ACCESS GRANTED                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    AI-POWERED FRAUD DETECTION                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA COLLECTION                                  │   │
│  │  (Transactions, user behaviour, device fingerprinting)              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FEATURE ENGINEERING                              │   │
│  │  (Amount, location, time, frequency, patterns)                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MODEL TRAINING                                   │   │
│  │  (Isolation Forest, XGBoost, Neural Networks)                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    REAL-TIME SCORING                                │   │
│  │  (Fraud score, risk assessment)                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ALERT & ACTION                                   │   │
│  │  (Block transaction, challenge user, notify team)                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 1, LESSON 8: DIGITAL IDENTITY AND SECURITY IN BANKING
# ===================================================================

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

print("="*70)
print("DIGITAL IDENTITY AND SECURITY IN BANKING")
print("="*70)

# ----------------------------------------------------------------
# PART A: AUTHENTICATION METHODS COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Authentication Methods Comparison")
print("-"*60)

auth_methods = pd.DataFrame({
    'Method': ['Password', 'SMS OTP', 'Email OTP', 'Authenticator App', 
               'Hardware Token', 'Fingerprint', 'Face ID', 'Voice Recognition', 
               'Behavioural Biometrics', 'Passwordless (FIDO)'],
    'Security Level': [3, 4, 4, 5, 5, 5, 5, 4, 4, 5],
    'Convenience': [3, 4, 3, 4, 3, 5, 5, 4, 5, 5],
    'Cost': [1, 3, 2, 3, 5, 4, 4, 4, 3, 3],
    'Adoption': [5, 5, 4, 4, 3, 5, 5, 3, 2, 3]
})

print("Authentication Methods Comparison (1-5 scale):")
print(auth_methods.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(12, 6))
auth_methods.set_index('Method')[['Security Level', 'Convenience']].plot(kind='bar', ax=ax)
ax.set_ylabel('Score (1-5)')
ax.set_title('Authentication Methods: Security vs Convenience')
ax.legend(loc='best')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('auth_comparison.png', dpi=300, bbox_inches='tight')
plt.show()
print("Authentication comparison visualisation saved as 'auth_comparison.png'")

# ----------------------------------------------------------------
# PART B: SIMULATED BIOMETRIC AUTHENTICATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Simulated Biometric Authentication")
print("-"*60)

def simulate_biometric_auth(biometric_type, false_accept_rate, false_reject_rate):
    """Simulate a biometric authentication attempt."""
    # Probability of success
    success_prob = 1 - false_reject_rate
    
    # Simulate attempt
    is_successful = np.random.random() < success_prob
    is_false_accept = np.random.random() < false_accept_rate
    is_false_reject = not is_successful and not is_false_accept
    
    return {
        'biometric_type': biometric_type,
        'successful': is_successful,
        'false_accept': is_false_accept,
        'false_reject': is_false_reject,
        'message': 'Authentication successful' if is_successful else 
                   ('False accept' if is_false_accept else 'False reject')
    }

# Parameters for different biometrics
biometrics = {
    'Fingerprint': {'far': 0.001, 'frr': 0.01},
    'Face ID': {'far': 0.001, 'frr': 0.02},
    'Voice': {'far': 0.01, 'frr': 0.05},
    'Iris': {'far': 0.0001, 'frr': 0.005},
    'Behavioural': {'far': 0.02, 'frr': 0.08}
}

# Simulate multiple attempts
results = []
for bio, params in biometrics.items():
    for _ in range(100):
        result = simulate_biometric_auth(bio, params['far'], params['frr'])
        results.append(result)

auth_df = pd.DataFrame(results)
auth_summary = auth_df.groupby('biometric_type')['successful'].mean()

print("Simulated Biometric Authentication Success Rates:")
print(auth_summary)

# ----------------------------------------------------------------
# PART C: FRAUD DETECTION WITH ISOLATION FOREST
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Fraud Detection with Isolation Forest")
print("-"*60)

# Generate synthetic transaction data
np.random.seed(42)
n_transactions = 10000

# Normal transactions
normal_amounts = np.random.lognormal(3.5, 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))

# Fraudulent transactions
fraud_amounts = np.random.lognormal(6, 1.5, int(n_transactions * 0.05))
fraud_times = np.random.normal(3, 2, int(n_transactions * 0.05)).clip(0, 23)
fraud_locations = np.random.normal(10, 5, int(n_transactions * 0.05))

# Combine
amounts = np.concatenate([normal_amounts, fraud_amounts])
times = np.concatenate([normal_times, fraud_times])
locations = np.concatenate([normal_locations, fraud_locations])
labels = np.concatenate([np.zeros(int(n_transactions * 0.95)), np.ones(int(n_transactions * 0.05))])

# Create DataFrame
transaction_df = pd.DataFrame({
    'amount': amounts,
    'time': times,
    'location': locations,
    'is_fraud': labels
})

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

print(f"Generated {len(transaction_df)} transactions.")
print(f"Fraud rate: {transaction_df['is_fraud'].mean():.4f}")

# Train Isolation Forest
features = ['amount', 'time', 'location']
scaler = StandardScaler()
X_scaled = scaler.fit_transform(transaction_df[features])

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("\nFraud Detection Performance:")
print(classification_report(transaction_df['is_fraud'], pred_labels, 
                           target_names=['Legitimate', 'Fraud']))

cm = confusion_matrix(transaction_df['is_fraud'], pred_labels)
print("\nConfusion Matrix:")
print(pd.DataFrame(cm, columns=['Pred Legit', 'Pred Fraud'], 
                   index=['Actual Legit', 'Actual Fraud']))

# ----------------------------------------------------------------
# PART D: KYC VERIFICATION SIMULATION
# ----------------------------------------------------------------

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

def simulate_kyc_verification(applicant):
    """Simulate a KYC verification process."""
    # Simulate document verification
    document_valid = np.random.random() > 0.05  # 95% pass rate
    
    # Simulate biometric verification
    biometric_valid = np.random.random() > 0.02  # 98% pass rate
    
    # Simulate database check (sanctions, PEP)
    database_clear = np.random.random() > 0.01  # 99% pass rate
    
    # Overall verification
    verified = document_valid and biometric_valid and database_clear
    
    return {
        'applicant': applicant,
        'document_verified': document_valid,
        'biometric_verified': biometric_valid,
        'database_clear': database_clear,
        'verified': verified,
        'status': 'Approved' if verified else 'Rejected'
    }

# Simulate applicants
applicants = [f'Applicant_{i+1}' for i in range(20)]
kyc_results = [simulate_kyc_verification(app) for app in applicants]

kyc_df = pd.DataFrame(kyc_results)
print("KYC Verification Results:")
print(kyc_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SECURITY THREAT TREND ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Security Threat Trend Analysis")
print("-"*60)

# Simulate threat data over time
years = ['2019', '2020', '2021', '2022', '2023', '2024']
threats = ['Phishing', 'Malware', 'Ransomware', 'Identity Theft', 'Account Takeover', 'Insider Threats']

threat_data = {
    'Phishing': [50, 70, 85, 100, 120, 140],
    'Malware': [60, 55, 50, 45, 40, 35],
    'Ransomware': [20, 40, 60, 80, 100, 110],
    'Identity Theft': [30, 35, 40, 50, 55, 60],
    'Account Takeover': [15, 20, 30, 45, 60, 75],
    'Insider Threats': [10, 12, 15, 18, 20, 22]
}

threat_df = pd.DataFrame(threat_data, index=years)
print("Security Threat Trends (Incidents per 10,000 customers):")
print(threat_df)

# Visualise
fig, ax = plt.subplots(figsize=(12, 6))
threat_df.plot(kind='line', marker='o', ax=ax, linewidth=2, markersize=8)
ax.set_xlabel('Year')
ax.set_ylabel('Incidents per 10,000 customers')
ax.set_title('Security Threat Trends')
ax.legend(loc='best')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('threat_trends.png', dpi=300, bbox_inches='tight')
plt.show()
print("Security threat trends visualisation saved as 'threat_trends.png'")

# ----------------------------------------------------------------
# PART F: DIGITAL IDENTITY STRATEGY
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Digital Identity Strategy")
print("-"*60)

identity_strategy = {
    "1. Customer Authentication": {
        "Tactics": [
            "Implement MFA with biometrics.",
            "Use behavioural biometrics for continuous authentication.",
            "Offer passwordless authentication (FIDO).",
            "Implement risk-based authentication."
        ],
        "Priority": "High",
        "Timeline": "Now"
    },
    "2. KYC/Onboarding": {
        "Tactics": [
            "Implement AI-powered document verification.",
            "Use biometric verification for identity proofing.",
            "Integrate with identity verification providers.",
            "Automate screening and monitoring."
        ],
        "Priority": "High",
        "Timeline": "Now"
    },
    "3. Fraud Detection": {
        "Tactics": [
            "Implement AI-powered fraud detection.",
            "Use real-time transaction monitoring.",
            "Build a fraud intelligence network.",
            "Implement case management for fraud investigation."
        ],
        "Priority": "High",
        "Timeline": "6 months"
    },
    "4. Security Infrastructure": {
        "Tactics": [
            "Implement zero-trust architecture.",
            "Use encryption for data at rest and in transit.",
            "Implement security monitoring and incident response.",
            "Conduct regular security assessments and penetration testing."
        ],
        "Priority": "High",
        "Timeline": "12 months"
    },
    "5. Compliance": {
        "Tactics": [
            "Ensure GDPR/CCPA compliance.",
            "Implement SCA per PSD2 requirements.",
            "Maintain AML/KYC compliance.",
            "Regular regulatory audits and reporting."
        ],
        "Priority": "High",
        "Timeline": "Ongoing"
    }
}

print("Digital Identity Strategy:")
for strategy_item, details in identity_strategy.items():
    print(f"\n{strategy_item}:")
    print("  Tactics:")
    for tactic in details['Tactics']:
        print(f"    • {tactic}")
    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("""
Digital Identity and Security – Key Takeaways:

1. Digital identity is critical for security, compliance, and customer experience.
2. Authentication methods include something you know, have, and are (biometrics).
3. Multi-factor authentication (MFA) is essential for security.
4. AI-powered fraud detection enables real-time risk assessment.
5. KYC compliance requires identity verification and ongoing monitoring.
6. Key threats: phishing, malware, ransomware, identity theft, account takeover.
7. Regulatory compliance: GDPR, PSD2 (SCA), AML/KYC, CCPA.

Recommendations:
  - Implement MFA with biometrics.
  - Use AI for fraud detection and KYC verification.
  - Adopt zero-trust architecture.
  - Ensure regulatory compliance (GDPR, PSD2, AML/KYC).
  - Invest in security monitoring and incident response.
  - Educate customers on security best practices.
""")

print("="*70)
print("END OF LESSON 8 – MODULE 1")
print("="*70)