┌─────────────────────────────────────────────────────────────────────────────┐
│                    CONVERSATIONAL AI ARCHITECTURE                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    SPEECH RECOGNITION (ASR)                         │   │
│  │  (Converts speech to text)                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    NATURAL LANGUAGE UNDERSTANDING (NLU)              │   │
│  │  (Intent recognition, entity extraction, sentiment analysis)        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DIALOGUE MANAGEMENT                              │   │
│  │  (Context management, state tracking, response generation)          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    NATURAL LANGUAGE GENERATION (NLG)                 │   │
│  │  (Text-to-speech TTS, response generation)                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    SAMPLE DIALOG FLOW                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  User: "I want to check my balance."                                       │
│                                                                             │
│  Bot: "Sure, I can help with that. Which account would you like to check?" │
│                                                                             │
│  User: "My checking account."                                              │
│                                                                             │
│  Bot: "Your checking account balance is $1,234.56. Would you like to       │
│       see your recent transactions?"                                       │
│                                                                             │
│  User: "Yes, please."                                                      │
│                                                                             │
│  Bot: "Here are your last 5 transactions: ..."                            │
│                                                                             │
│  User: "Thanks."                                                           │
│                                                                             │
│  Bot: "You're welcome! Is there anything else I can help you with?"       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 2, LESSON 7: VOICE BANKING AND CONVERSATIONAL AI
# ===================================================================

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

print("="*70)
print("VOICE BANKING AND CONVERSATIONAL AI")
print("="*70)

# ----------------------------------------------------------------
# PART A: SIMPLE INTENT RECOGNITION SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Simple Intent Recognition System")
print("-"*60)

# Define intents and patterns
intents = {
    'balance_inquiry': {
        'patterns': ['balance', 'how much', 'account balance', 'check balance', 'what is my balance'],
        'responses': [
            "Your checking account balance is $1,234.56.",
            "Your savings account balance is $8,765.43.",
            "Your total balance across all accounts is $10,000.00."
        ]
    },
    'transfer_funds': {
        'patterns': ['transfer', 'send money', 'move money', 'pay', 'send to'],
        'responses': [
            "I can help with that. Which account would you like to transfer from?",
            "Please provide the amount you'd like to transfer.",
            "Who would you like to send money to?"
        ]
    },
    'transaction_history': {
        'patterns': ['transaction', 'history', 'recent transactions', 'what did I spend', 'payments'],
        'responses': [
            "Here are your last 5 transactions: ...",
            "You made a payment of $45.20 to Amazon yesterday.",
            "Your last transaction was $120.00 at Target."
        ]
    },
    'card_management': {
        'patterns': ['card', 'block card', 'report lost', 'lost card', 'new card', 'activate card'],
        'responses': [
            "I can help with card management. Please tell me which card you'd like to manage.",
            "Your card has been successfully blocked.",
            "A new card will be sent to your registered address."
        ]
    },
    'help': {
        'patterns': ['help', 'what can you do', 'assist', 'guide', 'how do I'],
        'responses': [
            "I can help you with: balance inquiries, transfers, transaction history, card management, and loan applications.",
            "What would you like assistance with today?",
            "I'm here to help with your banking needs."
        ]
    },
    'loan_application': {
        'patterns': ['loan', 'apply for loan', 'personal loan', 'mortgage', 'borrow'],
        'responses': [
            "I can help you with loan applications. What type of loan are you interested in?",
            "Our personal loans start from 5.99% APR. Would you like to start an application?",
            "Please provide the amount you'd like to borrow."
        ]
    }
}

def detect_intent(text):
    """Detect intent from user input."""
    text_lower = text.lower()
    for intent, data in intents.items():
        for pattern in data['patterns']:
            if pattern in text_lower:
                return intent, data['responses'][0]
    return 'unknown', "I'm not sure I understand. Could you please rephrase that?"

# Test the intent recognition
test_queries = [
    "What's my balance?",
    "I want to transfer money",
    "Can you show my recent transactions?",
    "I lost my card",
    "Help me",
    "Apply for a loan",
    "What's the weather like?"
]

print("Intent Recognition Test:")
for query in test_queries:
    intent, response = detect_intent(query)
    print(f"Query: '{query}' -> Intent: {intent}")
    print(f"  Response: {response}")

# ----------------------------------------------------------------
# PART B: CONVERSATIONAL AI METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Conversational AI Metrics")
print("-"*60)

