┌─────────────────────────────────────────────────────────────────────────────┐
│                    OMNICHANNEL ARCHITECTURE                               │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CHANNEL LAYER                                    │   │
│  │  Mobile App | Web | Branch | Contact Centre | ATM | Chatbot         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ORCHESTRATION LAYER                              │   │
│  │  Journey orchestration, personalisation, decision engine            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    API LAYER                                        │   │
│  │  API Gateway, microservices, event-driven architecture              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA LAYER                                       │   │
│  │  Customer Data Platform, data lake, real-time data processing       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    JOURNEY ORCHESTRATION PROCESS                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DESIGN                                          │   │
│  │  Map customer journeys, identify touchpoints, define triggers       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EXECUTE                                          │   │
│  │  Real-time triggers, personalised interactions, channel handovers   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MEASURE                                          │   │
│  │  Track journey performance, conversion, satisfaction                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    OPTIMISE                                         │   │
│  │  A/B testing, personalisation, continuous improvement               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 2, LESSON 4: OMNICHANNEL BANKING INTEGRATION
# ===================================================================

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

print("="*70)
print("OMNICHANNEL BANKING INTEGRATION")
print("="*70)

# ----------------------------------------------------------------
# PART A: OMNICHANNEL MATURITY ASSESSMENT
# ----------------------------------------------------------------

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

maturity_dimensions = {
    'Channel Availability': {'Current Score': 3, 'Target Score': 5, 'Priority': 'High'},
    'Channel Integration': {'Current Score': 2, 'Target Score': 5, 'Priority': 'High'},
    'Data Unification': {'Current Score': 3, 'Target Score': 5, 'Priority': 'High'},
    'Personalisation': {'Current Score': 2, 'Target Score': 5, 'Priority': 'High'},
    'Journey Orchestration': {'Current Score': 2, 'Target Score': 4, 'Priority': 'Medium'},
    'Real-Time Capability': {'Current Score': 2, 'Target Score': 4, 'Priority': 'Medium'},
    'Measurement': {'Current Score': 3, 'Target Score': 4, 'Priority': 'Medium'}
}

