Building Smarter Customer Experiences with NLP: Advanced Language Technologies for Personalized Engagement

import pandas as pd
import numpy as np
from transformers import pipeline, AutoTokenizer, AutoModel
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from datetime import datetime, timedelta
import re
import json
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple

@dataclass
class CustomerInteraction:
    """Customer interaction data structure"""
    interaction_id: str
    customer_id: str
    timestamp: datetime
    channel: str  # chat, email, phone, social
    message: str
    sentiment_score: float = 0.0
    emotion: str = 'neutral'
    intent: str = 'unknown'
    urgency_level: str = 'medium'
    response: str = ''
    satisfaction_score: float = 0.0
    
class AdvancedNLPCustomerExperience:
    def __init__(self):
        # Initialize NLP models
        self.sentiment_analyzer = pipeline('sentiment-analysis', 
                                         model='cardiffnlp/twitter-roberta-base-sentiment-latest')
        self.emotion_analyzer = pipeline('text-classification', 
                                       model='j-hartmann/emotion-english-distilroberta-base')
        self.intent_classifier = pipeline('zero-shot-classification', 
                                         model='facebook/bart-large-mnli')
        
        # Customer data and interaction history
        self.customer_profiles = {}
        self.interaction_history = []
        self.knowledge_base = {}
        self.response_templates = {}
        
        # Conversation context tracking
        self.conversation_contexts = {}
        
        # Initialize intent categories
        self.intent_categories = [
            'technical_support', 'billing_inquiry', 'product_information',
            'complaint', 'compliment', 'refund_request', 'order_status',
            'account_management', 'general_inquiry', 'cancellation'
        ]
        
        # Initialize response templates
        self._initialize_response_templates()
        
    def _initialize_response_templates(self):
        """Initialize response templates for different intents and emotions"""
        self.response_templates = {
            'technical_support': {
                'positive': "I'm happy to help you with your technical issue! Let me guide you through the solution.",
                'negative': "I understand your frustration with this technical issue. Let me help resolve this quickly for you.",
                'neutral': "I can assist you with your technical support request. Here's what we can do:"
            },
            'billing_inquiry': {
                'positive': "I'd be glad to help clarify your billing information!",
                'negative': "I understand billing concerns can be stressful. Let me review your account and explain everything clearly.",
                'neutral': "I can help you with your billing inquiry. Let me look into your account details."
            },
            'complaint': {
                'positive': "Thank you for bringing this to our attention. I appreciate your patience as we resolve this.",
                'negative': "I sincerely apologize for the inconvenience you've experienced. Let me make this right for you immediately.",
                'neutral': "I understand your concern and I'm here to help resolve this issue for you."
            },
            'compliment': {
                'positive': "Thank you so much for your kind words! I'm delighted to hear about your positive experience.",
                'negative': "Thank you for the feedback. I'm glad we could turn your experience around!",
                'neutral': "Thank you for taking the time to share your positive feedback with us."
            }
        }
        
    def analyze_customer_message(self, message: str, customer_id: str, channel: str) -> CustomerInteraction:
        """Comprehensive analysis of customer message"""
        interaction_id = f"INT_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{customer_id}"
        
        # Sentiment analysis
        sentiment_result = self.sentiment_analyzer(message)[0]
        sentiment_score = sentiment_result['score'] if sentiment_result['label'] == 'POSITIVE' else -sentiment_result['score']
        
        # Emotion detection
        emotion_result = self.emotion_analyzer(message)[0]
        emotion = emotion_result['label'].lower()
        
        # Intent classification
        intent_result = self.intent_classifier(message, self.intent_categories)
        intent = intent_result['labels'][0]
        intent_confidence = intent_result['scores'][0]
        
        # Urgency detection
        urgency_level = self._detect_urgency(message, sentiment_score, emotion)
        
        # Create interaction object
        interaction = CustomerInteraction(
            interaction_id=interaction_id,
            customer_id=customer_id,
            timestamp=datetime.now(),
            channel=channel,
            message=message,
            sentiment_score=sentiment_score,
            emotion=emotion,
            intent=intent,
            urgency_level=urgency_level
        )
        
        # Generate appropriate response
        interaction.response = self.generate_intelligent_response(interaction)
        
        # Store interaction
        self.interaction_history.append(interaction)
        self._update_conversation_context(customer_id, interaction)
        
        return interaction
        
    def _detect_urgency(self, message: str, sentiment_score: float, emotion: str) -> str:
        """Detect urgency level based on message content and emotional state"""
        urgent_keywords = ['urgent', 'emergency', 'asap', 'immediately', 'critical', 'broken', 'not working']
        high_urgency_emotions = ['anger', 'fear', 'disgust']
        
        message_lower = message.lower()
        
        # Check for urgent keywords
        if any(keyword in message_lower for keyword in urgent_keywords):
            return 'high'
        
        # Check emotional state
        if emotion in high_urgency_emotions or sentiment_score < -0.7:
            return 'high'
        
        # Check for question marks (indicates need for response)
        if '?' in message and sentiment_score < -0.3:
            return 'medium'
        
        return 'low' if sentiment_score > 0.5 else 'medium'
        
    def generate_intelligent_response(self, interaction: CustomerInteraction) -> str:
        """Generate contextually appropriate response"""
        # Get conversation context
        context = self.conversation_contexts.get(interaction.customer_id, [])
        
        # Determine sentiment category for response template
        if interaction.sentiment_score > 0.3:
            sentiment_category = 'positive'
        elif interaction.sentiment_score < -0.3:
            sentiment_category = 'negative'
        else:
            sentiment_category = 'neutral'
            
        # Get base response template
        template = self.response_templates.get(interaction.intent, {}).get(
            sentiment_category, 
            "I understand your inquiry and I'm here to help you with that."
        )
        
        # Personalize based on customer history
        personalized_response = self._personalize_response(template, interaction, context)
        
        # Add specific solution if available
        solution = self._get_solution_for_intent(interaction.intent, interaction.message)
        if solution:
            personalized_response += f" {solution}"
            
        return personalized_response
        
    def _personalize_response(self, template: str, interaction: CustomerInteraction, context: List) -> str:
        """Personalize response based on customer history and current context"""
        # Add customer name if available
        customer_name = self.customer_profiles.get(interaction.customer_id, {}).get('name')
        if customer_name:
            template = template.replace('I', f'Hi {customer_name}, I')
            
        # Reference previous interactions if relevant
        if len(context) > 1:
            prev_interaction = context[-2]
            if prev_interaction.intent == interaction.intent:
                template += " I see this is a follow-up to your previous inquiry."
                
        # Adjust for urgency
        if interaction.urgency_level == 'high':
            template = template.replace('I can', 'I will immediately').replace('Let me', 'Let me urgently')
            
        return template
        
    def _get_solution_for_intent(self, intent: str, message: str) -> Optional[str]:
        """Get specific solution based on intent and message content"""
        solutions = {
            'technical_support': "Here are the troubleshooting steps: 1) Restart your device, 2) Check your internet connection, 3) Clear your browser cache. If the issue persists, I'll connect you with our technical team.",
            'billing_inquiry': "I can provide your current balance, recent transactions, and explain any charges. Would you like me to email you a detailed billing summary?",
            'order_status': "Let me check your order status right away. I'll need your order number or the email address used for the purchase.",
            'refund_request': "I can process your refund request. Our policy allows returns within 30 days. I'll guide you through the return process.",
            'account_management': "I can help you update your account information, change your password, or modify your preferences. What would you like to update?"
        }
        
        return solutions.get(intent)
        
    def _update_conversation_context(self, customer_id: str, interaction: CustomerInteraction):
        """Update conversation context for customer"""
        if customer_id not in self.conversation_contexts:
            self.conversation_contexts[customer_id] = []
            
        self.conversation_contexts[customer_id].append(interaction)
        
        # Keep only last 10 interactions for context
        if len(self.conversation_contexts[customer_id]) > 10:
            self.conversation_contexts[customer_id] = self.conversation_contexts[customer_id][-10:]
            
    def analyze_customer_journey(self, customer_id: str, days_back: int = 30) -> Dict:
        """Analyze customer journey and provide insights"""
        cutoff_date = datetime.now() - timedelta(days=days_back)
        customer_interactions = [
            interaction for interaction in self.interaction_history
            if interaction.customer_id == customer_id and interaction.timestamp >= cutoff_date
        ]
        
        if not customer_interactions:
            return {'error': 'No interactions found for this customer'}
            
        # Calculate journey metrics
        journey_analysis = {
            'total_interactions': len(customer_interactions),
            'channels_used': list(set(i.channel for i in customer_interactions)),
            'average_sentiment': np.mean([i.sentiment_score for i in customer_interactions]),
            'most_common_intent': self._get_most_common_intent(customer_interactions),
            'emotion_distribution': self._get_emotion_distribution(customer_interactions),
            'urgency_pattern': self._get_urgency_pattern(customer_interactions),
            'satisfaction_trend': self._calculate_satisfaction_trend(customer_interactions),
            'resolution_rate': self._calculate_resolution_rate(customer_interactions)
        }
        
        return journey_analysis
        
    def generate_proactive_recommendations(self, customer_id: str) -> List[Dict]:
        """Generate proactive recommendations based on customer behavior"""
        context = self.conversation_contexts.get(customer_id, [])
        if not context:
            return []
            
        recommendations = []
        recent_interactions = context[-5:]  # Last 5 interactions
        
        # Check for recurring issues
        intents = [i.intent for i in recent_interactions]
        if intents.count('technical_support') >= 2:
            recommendations.append({
                'type': 'proactive_support',
                'priority': 'high',
                'message': 'We noticed you\'ve had multiple technical issues. Would you like us to schedule a call with our technical specialist?',
                'action': 'schedule_technical_call'
            })
            
        # Check sentiment decline
        sentiments = [i.sentiment_score for i in recent_interactions]
        if len(sentiments) >= 3 and all(s < 0 for s in sentiments[-3:]):
            recommendations.append({
                'type': 'retention_outreach',
                'priority': 'critical',
                'message': 'We\'re concerned about your recent experience. Can we arrange a call to discuss how we can better serve you?',
                'action': 'schedule_retention_call'
            })
            
        # Check for upsell opportunities
        if any(i.intent == 'product_information' for i in recent_interactions):
            recommendations.append({
                'type': 'product_recommendation',
                'priority': 'medium',
                'message': 'Based on your interests, you might like our premium features. Would you like a free trial?',
                'action': 'offer_trial'
            })
            
        return recommendations
        
    def measure_nlp_effectiveness(self) -> Dict:
        """Measure effectiveness of NLP-powered customer experience"""
        if not self.interaction_history:
            return {'error': 'No interaction data available'}
            
        recent_interactions = [
            i for i in self.interaction_history 
            if i.timestamp >= datetime.now() - timedelta(days=30)
        ]
        
        metrics = {
            'total_interactions': len(recent_interactions),
            'average_sentiment_score': np.mean([i.sentiment_score for i in recent_interactions]),
            'positive_sentiment_percentage': len([i for i in recent_interactions if i.sentiment_score > 0]) / len(recent_interactions) * 100,
            'intent_classification_accuracy': self._estimate_intent_accuracy(recent_interactions),
            'response_personalization_rate': self._calculate_personalization_rate(recent_interactions),
            'emotion_recognition_coverage': len(set(i.emotion for i in recent_interactions)),
            'urgency_detection_effectiveness': self._calculate_urgency_effectiveness(recent_interactions),
            'channel_distribution': self._get_channel_distribution(recent_interactions)
        }
        
        return metrics
        
    # Helper methods for analytics
    def _get_most_common_intent(self, interactions): 
        intents = [i.intent for i in interactions]
        return max(set(intents), key=intents.count) if intents else 'unknown'
        
    def _get_emotion_distribution(self, interactions):
        emotions = [i.emotion for i in interactions]
        unique_emotions = set(emotions)
        return {emotion: emotions.count(emotion) for emotion in unique_emotions}
        
    def _get_urgency_pattern(self, interactions):
        urgency_levels = [i.urgency_level for i in interactions]
        return {'high': urgency_levels.count('high'), 'medium': urgency_levels.count('medium'), 'low': urgency_levels.count('low')}
        
    def _calculate_satisfaction_trend(self, interactions):
        if len(interactions) < 2:
            return 'insufficient_data'
        sentiments = [i.sentiment_score for i in interactions]
        return 'improving' if sentiments[-1] > sentiments[0] else 'declining'
        
    def _calculate_resolution_rate(self, interactions):
        # Simplified - in practice would track actual resolution
        positive_endings = len([i for i in interactions if i.sentiment_score > 0.2])
        return (positive_endings / len(interactions)) * 100 if interactions else 0
        
    def _estimate_intent_accuracy(self, interactions):
        # Simplified estimation - in practice would use labeled data
        return 85.0  # Placeholder for intent classification accuracy
        
    def _calculate_personalization_rate(self, interactions):
        # Check how many responses were personalized
        personalized = len([i for i in interactions if 'Hi ' in i.response or 'follow-up' in i.response])
        return (personalized / len(interactions)) * 100 if interactions else 0
        
    def _calculate_urgency_effectiveness(self, interactions):
        # Measure how well urgency detection aligns with sentiment
        correct_urgency = 0
        for i in interactions:
            if (i.urgency_level == 'high' and i.sentiment_score < -0.5) or \
               (i.urgency_level == 'low' and i.sentiment_score > 0.3):
                correct_urgency += 1
        return (correct_urgency / len(interactions)) * 100 if interactions else 0
        
    def _get_channel_distribution(self, interactions):
        channels = [i.channel for i in interactions]
        unique_channels = set(channels)
        return {channel: channels.count(channel) for channel in unique_channels}

