┌─────────────────────────────────────────────────────────────────────────────┐
│                    AUTOMATION EVOLUTION                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐  │
│  │  Manual     │    │  RPA        │    │  Intelligent│    │  Autonomous │  │
│  │  Processes  │ ──→ │  (Rule-    │ ──→ │  Automation│ ──→ │  Operations │  │
│  │             │    │   Based)    │    │  (AI-Powered)│    │  (Self-     │  │
│  └─────────────┘    └─────────────┘    └─────────────┘    │  Optimising)│  │
│                                                             └─────────────┘  │
│                                                                             │
│  • Human-led      • Rule-based     • Cognitive       • Self-healing        │
│  • Error-prone    • Structured     • Unstructured    • Predictive          │
│  • Slow           • Repetitive     • Adaptive        • Autonomous          │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DOCUMENT PROCESSING PIPELINE                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DOCUMENT INGESTION                               │   │
│  │  (Scan, upload, email, API)                                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CLASSIFICATION                                   │   │
│  │  (Identify document type)                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA EXTRACTION                                  │   │
│  │  (OCR, NLP, structured data extraction)                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    VALIDATION                                       │   │
│  │  (Data quality checks, verification)                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PROCESSING                                       │   │
│  │  (Trigger workflows, update systems)                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    STORAGE & INDEXING                               │   │
│  │  (Document storage, searchable index)                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 3: INTELLIGENT AUTOMATION AND COGNITIVE RPA
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import re
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("INTELLIGENT AUTOMATION AND COGNITIVE RPA IN BANKING")
print("="*70)

# ----------------------------------------------------------------
# PART A: AUTOMATION MATURITY ASSESSMENT
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Automation Maturity Assessment")
print("-"*60)

maturity_dimensions = {
    'Process Discovery': {'Current Score': 2, 'Target Score': 4, 'Priority': 'High'},
    'RPA Coverage': {'Current Score': 3, 'Target Score': 5, 'Priority': 'High'},
    'AI/ML Integration': {'Current Score': 2, 'Target Score': 4, 'Priority': 'High'},
    'Document Processing': {'Current Score': 2, 'Target Score': 4, 'Priority': 'High'},
    'Process Mining': {'Current Score': 1, 'Target Score': 4, 'Priority': 'Medium'},
    'Intelligent Decisioning': {'Current Score': 2, 'Target Score': 4, 'Priority': 'High'},
    'Governance': {'Current Score': 2, 'Target Score': 4, 'Priority': 'Medium'}
}

maturity_df = pd.DataFrame(maturity_dimensions).T
print("Automation Maturity Assessment:")
print(maturity_df)

# Visualise
fig, ax = plt.subplots(figsize=(10, 6))
dimensions = list(maturity_df.index)
current = maturity_df['Current Score'].tolist()
target = maturity_df['Target Score'].tolist()

x = np.arange(len(dimensions))
width = 0.35

ax.barh(x - width/2, current, width, label='Current', color='blue', alpha=0.7)
ax.barh(x + width/2, target, width, label='Target', color='green', alpha=0.7)

ax.set_yticks(x)
ax.set_yticklabels(dimensions)
ax.set_xlabel('Maturity Score (1-5)')
ax.set_title('Automation Maturity Assessment')
ax.legend()
ax.grid(True, alpha=0.3, axis='x')

plt.tight_layout()
plt.savefig('automation_maturity.png', dpi=300, bbox_inches='tight')
plt.show()
print("Automation maturity visualisation saved as 'automation_maturity.png'")

# ----------------------------------------------------------------
# PART B: DOCUMENT PROCESSING AUTOMATION SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Document Processing Automation Simulation")
print("-"*60)