maturity_df = pd.DataFrame(maturity_dimensions).T
print("Omnichannel 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('Omnichannel Maturity Assessment')
ax.legend()
ax.grid(True, alpha=0.3, axis='x')

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

# ----------------------------------------------------------------
# PART B: CHANNEL INTEGRATION MATRIX
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Channel Integration Matrix")
print("-"*60)

channels = ['Mobile App', 'Web', 'Branch', 'Contact Centre', 'ATM', 'Chatbot']
integration_matrix = np.array([
    [5, 4, 3, 4, 4, 5],  # Mobile App
    [4, 5, 3, 4, 3, 4],  # Web
    [3, 3, 5, 4, 2, 3],  # Branch
    [4, 4, 4, 5, 3, 4],  # Contact Centre
    [4, 3, 2, 3, 5, 3],  # ATM
    [5, 4, 3, 4, 3, 5]   # Chatbot
])

integration_df = pd.DataFrame(integration_matrix, index=channels, columns=channels)
print("Channel Integration Matrix (1-5):")
print(integration_df)

# Visualise
fig, ax = plt.subplots(figsize=(10, 8))
sns.heatmap(integration_df, annot=True, fmt='.0f', cmap='RdYlGn', ax=ax, vmin=1, vmax=5)
ax.set_title('Channel Integration Heatmap')
plt.tight_layout()
plt.savefig('integration_matrix.png', dpi=300, bbox_inches='tight')
plt.show()
print("Integration matrix visualisation saved as 'integration_matrix.png'")

# ----------------------------------------------------------------
# PART C: CUSTOMER JOURNEY ORCHESTRATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Customer Journey Orchestration")
print("-"*60)

# Define a sample journey
journey = {
    'Trigger': 'Customer visits website',
    'Steps': [
        {'step': '1. Website Visit', 'channel': 'Web', 'action': 'Track visit'},
        {'step': '2. Browse Products', 'channel': 'Web', 'action': 'Recommend products'},
        {'step': '3. Add to Cart', 'channel': 'Web', 'action': 'Cart abandonment risk'},
        {'step': '4. Email Reminder', 'channel': 'Email', 'action': 'Send reminder'},
        {'step': '5. Mobile App Open', 'channel': 'Mobile App', 'action': 'Show cart'},
        {'step': '6. Complete Purchase', 'channel': 'Mobile App', 'action': 'Process order'},
        {'step': '7. Follow-up', 'channel': 'Chatbot', 'action': 'Ask for feedback'}
    ]
}

print("Customer Journey Orchestration:")
print(f"Trigger: {journey['Trigger']}")
print("\nJourney Steps:")
for step in journey['Steps']:
    print(f"  {step['step']} -> Channel: {step['channel']} -> Action: {step['action']}")

# ----------------------------------------------------------------
# PART D: CHANNEL PERFORMANCE DASHBOARD
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Omnichannel Performance Dashboard")
print("-"*60)

# Simulate channel performance data
channels = ['Mobile App', 'Web', 'Branch', 'Contact Centre', 'ATM', 'Chatbot']
usage = [78, 62, 32, 22, 58, 18]
satisfaction = [88, 82, 76, 72, 84, 80]
cost_per_transaction = [0.25, 0.50, 4.50, 3.00, 1.00, 0.15]
conversion = [72, 65, 55, 48, 60, 58]
integration_score = [5, 4, 3, 4, 3, 5]

dashboard_df = pd.DataFrame({
    'Channel': channels,
    'Usage (%)': usage,
    'Satisfaction (CSAT)': satisfaction,
    'Cost per Transaction ($)': cost_per_transaction,
    'Conversion Rate (%)': conversion,
    'Integration Score (1-5)': integration_score
})

print("Omnichannel Performance Dashboard:")
print(dashboard_df.to_string(index=False))

# Visualise
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Usage and Satisfaction
ax = axes[0, 0]
ax.scatter(dashboard_df['Usage (%)'], dashboard_df['Satisfaction (CSAT)'], s=100, alpha=0.7)
for i, channel in enumerate(dashboard_df['Channel']):
    ax.annotate(channel, (dashboard_df['Usage (%)'][i], dashboard_df['Satisfaction (CSAT)'][i]))
ax.set_xlabel('Usage (%)')
ax.set_ylabel('Satisfaction (CSAT)')
ax.set_title('Channel Usage vs Satisfaction')
ax.grid(True, alpha=0.3)

# Cost vs Conversion
ax = axes[0, 1]
ax.scatter(dashboard_df['Cost per Transaction ($)'], dashboard_df['Conversion Rate (%)'], s=100, alpha=0.7)
for i, channel in enumerate(dashboard_df['Channel']):
    ax.annotate(channel, (dashboard_df['Cost per Transaction ($)'][i], dashboard_df['Conversion Rate (%)'][i]))
ax.set_xlabel('Cost per Transaction ($)')
ax.set_ylabel('Conversion Rate (%)')
ax.set_title('Cost vs Conversion')
ax.grid(True, alpha=0.3)

# Integration Score by Channel
ax = axes[1, 0]
ax.bar(dashboard_df['Channel'], dashboard_df['Integration Score (1-5)'], color='teal', alpha=0.7)
ax.axhline(y=4, color='red', linestyle='--', label='Target (4)')
ax.set_xlabel('Channel')
ax.set_ylabel('Integration Score (1-5)')
ax.set_title('Channel Integration Score')
ax.legend()
ax.grid(True, alpha=0.3)

# Channel Radar
ax = axes[1, 1]
from math import pi
categories = dashboard_df['Channel'].tolist()
values = dashboard_df['Usage (%)'].tolist() + values[:1]  # For radar
values = dashboard_df['Integration Score (1-5)'].tolist()
N = len(categories)
angles = [n / float(N) * 2 * pi for n in range(N)]
angles += angles[:1]
values += values[:1]

ax = plt.subplot(2, 2, 4, projection='polar')
ax.plot(angles, values, 'o-', linewidth=2)
ax.fill(angles, values, alpha=0.25)
ax.set_xticks(angles[:-1])
ax.set_xticklabels(categories, size=8)
ax.set_ylim(0, 5)
ax.set_title('Channel Integration Score (Radar)')

plt.tight_layout()
plt.savefig('omnichannel_dashboard.png', dpi=300, bbox_inches='tight')
plt.show()
print("Omnichannel dashboard visualisation saved as 'omnichannel_dashboard.png'")

# ----------------------------------------------------------------
# PART E: OMNICHANNEL TECHNOLOGY STACK
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Omnichannel Technology Stack")
print("-"*60)

tech_stack = {
    "Channel Layer": {
        "Components": ["Mobile App", "Web", "Branch", "Contact Centre", "ATM", "Chatbot"],
        "Technologies": ["React Native", "React", "Salesforce", "Genesys", "NCR", "Dialogflow"]
    },
    "Orchestration Layer": {
        "Components": ["Journey Orchestration", "Personalisation", "Decision Engine"],
        "Technologies": ["Adobe Journey Optimizer", "Dynamic Yield", "Pega"]
    },
    "API Layer": {
        "Components": ["API Gateway", "Microservices", "Event Streaming"],
        "Technologies": ["Kong/AWS API Gateway", "Spring Boot", "Kafka"]
    },
    "Data Layer": {
        "Components": ["Customer Data Platform", "Data Lake", "Real-time Processing"],
        "Technologies": ["Segment/CDP", "Snowflake", "Apache Flink"]
    }
}

print("Omnichannel Technology Stack:")
for layer, details in tech_stack.items():
    print(f"\n{layer}:")
    print(f"  Components: {', '.join(details['Components'])}")
    print(f"  Technologies: {', '.join(details['Technologies'])}")

# ----------------------------------------------------------------
# PART F: OMNICHANNEL STRATEGY RECOMMENDATIONS
# ----------------------------------------------------------------

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

strategy = {
    "1. Data Unification": {
        "Actions": [
            "Implement a Customer Data Platform (CDP).",
            "Integrate data across all channels.",
            "Build a single customer view.",
            "Ensure data quality and governance."
        ],
        "Priority": "High",
        "Timeline": "0-6 months"
    },
    "2. Channel Integration": {
        "Actions": [
            "Implement API-first architecture.",
            "Connect all channels to the CDP.",
            "Enable seamless channel handovers.",
            "Ensure consistent experiences."
        ],
        "Priority": "High",
        "Timeline": "6-12 months"
    },
    "3. Journey Orchestration": {
        "Actions": [
            "Map key customer journeys.",
            "Implement journey orchestration engine.",
            "Define triggers and actions.",
            "Enable real-time personalisation."
        ],
        "Priority": "Medium",
        "Timeline": "12-18 months"
    },
    "4. Measurement": {
        "Actions": [
            "Define omnichannel KPIs.",
            "Implement cross-channel attribution.",
            "Track journey performance.",
            "Continuously optimise."
        ],
        "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("""
Omnichannel Banking Integration – Key Takeaways:

1. Omnichannel is a fully integrated, seamless customer experience across all channels.
2. Key principles: consistency, continuity, personalisation, context, and choice.
3. Architecture includes channel, orchestration, API, and data layers.
4. Journey orchestration designs, executes, and optimises customer journeys.
5. Technology enablers include CDP, API gateway, microservices, and event-driven architecture.
6. Measurement includes usage, satisfaction, cost, conversion, and integration.

Recommendations:
  - Implement a Customer Data Platform (CDP).
  - Build API-first architecture for channel integration.
  - Implement journey orchestration capabilities.
  - Enable real-time personalisation.
  - Measure and optimise omnichannel performance.
  - Prioritise channels based on customer value and potential.
""")

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