# Example usage and demonstration
def run_nlp_customer_experience_demo():
    # Initialize NLP customer experience system
    nlp_system = AdvancedNLPCustomerExperience()
    
    # Sample customer interactions
    sample_interactions = [
        {
            'message': "I'm really frustrated! My order hasn't arrived and it's been two weeks!",
            'customer_id': 'CUST001',
            'channel': 'chat'
        },
        {
            'message': "Hi, I love your product! Can you tell me about the premium features?",
            'customer_id': 'CUST002', 
            'channel': 'email'
        },
        {
            'message': "My billing seems wrong. Can you help explain these charges?",
            'customer_id': 'CUST003',
            'channel': 'phone'
        },
        {
            'message': "Thank you so much for the quick resolution yesterday!",
            'customer_id': 'CUST001',
            'channel': 'chat'
        }
    ]
    
    print("=== NLP Customer Experience Analysis ===")
    
    # Process each interaction
    for interaction_data in sample_interactions:
        interaction = nlp_system.analyze_customer_message(
            message=interaction_data['message'],
            customer_id=interaction_data['customer_id'],
            channel=interaction_data['channel']
        )
        
        print(f"\nCustomer: {interaction.customer_id}")
        print(f"Message: {interaction.message}")
        print(f"Sentiment: {interaction.sentiment_score:.2f} | Emotion: {interaction.emotion}")
        print(f"Intent: {interaction.intent} | Urgency: {interaction.urgency_level}")
        print(f"Response: {interaction.response}")
        print("-" * 80)
    
    # Analyze customer journey
    print("\n=== Customer Journey Analysis ===")
    journey = nlp_system.analyze_customer_journey('CUST001')
    if 'error' not in journey:
        print(f"Total Interactions: {journey['total_interactions']}")
        print(f"Average Sentiment: {journey['average_sentiment']:.2f}")
        print(f"Most Common Intent: {journey['most_common_intent']}")
        print(f"Channels Used: {journey['channels_used']}")
    
    # Generate proactive recommendations
    print("\n=== Proactive Recommendations ===")
    recommendations = nlp_system.generate_proactive_recommendations('CUST001')
    for rec in recommendations:
        print(f"Type: {rec['type']} | Priority: {rec['priority']}")
        print(f"Message: {rec['message']}")
        print(f"Action: {rec['action']}")
        print()
    
    # Measure system effectiveness
    print("\n=== NLP System Effectiveness ===")
    metrics = nlp_system.measure_nlp_effectiveness()
    if 'error' not in metrics:
        print(f"Total Interactions: {metrics['total_interactions']}")
        print(f"Average Sentiment: {metrics['average_sentiment_score']:.2f}")
        print(f"Positive Sentiment: {metrics['positive_sentiment_percentage']:.1f}%")
        print(f"Intent Accuracy: {metrics['intent_classification_accuracy']:.1f}%")
        print(f"Personalization Rate: {metrics['response_personalization_rate']:.1f}%")
        print(f"Channel Distribution: {metrics['channel_distribution']}")
    
    return nlp_system

