┌─────────────────────────────────────────────────────────────────────────────┐
│                    360° CUSTOMER VIEW                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DEMOGRAPHIC DATA                                 │   │
│  │  Age, gender, income, location, occupation, education              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    RELATIONSHIP DATA                                │   │
│  │  Product holdings, account types, tenure, engagement               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRANSACTIONAL DATA                               │   │
│  │  Transaction history, spending patterns, payment behaviour          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BEHAVIOURAL DATA                                 │   │
│  │  Channel usage, app interactions, website visits, preferences       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    INTERACTION DATA                                 │   │
│  │  Customer service, complaints, feedback, chatbot conversations      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EXTERNAL DATA                                    │   │
│  │  Credit bureau, social media, third-party, public records           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    CDP IMPLEMENTATION PHASES                               │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Phase 1           Phase 2           Phase 3           Phase 4             │
│  ┌─────────┐      ┌─────────┐      ┌─────────┐      ┌─────────┐          │
│  │ Data    │      │ Identity │      │ Profile │      │ Activation│        │
│  │ Ingestion│ ──→ │ Resolution│ ──→ │ Building│ ──→ │ & Analytics│        │
│  └─────────┘      └─────────┘      └─────────┘      └─────────┘          │
│                                                                             │
│  • Connect      • Match        • Build       • Enable                     │
│    sources        records        profiles      personalisation             │
│  • Extract      • Merge        • Enrich      • Power                     │
│    data          duplicates      with data      analytics                  │
│  • Validate     • Create       • Segment     • Activate                   │
│    data          golden          customers      insights                   │
│                   record                                                     │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 4, LESSON 2: CUSTOMER DATA PLATFORMS (CDP) AND 360° VIEWS
# ===================================================================

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("CUSTOMER DATA PLATFORMS (CDP) AND 360° CUSTOMER VIEWS")
print("="*70)

# ----------------------------------------------------------------
# PART A: DATA SOURCE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Simulating Data Sources")
print("-"*60)

# Simulate core banking data
np.random.seed(42)
n_customers = 1000

core_banking = pd.DataFrame({
    'customer_id': range(1, n_customers + 1),
    'name': [f'Customer_{i}' for i in range(1, n_customers + 1)],
    'age': np.random.normal(45, 15, n_customers).clip(18, 80).astype(int),
    'income': np.random.gamma(5, 20, n_customers) + 20,
    'account_balance': np.random.gamma(3, 100, n_customers).clip(0, 50000),
    'account_type': np.random.choice(['Checking', 'Savings', 'Both'], n_customers, p=[0.3, 0.3, 0.4]),
    'tenure_years': np.random.gamma(2, 5, n_customers).clip(0, 20).astype(int)
})

# Simulate transaction data
n_transactions = 10000
transactions = pd.DataFrame({
    'customer_id': np.random.choice(range(1, n_customers + 1), n_transactions),
    'amount': np.random.lognormal(3, 1, n_transactions).clip(1, 1000),
    'category': np.random.choice(['Groceries', 'Dining', 'Utilities', 'Entertainment', 'Shopping', 'Transport', 'Healthcare'], n_transactions),
    'date': [datetime.now() - timedelta(days=np.random.randint(0, 365)) for _ in range(n_transactions)]
})

# Simulate digital channel data
digital = pd.DataFrame({
    'customer_id': np.random.choice(range(1, n_customers + 1), n_customers),
    'app_visits': np.random.poisson(10, n_customers).clip(0, 50),
    'web_visits': np.random.poisson(5, n_customers).clip(0, 30),
    'last_active': [datetime.now() - timedelta(days=np.random.randint(0, 30)) for _ in range(n_customers)],
    'device': np.random.choice(['iOS', 'Android', 'Web'], n_customers, p=[0.35, 0.45, 0.20])
})

print("Data Sources Simulated:")
print(f"Core Banking: {len(core_banking)} customers")
print(f"Transactions: {len(transactions)} transactions")
print(f"Digital Channel: {len(digital)} customers")

# ----------------------------------------------------------------
# PART B: DATA INGESTION AND UNIFICATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Data Ingestion and Unification")
print("-"*60)