# Simulate document processing
class DocumentProcessor:
    """Simulate intelligent document processing."""
    
    def __init__(self):
        self.processed_count = 0
        self.avg_time = 0
        self.accuracy = 0
    
    def process_document(self, doc_type, doc_content):
        """Simulate document processing with OCR and NLP."""
        self.processed_count += 1
        
        # Simulate processing time
        import time
        processing_time = np.random.gamma(2, 0.5) + 0.5
        time.sleep(0.01)  # Simulate processing
        
        # Simulate accuracy
        accuracy = np.random.beta(5, 1)
        
        # Extract information based on document type
        extracted_data = {}
        if doc_type == 'Invoice':
            # Simulate invoice data extraction
            extracted_data = {
                'invoice_number': f'INV-{np.random.randint(1000, 9999)}',
                'amount': round(np.random.uniform(100, 5000), 2),
                'date': datetime.now().strftime('%Y-%m-%d'),
                'vendor': f'Vendor {np.random.randint(1, 100)}',
                'status': 'Processed'
            }
        elif doc_type == 'KYC':
            # Simulate KYC document extraction
            extracted_data = {
                'name': f'Customer {np.random.randint(1000, 9999)}',
                'id_number': f'ID-{np.random.randint(10000, 99999)}',
                'date_of_birth': f'{np.random.randint(1950, 2000)}-01-01',
                'address': f'{np.random.randint(100, 999)} Main St, City',
                'verified': True
            }
        elif doc_type == 'Loan Application':
            # Simulate loan application extraction
            extracted_data = {
                'applicant': f'Applicant {np.random.randint(1000, 9999)}',
                'amount': round(np.random.uniform(5000, 50000), 2),
                'purpose': np.random.choice(['Home', 'Auto', 'Education', 'Personal']),
                'term': np.random.choice([12, 24, 36, 48, 60]),
                'status': 'Under Review'
            }
        else:
            extracted_data = {'status': 'Unknown Document Type'}
        
        return {
            'doc_type': doc_type,
            'processing_time': processing_time,
            'accuracy': accuracy,
            'extracted_data': extracted_data
        }

# Simulate document processing
processor = DocumentProcessor()
doc_types = ['Invoice', 'KYC', 'Loan Application', 'Invoice', 'KYC', 'Invoice', 'Loan Application']

results = []
for doc_type in doc_types:
    result = processor.process_document(doc_type, 'Sample content')
    results.append(result)

# Create summary DataFrame
summary_df = pd.DataFrame([{
    'Document Type': r['doc_type'],
    'Processing Time (s)': round(r['processing_time'], 2),
    'Accuracy (%)': round(r['accuracy'] * 100, 1),
    'Extracted Data': str(r['extracted_data'])[:50] + '...'
} for r in results])