# Run demonstration
if __name__ == "__main__":
    demo_system = run_nlp_customer_experience_demo()

import speech_recognition as sr
import pyttsx3
from transformers import pipeline
import numpy as np
from datetime import datetime
import json
from typing import Dict, List, Optional

class VoiceEnabledCustomerService:
    def __init__(self):
        # Initialize speech recognition and synthesis
        self.recognizer = sr.Recognizer()
        self.tts_engine = pyttsx3.init()
        
        # Configure text-to-speech
        self.tts_engine.setProperty('rate', 150)  # Speed of speech
        self.tts_engine.setProperty('volume', 0.8)  # Volume level
        
        # Initialize NLP components
        self.sentiment_analyzer = pipeline('sentiment-analysis')
        self.intent_classifier = pipeline('zero-shot-classification', 
                                         model='facebook/bart-large-mnli')
        
        # Voice interaction history
        self.voice_interactions = []
        
        # Intent categories for voice interactions
        self.voice_intents = [
            'check_account_balance', 'make_payment', 'report_issue',
            'product_inquiry', 'speak_to_human', 'cancel_service',
            'update_information', 'track_order', 'technical_support'
        ]
        
        # Response templates optimized for voice
        self.voice_responses = {
            'check_account_balance': "Your current account balance is {balance}. Would you like me to email you a detailed statement?",
            'make_payment': "I can help you make a payment. Please provide your payment method or say 'use saved card' to use your default payment method.",
            'report_issue': "I'm sorry to hear you're experiencing an issue. Can you describe the problem you're having?",
            'product_inquiry': "I'd be happy to help you learn about our products. What specific product or service are you interested in?",
            'speak_to_human': "I'll connect you with one of our customer service representatives. Please hold while I transfer your call.",
            'technical_support': "I can help troubleshoot your technical issue. First, can you tell me what device or service you're having trouble with?"
        }
        
    def listen_to_customer(self, timeout: int = 5, phrase_time_limit: int = 10) -> Optional[str]:
        """Listen to customer voice input and convert to text"""
        try:
            with sr.Microphone() as source:
                print("Listening for customer input...")
                # Adjust for ambient noise
                self.recognizer.adjust_for_ambient_noise(source, duration=1)
                
                # Listen for audio input
                audio = self.recognizer.listen(source, timeout=timeout, phrase_time_limit=phrase_time_limit)
                
                # Convert speech to text
                text = self.recognizer.recognize_google(audio)
                print(f"Customer said: {text}")
                return text
                
        except sr.WaitTimeoutError:
            print("No speech detected within timeout period")
            return None
        except sr.UnknownValueError:
            print("Could not understand the audio")
            return None
        except sr.RequestError as e:
            print(f"Error with speech recognition service: {e}")
            return None
            
    def speak_to_customer(self, text: str, voice_name: Optional[str] = None):
        """Convert text response to speech and play it"""
        # Set voice if specified
        if voice_name:
            voices = self.tts_engine.getProperty('voices')
            for voice in voices:
                if voice_name.lower() in voice.name.lower():
                    self.tts_engine.setProperty('voice', voice.id)
                    break
        
        print(f"Assistant: {text}")
        self.tts_engine.say(text)
        self.tts_engine.runAndWait()
        
    def process_voice_interaction(self, customer_id: str = 'VOICE_USER') -> Dict:
        """Complete voice interaction flow"""
        interaction_data = {
            'customer_id': customer_id,
            'timestamp': datetime.now(),
            'channel': 'voice',
            'conversation_turns': []
        }
        
        # Welcome message
        welcome_msg = "Hello! I'm your AI customer service assistant. How can I help you today?"
        self.speak_to_customer(welcome_msg)
        
        max_turns = 5  # Limit conversation length for demo
        turn_count = 0
        
        while turn_count < max_turns:
            turn_count += 1
            
            # Listen to customer
            customer_speech = self.listen_to_customer()
            if not customer_speech:
                if turn_count == 1:
                    self.speak_to_customer("I didn't hear anything. Could you please repeat your question?")
                    continue
                else:
                    self.speak_to_customer("I'm having trouble hearing you. Let me connect you with a human agent.")
                    break
            
            # Analyze customer input
            analysis = self.analyze_voice_input(customer_speech)
            
            # Generate and deliver response
            response = self.generate_voice_response(analysis)
            self.speak_to_customer(response)
            
            # Record conversation turn
            interaction_data['conversation_turns'].append({
                'turn': turn_count,
                'customer_input': customer_speech,
                'analysis': analysis,
                'assistant_response': response
            })
            
            # Check if interaction should end
            if analysis['intent'] in ['speak_to_human', 'end_conversation']:
                break
                
            # Ask if there's anything else
            if turn_count < max_turns:
                follow_up = "Is there anything else I can help you with today?"
                self.speak_to_customer(follow_up)
                
                # Brief pause for response
                additional_input = self.listen_to_customer(timeout=3)
                if not additional_input or any(word in additional_input.lower() for word in ['no', 'nothing', 'that\'s all']):
                    self.speak_to_customer("Thank you for calling. Have a great day!")
                    break
                else:
                    # Continue with additional request
                    turn_count -= 1  # Don't count follow-up question as full turn
                    customer_speech = additional_input
                    continue
        
        # Store interaction
        self.voice_interactions.append(interaction_data)
        return interaction_data
        
    def analyze_voice_input(self, speech_text: str) -> Dict:
        """Analyze voice input for sentiment, intent, and other factors"""
        # Sentiment analysis
        sentiment_result = self.sentiment_analyzer(speech_text)[0]
        
        # Intent classification
        intent_result = self.intent_classifier(speech_text, self.voice_intents)
        
        # Voice-specific analysis
        analysis = {
            'text': speech_text,
            'sentiment': sentiment_result['label'],
            'sentiment_score': sentiment_result['score'],
            'intent': intent_result['labels'][0],
            'intent_confidence': intent_result['scores'][0],
            'word_count': len(speech_text.split()),
            'contains_question': '?' in speech_text or any(word in speech_text.lower() for word in ['what', 'how', 'when', 'where', 'why', 'can you']),
            'urgency_indicators': self._detect_voice_urgency(speech_text)
        }
        
        return analysis
        
    def generate_voice_response(self, analysis: Dict) -> str:
        """Generate appropriate voice response"""
        intent = analysis['intent']
        sentiment = analysis['sentiment']
        
        # Get base response template
        base_response = self.voice_responses.get(intent, 
            "I understand your request. Let me see how I can help you with that.")
        
        # Adapt response based on sentiment
        if sentiment == 'NEGATIVE' and analysis['sentiment_score'] > 0.8:
            if 'sorry' not in base_response.lower():
                base_response = "I apologize for any inconvenience. " + base_response
        
        # Add urgency handling
        if analysis['urgency_indicators']:
            base_response = base_response.replace("I can help", "I'll help you right away")
            base_response = base_response.replace("Let me", "Let me immediately")
        
        # Make response more conversational for voice
        base_response = self._optimize_for_voice(base_response)
        
        return base_response
        
    def _detect_voice_urgency(self, text: str) -> List[str]:
        """Detect urgency indicators in voice input"""
        urgency_phrases = [
            'urgent', 'emergency', 'immediately', 'right now', 'asap',
            'broken', 'not working', 'can\'t access', 'locked out',
            'help me', 'desperate', 'frustrated'
        ]
        
        detected = []
        text_lower = text.lower()
        
        for phrase in urgency_phrases:
            if phrase in text_lower:
                detected.append(phrase)
                
        return detected
        
    def _optimize_for_voice(self, text: str) -> str:
        """Optimize text response for voice delivery"""
        # Make more conversational
        text = text.replace('&', 'and')
        text = text.replace('%', 'percent')
        text = text.replace('$', 'dollars')
        
        # Add natural pauses
        text = text.replace('. ', '. ... ')
        text = text.replace('? ', '? ... ')
        
        # Simplify complex sentences
        if len(text.split()) > 25:  # Long sentence
            sentences = text.split('. ')
            if len(sentences) > 1:
                text = '. '.join(sentences[:2]) + '.'  # Take first two sentences
        
        return text
        
    def get_voice_interaction_analytics(self) -> Dict:
        """Analyze voice interaction patterns and performance"""
        if not self.voice_interactions:
            return {'error': 'No voice interactions recorded'}
            
        analytics = {
            'total_interactions': len(self.voice_interactions),
            'average_turns_per_interaction': np.mean([len(i['conversation_turns']) for i in self.voice_interactions]),
            'most_common_intents': self._get_intent_distribution(),
            'sentiment_distribution': self._get_sentiment_distribution(),
            'average_interaction_duration': self._estimate_interaction_duration(),
            'success_indicators': self._calculate_success_metrics()
        }
        
        return analytics
        
    def _get_intent_distribution(self) -> Dict:
        """Get distribution of intents in voice interactions"""
        all_intents = []
        for interaction in self.voice_interactions:
            for turn in interaction['conversation_turns']:
                all_intents.append(turn['analysis']['intent'])
                
        intent_counts = {}
        for intent in all_intents:
            intent_counts[intent] = intent_counts.get(intent, 0) + 1
            
        return intent_counts
        
    def _get_sentiment_distribution(self) -> Dict:
        """Get sentiment distribution across voice interactions"""
        sentiments = []
        for interaction in self.voice_interactions:
            for turn in interaction['conversation_turns']:
                sentiments.append(turn['analysis']['sentiment'])
                
        sentiment_counts = {}
        for sentiment in sentiments:
            sentiment_counts[sentiment] = sentiment_counts.get(sentiment, 0) + 1
            
        return sentiment_counts
        
    def _estimate_interaction_duration(self) -> float:
        """Estimate average interaction duration in minutes"""
        # Rough estimate: 2 seconds per word spoken + processing time
        total_words = 0
        total_turns = 0
        
        for interaction in self.voice_interactions:
            for turn in interaction['conversation_turns']:
                total_words += turn['analysis']['word_count']
                total_words += len(turn['assistant_response'].split())
                total_turns += 1
                
        if total_turns == 0:
            return 0
            
        # Estimate: 2 seconds per word + 3 seconds processing per turn
        estimated_seconds = (total_words * 2) + (total_turns * 3)
        return estimated_seconds / 60  # Convert to minutes
        
    def _calculate_success_metrics(self) -> Dict:
        """Calculate success metrics for voice interactions"""
        if not self.voice_interactions:
            return {}
            
        total_interactions = len(self.voice_interactions)
        human_transfers = sum(1 for i in self.voice_interactions 
                            if any(turn['analysis']['intent'] == 'speak_to_human' 
                                 for turn in i['conversation_turns']))
        
        positive_sentiment_turns = 0
        total_turns = 0
        
        for interaction in self.voice_interactions:
            for turn in interaction['conversation_turns']:
                if turn['analysis']['sentiment'] == 'POSITIVE':
                    positive_sentiment_turns += 1
                total_turns += 1
        
        return {
            'human_transfer_rate': (human_transfers / total_interactions) * 100,
            'positive_sentiment_rate': (positive_sentiment_turns / total_turns) * 100 if total_turns > 0 else 0,
            'completion_rate': ((total_interactions - human_transfers) / total_interactions) * 100
        }