class CustomerDataPlatform:
    """Simulate a Customer Data Platform."""
    
    def __init__(self):
        self.sources = {}
        self.customer_profiles = {}
        self.unified_data = None
    
    def ingest_data(self, source_name, data):
        """Ingest data from a source."""
        self.sources[source_name] = data
        print(f"Ingested {len(data)} records from {source_name}")
    
    def unify_customers(self):
        """Unify customer data from all sources."""
        # Start with core banking as the base
        unified = self.sources.get('core_banking', pd.DataFrame()).copy()
        
        # Add transaction aggregates
        if 'transactions' in self.sources:
            tx_agg = self.sources['transactions'].groupby('customer_id').agg({
                'amount': ['count', 'sum', 'mean'],
                'category': lambda x: x.mode()[0] if len(x) > 0 else None
            }).reset_index()
            tx_agg.columns = ['customer_id', 'tx_count', 'tx_sum', 'tx_avg', 'top_category']
            unified = unified.merge(tx_agg, on='customer_id', how='left')
        
        # Add digital channel data
        if 'digital' in self.sources:
            unified = unified.merge(self.sources['digital'], on='customer_id', how='left')
        
        # Fill missing values
        unified = unified.fillna({
            'tx_count': 0,
            'tx_sum': 0,
            'tx_avg': 0,
            'top_category': 'Unknown',
            'app_visits': 0,
            'web_visits': 0
        })
        
        # Create customer profile
        self.unified_data = unified
        self.customer_profiles = {row['customer_id']: row.to_dict() for _, row in unified.iterrows()}
        
        return unified

# Create CDP
cdp = CustomerDataPlatform()

# Ingest data
cdp.ingest_data('core_banking', core_banking)
cdp.ingest_data('transactions', transactions)
cdp.ingest_data('digital', digital)

# Unify data
unified = cdp.unify_customers()

print(f"\nUnified Data: {len(unified)} customers, {len(unified.columns)} attributes")
print("\nUnified Data Sample:")
print(unified.head())

# ----------------------------------------------------------------
# PART C: 360° CUSTOMER VIEW
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: 360° Customer View")
print("-"*60)

def display_360_view(customer_id, unified_data):
    """Display a 360° view of a specific customer."""
    customer = unified_data[unified_data['customer_id'] == customer_id]
    if len(customer) == 0:
        print(f"Customer {customer_id} not found")
        return
    
    print(f"\n--- 360° VIEW FOR CUSTOMER {customer_id} ---")
    print("\n1. DEMOGRAPHICS:")
    print(f"   Name: {customer['name'].values[0]}")
    print(f"   Age: {customer['age'].values[0]}")
    print(f"   Income: ${customer['income'].values[0]:,.2f}")
    
    print("\n2. ACCOUNTS:")
    print(f"   Account Type: {customer['account_type'].values[0]}")
    print(f"   Balance: ${customer['account_balance'].values[0]:,.2f}")
    print(f"   Tenure: {customer['tenure_years'].values[0]} years")
    
    print("\n3. TRANSACTION BEHAVIOUR:")
    print(f"   Transaction Count: {customer['tx_count'].values[0]}")
    print(f"   Total Spend: ${customer['tx_sum'].values[0]:,.2f}")
    print(f"   Average Transaction: ${customer['tx_avg'].values[0]:,.2f}")
    print(f"   Top Category: {customer['top_category'].values[0]}")
    
    print("\n4. DIGITAL ENGAGEMENT:")
    print(f"   App Visits: {customer['app_visits'].values[0]}")
    print(f"   Web Visits: {customer['web_visits'].values[0]}")
    print(f"   Device: {customer['device'].values[0]}")
    print(f"   Last Active: {customer['last_active'].values[0]}")

# Display 360° view for a sample customer
display_360_view(42, unified)

# ----------------------------------------------------------------
# PART D: CUSTOMER SEGMENTATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Customer Segmentation")
print("-"*60)

# Create segmentation features
unified['customer_value'] = unified['account_balance'] + unified['tx_sum']
unified['engagement_score'] = unified['app_visits'] + unified['web_visits']

# Segment customers
def segment_customer(row):
    """Segment customers based on value and engagement."""
    if row['customer_value'] > 50000 and row['engagement_score'] > 20:
        return 'High Value - High Engagement'
    elif row['customer_value'] > 50000 and row['engagement_score'] <= 20:
        return 'High Value - Low Engagement'
    elif row['customer_value'] <= 50000 and row['engagement_score'] > 20:
        return 'Low Value - High Engagement'
    else:
        return 'Low Value - Low Engagement'

unified['segment'] = unified.apply(segment_customer, axis=1)

segment_counts = unified['segment'].value_counts()
print("Customer Segments:")
print(segment_counts)

# Segment profiles
segment_profiles = unified.groupby('segment').agg({
    'age': 'mean',
    'income': 'mean',
    'account_balance': 'mean',
    'tx_count': 'mean',
    'tx_sum': 'mean',
    'app_visits': 'mean',
    'web_visits': 'mean'
}).round(2)