# Simulate conversational AI performance metrics
metrics = pd.DataFrame({
    'Metric': [
        'Intent Recognition Accuracy',
        'User Satisfaction (CSAT)',
        'Task Completion Rate',
        'Average Conversation Length (turns)',
        'Fallback Rate',
        'Average Response Time (ms)',
        'User Retention Rate',
        'Escalation Rate (to human)'
    ],
    'Current Value': [
        '82%',
        '74%',
        '65%',
        '4.2',
        '18%',
        '850',
        '62%',
        '25%'
    ],
    'Target Value': [
        '> 90%',
        '> 80%',
        '> 80%',
        '3-5',
        '< 10%',
        '< 300',
        '> 70%',
        '< 15%'
    ],
    'Status': ['🟡', '🟡', '🔴', '🟡', '🔴', '🔴', '🔴', '🔴']
})

print("Conversational AI Metrics:")
print(metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART C: CONVERSATIONAL USAGE ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Conversational Usage Analysis")
print("-"*60)

# Simulate conversational data
np.random.seed(42)
n_conversations = 10000

conversation_data = pd.DataFrame({
    'conversation_id': range(1, n_conversations+1),
    'date': [datetime.now() - timedelta(days=np.random.randint(0, 365)) for _ in range(n_conversations)],
    'channel': np.random.choice(['Chatbot', 'Voice', 'WhatsApp', 'SMS'], n_conversations, 
                                p=[0.55, 0.20, 0.15, 0.10]),
    'intent': np.random.choice(list(intents.keys()) + ['unknown'], n_conversations,
                               p=[0.15, 0.12, 0.10, 0.08, 0.08, 0.05, 0.42]),
    'duration': np.random.gamma(2, 2, n_conversations).clip(0.5, 15),
    'turns': np.random.poisson(4, n_conversations).clip(1, 15),
    'satisfaction': np.random.choice([1, 2, 3, 4, 5], n_conversations, p=[0.05, 0.10, 0.20, 0.35, 0.30]),
    'resolved': np.random.choice([0, 1], n_conversations, p=[0.25, 0.75])
})

print("Conversational Data Sample:")
print(conversation_data.head())

# Summary statistics
print("\nChannel Distribution:")
print(conversation_data['channel'].value_counts())

print("\nIntent Distribution:")
print(conversation_data['intent'].value_counts().head(10))

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

# Channel Distribution
ax = axes[0, 0]
conversation_data['channel'].value_counts().plot(kind='pie', autopct='%1.1f%%', ax=ax)
ax.set_title('Channel Distribution')

# Intent Distribution
ax = axes[0, 1]
intent_counts = conversation_data['intent'].value_counts().head(8)
ax.barh(intent_counts.index, intent_counts.values, color='teal', alpha=0.7)
ax.set_xlabel('Count')
ax.set_title('Top Intents')

# Satisfaction Distribution
ax = axes[0, 2]
satisfaction_counts = conversation_data['satisfaction'].value_counts().sort_index()
ax.bar(satisfaction_counts.index, satisfaction_counts.values, color='green', alpha=0.7)
ax.set_xlabel('Satisfaction (1-5)')
ax.set_ylabel('Count')
ax.set_title('Satisfaction Distribution')

# Resolution Rate by Intent
ax = axes[1, 0]
intent_resolution = conversation_data.groupby('intent')['resolved'].mean().sort_values(ascending=False)
ax.barh(intent_resolution.index[:8], intent_resolution.values[:8], color='blue', alpha=0.7)
ax.set_xlabel('Resolution Rate')
ax.set_title('Resolution Rate by Intent')

# Duration by Channel
ax = axes[1, 1]
conversation_data.boxplot(column='duration', by='channel', ax=ax)
ax.set_title('Duration by Channel')
ax.set_ylabel('Duration (min)')
ax.set_xlabel('')

# Resolution Rate by Channel
ax = axes[1, 2]
channel_resolution = conversation_data.groupby('channel')['resolved'].mean()
ax.bar(channel_resolution.index, channel_resolution.values, color='purple', alpha=0.7)
ax.axhline(y=0.75, color='red', linestyle='--', label='Target (75%)')
ax.set_ylabel('Resolution Rate')
ax.set_title('Resolution Rate by Channel')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('conversational_ai_analysis.png', dpi=300, bbox_inches='tight')
plt.show()
print("Conversational AI analysis visualisation saved as 'conversational_ai_analysis.png'")

# ----------------------------------------------------------------
# PART D: VOICE BANKING USE CASES
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Voice Banking Use Cases")
print("-"*60)

voice_use_cases = {
    "1. Balance Inquiry": {
        "Description": "Check account balances by voice.",
        "Example": "What's my checking balance?",
        "Complexity": "Low"
    },
    "2. Transaction History": {
        "Description": "Get recent transactions by voice.",
        "Example": "Show my last 5 transactions.",
        "Complexity": "Medium"
    },
    "3. Fund Transfers": {
        "Description": "Transfer money by voice.",
        "Example": "Send $100 to John.",
        "Complexity": "High"
    },
    "4. Bill Payments": {
        "Description": "Pay bills by voice.",
        "Example": "Pay my electricity bill.",
        "Complexity": "Medium"
    },
    "5. Card Management": {
        "Description": "Activate, block, or report lost cards.",
        "Example": "Block my credit card.",
        "Complexity": "Medium"
    },
    "6. Account Opening": {
        "Description": "Open new accounts by voice.",
        "Example": "Open a savings account.",
        "Complexity": "High"
    },
    "7. Fraud Reporting": {
        "Description": "Report suspicious activity.",
        "Example": "Report a fraudulent transaction.",
        "Complexity": "High"
    },
    "8. Personal Finance": {
        "Description": "Budgeting and saving advice.",
        "Example": "How can I save more?",
        "Complexity": "Medium"
    }
}

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

# ----------------------------------------------------------------
# PART E: CONVERSATIONAL AI ROADMAP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Conversational AI Roadmap")
print("-"*60)

roadmap = {
    "Phase 1 (0-6 months)": {
        "Focus": "Implement basic chatbot for FAQs.",
        "Activities": [
            "Deploy rule-based chatbot on website and mobile app.",
            "Integrate with core banking systems (balance, transactions).",
            "Implement basic intent recognition."
        ],
        "Success Metrics": ["CSAT > 70%", "Resolution rate > 60%"]
    },
    "Phase 2 (6-12 months)": {
        "Focus": "Enhance with NLU and transactional capabilities.",
        "Activities": [
            "Implement NLU for better intent recognition.",
            "Add transactional capabilities (transfers, payments).",
            "Deploy voice assistant integration."
        ],
        "Success Metrics": ["CSAT > 75%", "Resolution rate > 70%"]
    },
    "Phase 3 (12-24 months)": {
        "Focus": "Contextual and predictive conversational AI.",
        "Activities": [
            "Implement context-aware conversations.",
            "Add predictive and proactive engagement.",
            "Personalise based on customer data."
        ],
        "Success Metrics": ["CSAT > 80%", "Resolution rate > 80%"]
    },
    "Phase 4 (24+ months)": {
        "Focus": "Autonomous AI assistant.",
        "Activities": [
            "Deploy fully autonomous AI assistant.",
            "Handle complex tasks end-to-end.",
            "Continuous learning and improvement."
        ],
        "Success Metrics": ["CSAT > 85%", "Resolution rate > 90%"]
    }
}

for phase, details in 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: CHALLENGES AND SOLUTIONS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Challenges and Solutions")
print("-"*60)

challenges = pd.DataFrame({
    'Challenge': [
        'Speech Recognition Accuracy',
        'Privacy and Security',
        'User Trust',
        'Complex Transactions',
        'Accents and Dialects',
        'Noise and Environment',
        'Context Understanding',
        'Integration with Legacy Systems'
    ],
    'Impact': ['High', 'Critical', 'Critical', 'High', 'Medium', 'Medium', 'High', 'High'],
    'Solution': [
        'Use advanced ASR models, continuous training.',
        'Encryption, anonymisation, secure authentication.',
        'Transparency, human fallback, clear privacy policies.',
        'Simplify flows, use confirmation steps.',
        'Train models on diverse accents, use multi-language support.',
        'Use noise-cancellation, optimise for environments.',
        'Use context management, session state tracking.',
        'Use API-first architecture, microservices.'
    ]
})

print("Challenges and Solutions:")
print(challenges.to_string(index=False))

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

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

print("""
Voice Banking and Conversational AI – Key Takeaways:

1. Conversational AI enables natural, intuitive banking interactions.
2. Key technologies: ASR, NLU, NLG, TTS, dialogue management.
3. Use cases: balance inquiries, transfers, payments, card management, support.
4. Design principles: natural language, clarity, context, personalisation.
5. Key metrics: accuracy, satisfaction, completion rate, fallback rate.
6. Challenges: accuracy, privacy, trust, complex transactions.
7. Roadmap: basic chatbot → NLU → contextual → autonomous AI.

Recommendations:
  - Start with simple, rule-based chatbots.
  - Gradually add NLU and transactional capabilities.
  - Ensure robust security and privacy.
  - Measure and optimise continuously.
  - Integrate with core banking systems.
  - Provide human fallback for complex issues.
""")

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