# Example usage (Note: Requires microphone and speakers for actual voice interaction)
def run_voice_service_demo():
    print("=== Voice-Enabled Customer Service Demo ===")
    print("Note: This demo requires a microphone and speakers for full functionality")
    
    voice_service = VoiceEnabledCustomerService()
    
    # Simulate voice interaction analysis (without actual audio)
    sample_voice_inputs = [
        "I need to check my account balance",
        "I'm having trouble with my internet connection and it's really frustrating",
        "Can you help me make a payment?",
        "I want to speak to a human representative please"
    ]
    
    print("\nAnalyzing sample voice inputs:")
    for i, voice_input in enumerate(sample_voice_inputs, 1):
        analysis = voice_service.analyze_voice_input(voice_input)
        response = voice_service.generate_voice_response(analysis)
        
        print(f"\n{i}. Customer: {voice_input}")
        print(f"   Intent: {analysis['intent']} (confidence: {analysis['intent_confidence']:.2f})")
        print(f"   Sentiment: {analysis['sentiment']} (score: {analysis['sentiment_score']:.2f})")
        print(f"   Assistant: {response}")
    
    # Uncomment the following line to run actual voice interaction
    # interaction_data = voice_service.process_voice_interaction()
    
    return voice_service

# Run demonstration
if __name__ == "__main__":
    voice_demo = run_voice_service_demo()