print("\nSegment Profiles:")
print(segment_profiles)

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

# Segment Distribution
ax = axes[0, 0]
ax.pie(segment_counts.values, labels=segment_counts.index, autopct='%1.1f%%')
ax.set_title('Customer Segment Distribution')

# Value vs Engagement
ax = axes[0, 1]
scatter = ax.scatter(unified['customer_value'], unified['engagement_score'], 
                     c=unified['segment'].astype('category').cat.codes, alpha=0.6, cmap='viridis')
ax.set_xlabel('Customer Value ($)')
ax.set_ylabel('Engagement Score')
ax.set_title('Customer Value vs Engagement')
plt.colorbar(scatter, ax=ax, label='Segment')

# Age by Segment
ax = axes[1, 0]
unified.boxplot(column='age', by='segment', ax=ax)
ax.set_title('Age by Segment')
ax.set_xlabel('')

# Transaction Volume by Segment
ax = axes[1, 1]
unified.boxplot(column='tx_count', by='segment', ax=ax)
ax.set_title('Transaction Count by Segment')
ax.set_xlabel('')

plt.tight_layout()
plt.savefig('cdp_segmentation.png', dpi=300, bbox_inches='tight')
plt.show()
print("CDP segmentation visualisation saved as 'cdp_segmentation.png'")

# ----------------------------------------------------------------
# PART E: CDP METRICS DASHBOARD
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: CDP Metrics Dashboard")
print("-"*60)

cdp_metrics = pd.DataFrame({
    'Metric': [
        'Data Coverage',
        'Identity Resolution Rate',
        'Data Freshness',
        'Data Accuracy',
        'CDP Adoption',
        'Time-to-Insight',
        'Personalisation Rate',
        'Customer Data Quality'
    ],
    'Current Value': [
        '85%',
        '92%',
        '2.5 hours',
        '96%',
        '55%',
        '3.2 hours',
        '35%',
        '88%'
    ],
    'Target Value': [
        '> 95%',
        '> 98%',
        '< 1 hour',
        '> 99%',
        '> 80%',
        '< 1 hour',
        '> 70%',
        '> 95%'
    ],
    'Status': ['🟡', '🟡', '🟡', '🟡', '🔴', '🔴', '🔴', '🟡']
})

print("CDP Metrics Dashboard:")
print(cdp_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART F: CDP USE CASES IN BANKING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: CDP Use Cases in Banking")
print("-"*60)

use_cases = {
    "Personalised Marketing": {
        "Description": "Targeted offers based on customer behaviour.",
        "Example": "Offer savings account to customers with high balances.",
        "Benefit": "Higher conversion rates."
    },
    "Customer Retention": {
        "Description": "Identify and retain at-risk customers.",
        "Example": "Proactive engagement for low-engagement high-value customers.",
        "Benefit": "Reduced churn."
    },
    "Cross-Sell": {
        "Description": "Recommend additional products.",
        "Example": "Offer credit card to customers with high transaction volume.",
        "Benefit": "Increased revenue."
    },
    "Risk Assessment": {
        "Description": "Assess customer risk using unified data.",
        "Example": "Identify high-risk customers for monitoring.",
        "Benefit": "Better risk management."
    },
    "Customer Service": {
        "Description": "360° view for service agents.",
        "Example": "Complete customer history for issue resolution.",
        "Benefit": "Faster, better service."
    },
    "Fraud Detection": {
        "Description": "Detect fraud using unified data.",
        "Example": "Unusual activity across accounts.",
        "Benefit": "Reduced fraud losses."
    }
}

for use_case, details in use_cases.items():
    print(f"\n{use_case}:")
    print(f"  Description: {details['Description']}")
    print(f"  Example: {details['Example']}")
    print(f"  Benefit: {details['Benefit']}")

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

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

print("""
Customer Data Platforms – Key Takeaways:

1. A CDP creates a persistent, unified customer database.
2. 360° customer view includes demographic, transactional, behavioural, and interaction data.
3. Identity resolution matches customer records across sources.
4. CDP enables segmentation, personalisation, analytics, and activation.
5. Key data sources: core banking, transactions, digital channels, CRM.
6. Key metrics: data coverage, identity resolution, data freshness, accuracy.
7. Use cases: personalised marketing, retention, cross-sell, risk, fraud.

Recommendations:
  - Build a CDP to unify customer data.
  - Implement identity resolution for a single customer view.
  - Use CDP data for segmentation and personalisation.
  - Enable real-time data updates.
  - Integrate CDP with marketing, sales, and service systems.
  - Measure and track CDP metrics.
""")

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