print("Document Processing Results:")
print(summary_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: INTELLIGENT AUTOMATION IMPACT ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Intelligent Automation Impact Analysis")
print("-"*60)

# Define processes and impact metrics
processes = ['Document Processing', 'Customer Onboarding', 'Transaction Monitoring', 
             'Regulatory Reporting', 'Fraud Detection', 'Customer Service']

impact_data = {
    'Process': processes,
    'Manual Time (hours)': [4.5, 3.0, 2.5, 5.0, 3.0, 2.0],
    'Manual Cost ($)': [45, 30, 25, 50, 30, 20],
    'Error Rate (%)': [8.0, 5.0, 6.0, 4.0, 7.0, 5.0],
    'IA Time (hours)': [0.5, 0.3, 0.2, 0.6, 0.3, 0.2],
    'IA Cost ($)': [5, 4, 3, 6, 4, 3],
    'IA Error Rate (%)': [0.5, 0.3, 0.4, 0.2, 0.5, 0.3]
}

ia_impact = pd.DataFrame(impact_data)
ia_impact['Time Reduction (%)'] = ((ia_impact['Manual Time (hours)'] - ia_impact['IA Time (hours)']) / ia_impact['Manual Time (hours)']) * 100
ia_impact['Cost Reduction (%)'] = ((ia_impact['Manual Cost ($)'] - ia_impact['IA Cost ($)']) / ia_impact['Manual Cost ($)']) * 100
ia_impact['Error Reduction (%)'] = ((ia_impact['Manual Error Rate (%)'] - ia_impact['IA Error Rate (%)']) / ia_impact['Manual Error Rate (%)']) * 100

print("Intelligent Automation Impact Analysis:")
print(ia_impact.round(2).to_string(index=False))

# Visualise
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# Time Reduction
ax = axes[0]
x = np.arange(len(processes))
width = 0.35
ax.bar(x - width/2, ia_impact['Manual Time (hours)'], width, label='Manual', color='red', alpha=0.7)
ax.bar(x + width/2, ia_impact['IA Time (hours)'], width, label='IA', color='green', alpha=0.7)
ax.set_xlabel('Process')
ax.set_ylabel('Time (hours)')
ax.set_title('Time Reduction with IA')
ax.set_xticks(x)
ax.set_xticklabels(processes, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

# Cost Reduction
ax = axes[1]
ax.bar(x - width/2, ia_impact['Manual Cost ($)'], width, label='Manual', color='red', alpha=0.7)
ax.bar(x + width/2, ia_impact['IA Cost ($)'], width, label='IA', color='green', alpha=0.7)
ax.set_xlabel('Process')
ax.set_ylabel('Cost ($)')
ax.set_title('Cost Reduction with IA')
ax.set_xticks(x)
ax.set_xticklabels(processes, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

# Error Reduction
ax = axes[2]
ax.bar(x - width/2, ia_impact['Manual Error Rate (%)'], width, label='Manual', color='red', alpha=0.7)
ax.bar(x + width/2, ia_impact['IA Error Rate (%)'], width, label='IA', color='green', alpha=0.7)
ax.set_xlabel('Process')
ax.set_ylabel('Error Rate (%)')
ax.set_title('Error Reduction with IA')
ax.set_xticks(x)
ax.set_xticklabels(processes, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('ia_impact.png', dpi=300, bbox_inches='tight')
plt.show()
print("Intelligent automation impact visualisation saved as 'ia_impact.png'")

# ----------------------------------------------------------------
# PART D: PROCESS MINING SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Process Mining Simulation")
print("-"*60)

# Simulate process events
np.random.seed(42)
n_events = 1000

process_events = pd.DataFrame({
    'case_id': np.random.choice(['Case_' + str(i) for i in range(1, 101)], n_events),
    'activity': np.random.choice(['Start', 'Application', 'Review', 'Approval', 'Documentation', 
                                  'Verification', 'Decision', 'Complete', 'Reject'], n_events,
                                p=[0.05, 0.15, 0.15, 0.10, 0.10, 0.10, 0.10, 0.15, 0.10]),
    'timestamp': [datetime.now() - timedelta(minutes=np.random.randint(0, 1440)) for _ in range(n_events)],
    'resource': np.random.choice(['Resource_' + str(i) for i in range(1, 11)], n_events),
    'duration': np.random.gamma(2, 5, n_events).clip(1, 60)
})

# Sort by case and timestamp
process_events = process_events.sort_values(['case_id', 'timestamp']).reset_index(drop=True)

# Calculate process metrics
case_summary = process_events.groupby('case_id').agg({
    'timestamp': ['min', 'max'],
    'activity': 'count',
    'duration': 'sum'
}).reset_index()
case_summary.columns = ['case_id', 'start_time', 'end_time', 'activity_count', 'total_duration']
case_summary['process_time'] = (case_summary['end_time'] - case_summary['start_time']).dt.total_seconds() / 60

print("Process Mining Sample Events:")
print(process_events.head(10))

print("\nCase Summary:")
print(case_summary.describe())

# Visualise process flow (simplified)
fig, ax = plt.subplots(figsize=(12, 6))

# Activity sequence analysis
activity_order = process_events.groupby('case_id')['activity'].apply(list).reset_index()
activity_counts = process_events['activity'].value_counts()
ax.bar(activity_counts.index, activity_counts.values, color='teal', alpha=0.7)
ax.set_xlabel('Activity')
ax.set_ylabel('Count')
ax.set_title('Process Activity Distribution')
ax.xticks(rotation=45)
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('process_mining.png', dpi=300, bbox_inches='tight')
plt.show()
print("Process mining visualisation saved as 'process_mining.png'")

# Identify bottlenecks
bottlenecks = case_summary.nlargest(10, 'process_time')
print("\nTop 10 Bottlenecks (Cases with Longest Processing Time):")
print(bottlenecks[['case_id', 'process_time', 'activity_count']].head(10).to_string(index=False))

# ----------------------------------------------------------------
# PART E: INTELLIGENT AUTOMATION ROADMAP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Intelligent Automation Roadmap")
print("-"*60)

ia_roadmap = {
    "Phase 1 (0-6 months) – Foundation": {
        "Focus": "Build intelligent automation capabilities.",
        "Activities": [
            "Implement document processing automation (OCR + NLP).",
            "Deploy intelligent chatbots for customer service.",
            "Establish process mining capabilities.",
            "Build an AI Centre of Excellence."
        ],
        "Success Metrics": ["Document processing time reduced by 70%", "Chatbot resolution rate > 60%"]
    },
    "Phase 2 (6-12 months) – Scaling": {
        "Focus": "Scale IA across the organisation.",
        "Activities": [
            "Scale document processing to all document types.",
            "Implement AI-powered fraud detection.",
            "Automate regulatory reporting with IA.",
            "Integrate IA with core systems."
        ],
        "Success Metrics": ["End-to-end automation for 10+ processes", "Fraud detection accuracy > 95%"]
    },
    "Phase 3 (12-24 months) – Cognitive": {
        "Focus": "Implement cognitive and predictive capabilities.",
        "Activities": [
            "Implement predictive analytics for process optimisation.",
            "Enable self-service automation for business users.",
            "Implement AI-powered decisioning.",
            "Develop autonomous operations."
        ],
        "Success Metrics": ["STP rate > 90%", "Predictive accuracy > 85%"]
    },
    "Phase 4 (24+ months) – Autonomous": {
        "Focus": "Self-optimising, self-healing operations.",
        "Activities": [
            "Deploy autonomous process optimisation.",
            "Implement self-healing automation.",
            "Enable continuous learning.",
            "Achieve zero-touch operations."
        ],
        "Success Metrics": ["Zero-touch operations > 80%", "Continuous improvement"]
    }
}

for phase, details in ia_roadmap.items():
    print(f"\n{phase}:")
    print(f"  Focus: {details['Focus']}")
    print("  Activities:")
    for activity in details['Activities']:
        print(f"    • {activity}")
    print("  Success Metrics:")
    for metric in details['Success Metrics']:
        print(f"    • {metric}")

# ----------------------------------------------------------------
# PART F: IA TECHNOLOGIES EVALUATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: IA Technologies Evaluation")
print("-"*60)

tech_evaluation = pd.DataFrame({
    'Technology': [
        'OCR/ICR',
        'NLP',
        'ML',
        'Generative AI',
        'Process Mining',
        'RPA',
        'Chatbots',
        'Computer Vision'
    ],
    'Maturity (1-5)': [5, 4, 4, 3, 4, 5, 4, 4],
    'Impact (1-5)': [4, 5, 5, 5, 4, 4, 4, 4],
    'Complexity (1-5)': [3, 4, 4, 5, 3, 2, 3, 4],
    'Investment Priority': ['High', 'High', 'High', 'High', 'Medium', 'High', 'Medium', 'Medium']
})

print("IA Technologies Evaluation:")
print(tech_evaluation.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 6))
scatter = ax.scatter(tech_evaluation['Maturity (1-5)'], tech_evaluation['Impact (1-5)'], 
                     s=tech_evaluation['Complexity (1-5)'] * 100, alpha=0.7)
for i, row in tech_evaluation.iterrows():
    ax.annotate(row['Technology'], (row['Maturity (1-5)'] + 0.1, row['Impact (1-5)'] + 0.1))
ax.set_xlabel('Maturity (1-5)')
ax.set_ylabel('Impact (1-5)')
ax.set_title('IA Technologies: Maturity vs Impact')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('ia_technologies.png', dpi=300, bbox_inches='tight')
plt.show()
print("IA technologies visualisation saved as 'ia_technologies.png'")

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

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

print("""
Intelligent Automation and Cognitive RPA – Key Takeaways:

1. Intelligent Automation combines RPA with AI/ML, NLP, and computer vision.
2. Key technologies: OCR, NLP, ML, Generative AI, Process Mining.
3. Use cases: document processing, customer service, fraud detection, compliance.
4. Document processing automation reduces time, cost, and errors.
5. Process mining identifies bottlenecks and automation opportunities.
6. Implementation roadmap: foundation → scaling → cognitive → autonomous.
7. Challenges: data quality, change management, talent, integration.

Recommendations:
  - Start with document processing automation.
  - Implement process mining to identify opportunities.
  - Build an AI Centre of Excellence.
  - Invest in NLP and ML capabilities.
  - Scale IA across the organisation.
  - Measure and optimise continuously.
""")

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