sentiment_analyzer.py

"""
SentilensAI - Advanced Sentiment Analysis for AI Chatbot Messages

This module provides comprehensive sentiment analysis capabilities specifically designed
for analyzing AI chatbot conversations using LangChain integration and multiple ML models.

Features:
- Multi-model sentiment analysis (VADER, TextBlob, spaCy, Transformers)
- LangChain integration for intelligent conversation analysis
- Real-time sentiment tracking for chatbot interactions
- Advanced emotion detection and classification
- Context-aware sentiment analysis for conversational AI

Author: Pravin Selvamuthu
Repository: https://github.com/kernelseed/sentilens-ai
"""

import re
import json
import logging
from typing import Dict, List, Tuple, Optional, Union, Any
from datetime import datetime
from dataclasses import dataclass
from pathlib import Path

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
import joblib

# NLP Libraries
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.stem import WordNetLemmatizer
from textblob import TextBlob
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

# LangChain Integration
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain_community.llms import OpenAI
from langchain_core.callbacks import BaseCallbackHandler
from langchain_core.output_parsers import BaseOutputParser

# Transformers for advanced sentiment analysis
try:
    from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
    import torch
    TRANSFORMERS_AVAILABLE = True
except ImportError:
    TRANSFORMERS_AVAILABLE = False

# Multilingual support
try:
    from multilingual_sentiment import MultilingualSentimentAnalyzer, MultilingualSentimentResult
    MULTILINGUAL_AVAILABLE = True
except ImportError:
    MULTILINGUAL_AVAILABLE = False

# spaCy for advanced NLP
try:
    import spacy
    SPACY_AVAILABLE = True
except ImportError:
    SPACY_AVAILABLE = False

# Download required NLTK data
try:
    nltk.download('punkt', quiet=True)
    nltk.download('stopwords', quiet=True)
    nltk.download('wordnet', quiet=True)
    nltk.download('vader_lexicon', quiet=True)
except:
    pass

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


@dataclass
class SentimentResult:
    """Data class for sentiment analysis results"""
    text: str
    sentiment: str  # positive, negative, neutral
    confidence: float
    polarity: float  # -1 to 1
    subjectivity: float  # 0 to 1
    emotions: Dict[str, float]
    timestamp: datetime
    model_used: str
    metadata: Dict[str, Any]


@dataclass
class ChatbotMessage:
    """Data class for chatbot message analysis"""
    message_id: str
    user_message: str
    bot_response: str
    timestamp: datetime
    conversation_id: str
    user_sentiment: SentimentResult
    bot_sentiment: SentimentResult
    conversation_sentiment: str
    satisfaction_score: float


class SentimentOutputParser(BaseOutputParser):
    """Custom output parser for LangChain sentiment analysis"""
    
    def parse(self, text: str) -> Dict[str, Any]:
        """Parse sentiment analysis output from LLM"""
        try:
            # Try to parse as JSON first
            if text.strip().startswith('{'):
                return json.loads(text)
            
            # Extract sentiment information using regex
            sentiment_match = re.search(r'sentiment["\']?\s*:\s*["\']?(\w+)', text, re.IGNORECASE)
            confidence_match = re.search(r'confidence["\']?\s*:\s*([0-9.]+)', text, re.IGNORECASE)
            polarity_match = re.search(r'polarity["\']?\s*:\s*([-0-9.]+)', text, re.IGNORECASE)
            
            result = {
                'sentiment': sentiment_match.group(1).lower() if sentiment_match else 'neutral',
                'confidence': float(confidence_match.group(1)) if confidence_match else 0.5,
                'polarity': float(polarity_match.group(1)) if polarity_match else 0.0,
                'raw_output': text
            }
            
            return result
        except Exception as e:
            logger.warning(f"Failed to parse sentiment output: {e}")
            return {
                'sentiment': 'neutral',
                'confidence': 0.5,
                'polarity': 0.0,
                'raw_output': text
            }


class SentilensAIAnalyzer:
    """
    Advanced sentiment analysis for AI chatbot messages using multiple models and LangChain
    """
    
    def __init__(self, openai_api_key: Optional[str] = None, model_cache_dir: str = "./model_cache", 
                 enable_multilingual: bool = True):
        """
        Initialize the SentimentsAI analyzer
        
        Args:
            openai_api_key: OpenAI API key for LangChain integration
            model_cache_dir: Directory to cache downloaded models
            enable_multilingual: Enable multilingual support for English, Spanish, and Chinese
        """
        self.model_cache_dir = Path(model_cache_dir)
        self.model_cache_dir.mkdir(exist_ok=True)
        
        # Multilingual support
        self.enable_multilingual = enable_multilingual and MULTILINGUAL_AVAILABLE
        if self.enable_multilingual:
            try:
                self.multilingual_analyzer = MultilingualSentimentAnalyzer()
                logger.info("✅ Multilingual support enabled (English, Spanish, Chinese)")
            except Exception as e:
                logger.warning(f"Failed to initialize multilingual analyzer: {e}")
                self.enable_multilingual = False
        else:
            self.multilingual_analyzer = None
        
        # Initialize sentiment analyzers
        self.vader_analyzer = SentimentIntensityAnalyzer()
        self.lemmatizer = WordNetLemmatizer()
        
        # Load stopwords
        try:
            self.stop_words = set(stopwords.words('english'))
        except:
            self.stop_words = set()
        
        # Initialize spaCy model
        self.spacy_model = None
        if SPACY_AVAILABLE:
            try:
                self.spacy_model = spacy.load("en_core_web_sm")
            except OSError:
                logger.warning("spaCy model 'en_core_web_sm' not found. Install with: python -m spacy download en_core_web_sm")
        
        # Initialize transformers pipeline
        self.transformers_pipeline = None
        if TRANSFORMERS_AVAILABLE:
            try:
                self.transformers_pipeline = pipeline(
                    "sentiment-analysis",
                    model="cardiffnlp/twitter-roberta-base-sentiment-latest",
                    cache_dir=self.model_cache_dir
                )
            except Exception as e:
                logger.warning(f"Failed to load transformers pipeline: {e}")
        
        # Initialize LangChain components
        self.llm = None
        self.sentiment_chain = None
        if openai_api_key:
            try:
                self.llm = OpenAI(api_key=openai_api_key, temperature=0.1)
                self._setup_langchain_components()
            except Exception as e:
                logger.warning(f"Failed to initialize OpenAI LLM: {e}")
        
        # Emotion detection patterns
        self.emotion_patterns = {
            'joy': [r'\b(happy|joy|excited|great|wonderful|amazing|fantastic|love|adore)\b'],
            'sadness': [r'\b(sad|depressed|upset|disappointed|hurt|grief|sorrow)\b'],
            'anger': [r'\b(angry|mad|furious|rage|annoyed|irritated|frustrated)\b'],
            'fear': [r'\b(scared|afraid|worried|anxious|nervous|terrified|panic)\b'],
            'surprise': [r'\b(surprised|shocked|amazed|wow|incredible|unbelievable)\b'],
            'disgust': [r'\b(disgusted|revolted|sick|gross|nasty|awful|terrible)\b']
        }
    
    def _setup_langchain_components(self):
        """Setup LangChain components for sentiment analysis"""
        if not self.llm:
            return
        
        # Create sentiment analysis prompt template
        sentiment_prompt = PromptTemplate(
            input_variables=["text", "context"],
            template="""
            Analyze the sentiment of the following text from an AI chatbot conversation.
            Consider the context of the conversation and provide a detailed sentiment analysis.
            
            Text: "{text}"
            Context: "{context}"
            
            Please provide your analysis in the following JSON format:
            {{
                "sentiment": "positive|negative|neutral",
                "confidence": 0.0-1.0,
                "polarity": -1.0 to 1.0,
                "reasoning": "Brief explanation of your analysis",
                "emotions": {{
                    "joy": 0.0-1.0,
                    "sadness": 0.0-1.0,
                    "anger": 0.0-1.0,
                    "fear": 0.0-1.0,
                    "surprise": 0.0-1.0,
                    "disgust": 0.0-1.0
                }}
            }}
            """
        )
        
        # Create the sentiment analysis chain
        self.sentiment_chain = LLMChain(
            llm=self.llm,
            prompt=sentiment_prompt,
            output_parser=SentimentOutputParser()
        )
    
    def preprocess_text(self, text: str) -> str:
        """
        Preprocess text for sentiment analysis
        
        Args:
            text: Input text to preprocess
            
        Returns:
            Preprocessed text
        """
        if not text:
            return ""
        
        # Convert to lowercase
        text = text.lower()
        
        # Remove URLs, mentions, and hashtags
        text = re.sub(r'http\S+|www\S+|https\S+', '', text, flags=re.MULTILINE)
        text = re.sub(r'@\w+|#\w+', '', text)
        
        # Remove extra whitespace
        text = re.sub(r'\s+', ' ', text).strip()
        
        # Remove special characters but keep basic punctuation
        text = re.sub(r'[^\w\s\.\!\?\,\;\:]', '', text)
        
        return text
    
    def extract_emotions(self, text: str) -> Dict[str, float]:
        """
        Extract emotion scores from text using pattern matching
        
        Args:
            text: Input text
            
        Returns:
            Dictionary of emotion scores
        """
        emotions = {emotion: 0.0 for emotion in self.emotion_patterns.keys()}
        
        for emotion, patterns in self.emotion_patterns.items():
            for pattern in patterns:
                matches = re.findall(pattern, text, re.IGNORECASE)
                emotions[emotion] += len(matches) * 0.1  # Simple scoring
        
        # Normalize scores
        total_score = sum(emotions.values())
        if total_score > 0:
            emotions = {k: min(v / total_score, 1.0) for k, v in emotions.items()}
        
        return emotions
    
    def analyze_with_vader(self, text: str) -> Dict[str, Any]:
        """Analyze sentiment using VADER"""
        scores = self.vader_analyzer.polarity_scores(text)
        
        # Determine sentiment
        if scores['compound'] >= 0.05:
            sentiment = 'positive'
        elif scores['compound'] <= -0.05:
            sentiment = 'negative'
        else:
            sentiment = 'neutral'
        
        return {
            'sentiment': sentiment,
            'confidence': abs(scores['compound']),
            'polarity': scores['compound'],
            'subjectivity': 0.5,  # VADER doesn't provide subjectivity
            'scores': scores
        }
    
    def analyze_with_textblob(self, text: str) -> Dict[str, Any]:
        """Analyze sentiment using TextBlob"""
        blob = TextBlob(text)
        
        # Determine sentiment
        if blob.sentiment.polarity > 0.1:
            sentiment = 'positive'
        elif blob.sentiment.polarity < -0.1:
            sentiment = 'negative'
        else:
            sentiment = 'neutral'
        
        return {
            'sentiment': sentiment,
            'confidence': abs(blob.sentiment.polarity),
            'polarity': blob.sentiment.polarity,
            'subjectivity': blob.sentiment.subjectivity
        }
    
    def analyze_with_spacy(self, text: str) -> Dict[str, Any]:
        """Analyze sentiment using spaCy (if available)"""
        if not self.spacy_model:
            return self.analyze_with_textblob(text)  # Fallback
        
        doc = self.spacy_model(text)
        
        # Simple sentiment analysis using spaCy's token attributes
        positive_words = 0
        negative_words = 0
        total_words = 0
        
        for token in doc:
            if not token.is_stop and not token.is_punct and token.is_alpha:
                total_words += 1
                # Simple heuristic based on word sentiment
                if token.lemma_.lower() in ['good', 'great', 'excellent', 'amazing', 'wonderful']:
                    positive_words += 1
                elif token.lemma_.lower() in ['bad', 'terrible', 'awful', 'horrible', 'worst']:
                    negative_words += 1
        
        if total_words == 0:
            polarity = 0.0
        else:
            polarity = (positive_words - negative_words) / total_words
        
        # Determine sentiment
        if polarity > 0.1:
            sentiment = 'positive'
        elif polarity < -0.1:
            sentiment = 'negative'
        else:
            sentiment = 'neutral'
        
        return {
            'sentiment': sentiment,
            'confidence': abs(polarity),
            'polarity': polarity,
            'subjectivity': 0.5  # spaCy doesn't provide subjectivity
        }
    
    def analyze_with_transformers(self, text: str) -> Dict[str, Any]:
        """Analyze sentiment using Transformers (if available)"""
        if not self.transformers_pipeline:
            return self.analyze_with_textblob(text)  # Fallback
        
        try:
            result = self.transformers_pipeline(text)[0]
            
            # Map transformer labels to our format
            label_mapping = {
                'LABEL_0': 'negative',
                'LABEL_1': 'neutral', 
                'LABEL_2': 'positive'
            }
            
            sentiment = label_mapping.get(result['label'], 'neutral')
            confidence = result['score']
            
            # Estimate polarity from confidence and sentiment
            if sentiment == 'positive':
                polarity = confidence
            elif sentiment == 'negative':
                polarity = -confidence
            else:
                polarity = 0.0
            
            return {
                'sentiment': sentiment,
                'confidence': confidence,
                'polarity': polarity,
                'subjectivity': 0.5  # Transformers don't provide subjectivity
            }
        except Exception as e:
            logger.warning(f"Transformers analysis failed: {e}")
            return self.analyze_with_textblob(text)  # Fallback
    
    def analyze_with_langchain(self, text: str, context: str = "") -> Dict[str, Any]:
        """Analyze sentiment using LangChain and LLM"""
        if not self.sentiment_chain:
            return self.analyze_with_textblob(text)  # Fallback
        
        try:
            result = self.sentiment_chain.run(text=text, context=context)
            
            # Ensure we have the required fields
            if not isinstance(result, dict):
                result = {'sentiment': 'neutral', 'confidence': 0.5, 'polarity': 0.0}
            
            # Validate and normalize the result
            sentiment = result.get('sentiment', 'neutral')
            if sentiment not in ['positive', 'negative', 'neutral']:
                sentiment = 'neutral'
            
            confidence = max(0.0, min(1.0, float(result.get('confidence', 0.5))))
            polarity = max(-1.0, min(1.0, float(result.get('polarity', 0.0))))
            
            # Extract emotions if available
            emotions = result.get('emotions', {})
            if not isinstance(emotions, dict):
                emotions = self.extract_emotions(text)
            
            return {
                'sentiment': sentiment,
                'confidence': confidence,
                'polarity': polarity,
                'subjectivity': 0.5,  # LLM doesn't provide subjectivity
                'emotions': emotions,
                'reasoning': result.get('reasoning', '')
            }
        except Exception as e:
            logger.warning(f"LangChain analysis failed: {e}")
            return self.analyze_with_textblob(text)  # Fallback
    
    def analyze_sentiment(self, text: str, method: str = 'ensemble', context: str = "") -> SentimentResult:
        """
        Analyze sentiment using specified method
        
        Args:
            text: Text to analyze
            method: Analysis method ('vader', 'textblob', 'spacy', 'transformers', 'langchain', 'ensemble')
            context: Additional context for analysis
            
        Returns:
            SentimentResult object
        """
        if not text or not text.strip():
            return SentimentResult(
                text=text,
                sentiment='neutral',
                confidence=0.0,
                polarity=0.0,
                subjectivity=0.0,
                emotions={},
                timestamp=datetime.now(),
                model_used=method,
                metadata={}
            )
        
        # Preprocess text
        processed_text = self.preprocess_text(text)
        
        if method == 'ensemble':
            # Use ensemble of all available methods
            results = []
            
            # VADER
            vader_result = self.analyze_with_vader(processed_text)
            results.append(vader_result)
            
            # TextBlob
            textblob_result = self.analyze_with_textblob(processed_text)
            results.append(textblob_result)
            
            # spaCy
            spacy_result = self.analyze_with_spacy(processed_text)
            results.append(spacy_result)
            
            # Transformers
            if self.transformers_pipeline:
                transformers_result = self.analyze_with_transformers(processed_text)
                results.append(transformers_result)
            
            # LangChain
            if self.sentiment_chain:
                langchain_result = self.analyze_with_langchain(processed_text, context)
                results.append(langchain_result)
            
            # Ensemble voting
            sentiment_votes = [r['sentiment'] for r in results]
            sentiment_counts = {s: sentiment_votes.count(s) for s in set(sentiment_votes)}
            final_sentiment = max(sentiment_counts, key=sentiment_counts.get)
            
            # Average confidence and polarity
            avg_confidence = np.mean([r['confidence'] for r in results])
            avg_polarity = np.mean([r['polarity'] for r in results])
            avg_subjectivity = np.mean([r.get('subjectivity', 0.5) for r in results])
            
            # Combine emotions
            all_emotions = {}
            for result in results:
                if 'emotions' in result:
                    for emotion, score in result['emotions'].items():
                        all_emotions[emotion] = all_emotions.get(emotion, 0) + score
            emotions = {k: v / len(results) for k, v in all_emotions.items()}
            
            if not emotions:
                emotions = self.extract_emotions(processed_text)
            
            final_result = {
                'sentiment': final_sentiment,
                'confidence': avg_confidence,
                'polarity': avg_polarity,
                'subjectivity': avg_subjectivity,
                'emotions': emotions
            }
            
        else:
            # Use specific method
            if method == 'vader':
                final_result = self.analyze_with_vader(processed_text)
            elif method == 'textblob':
                final_result = self.analyze_with_textblob(processed_text)
            elif method == 'spacy':
                final_result = self.analyze_with_spacy(processed_text)
            elif method == 'transformers':
                final_result = self.analyze_with_transformers(processed_text)
            elif method == 'langchain':
                final_result = self.analyze_with_langchain(processed_text, context)
            else:
                raise ValueError(f"Unknown method: {method}")
            
            # Extract emotions if not provided
            if 'emotions' not in final_result:
                final_result['emotions'] = self.extract_emotions(processed_text)
        
        return SentimentResult(
            text=text,
            sentiment=final_result['sentiment'],
            confidence=final_result['confidence'],
            polarity=final_result['polarity'],
            subjectivity=final_result.get('subjectivity', 0.5),
            emotions=final_result['emotions'],
            timestamp=datetime.now(),
            model_used=method,
            metadata=final_result
        )
    
    def analyze_sentiment_multilingual(self, text: str, target_language: Optional[str] = None,
                                     enable_cross_language: bool = False) -> MultilingualSentimentResult:
        """
        Analyze sentiment with multilingual support (English, Spanish, Chinese)
        
        Args:
            text: Text to analyze
            target_language: Specific language to use ('en', 'es', 'zh') or None for auto-detection
            enable_cross_language: Enable cross-language consensus analysis
            
        Returns:
            MultilingualSentimentResult object
        """
        if not self.enable_multilingual or not self.multilingual_analyzer:
            # Fallback to regular analysis
            regular_result = self.analyze_sentiment(text, method='ensemble')
            return MultilingualSentimentResult(
                text=text,
                detected_language='en',
                language_confidence=0.5,
                sentiment=regular_result.sentiment,
                confidence=regular_result.confidence,
                emotions=regular_result.emotions,
                methods_used=[regular_result.model_used],
                language_specific_analysis={'fallback': True}
            )
        
        return self.multilingual_analyzer.analyze_sentiment_multilingual(
            text, target_language, enable_cross_language
        )
    
    def analyze_conversation_multilingual(self, conversation: Dict[str, Any]) -> Dict[str, Any]:
        """
        Analyze a conversation with multilingual support
        
        Args:
            conversation: Conversation dictionary with messages
            
        Returns:
            Dictionary with multilingual analysis results
        """
        if not self.enable_multilingual or not self.multilingual_analyzer:
            # Fallback to regular analysis
            messages = conversation.get('messages', [])
            regular_results = []
            for msg in messages:
                user_text = msg.get('user', '')
                bot_text = msg.get('bot', '')
                if user_text:
                    regular_results.append(self.analyze_sentiment(user_text))
                if bot_text:
                    regular_results.append(self.analyze_sentiment(bot_text))
            return {'fallback': True, 'results': regular_results}
        
        return self.multilingual_analyzer.analyze_conversation_multilingual(conversation)
    
    def get_supported_languages(self) -> List[str]:
        """Get list of supported languages for multilingual analysis"""
        if self.enable_multilingual and self.multilingual_analyzer:
            return self.multilingual_analyzer.get_supported_languages()
        return ['en']  # Default to English only
    
    def get_language_name(self, language_code: str) -> str:
        """Get human-readable language name"""
        if self.enable_multilingual and self.multilingual_analyzer:
            return self.multilingual_analyzer.get_language_name(language_code)
        return {'en': 'English'}.get(language_code, language_code)
    
    def analyze_chatbot_conversation(self, messages: List[Dict[str, Any]]) -> List[ChatbotMessage]:
        """
        Analyze a complete chatbot conversation
        
        Args:
            messages: List of message dictionaries with 'user', 'bot', 'timestamp', 'conversation_id'
            
        Returns:
            List of ChatbotMessage objects
        """
        results = []
        
        for i, msg in enumerate(messages):
            user_text = msg.get('user', '')
            bot_text = msg.get('bot', '')
            timestamp = msg.get('timestamp', datetime.now())
            conversation_id = msg.get('conversation_id', f'conv_{i}')
            message_id = msg.get('message_id', f'{conversation_id}_{i}')
            
            # Analyze user message
            user_sentiment = self.analyze_sentiment(user_text, method='ensemble')
            
            # Analyze bot response
            bot_sentiment = self.analyze_sentiment(bot_text, method='ensemble', context=user_text)
            
            # Determine overall conversation sentiment
            if user_sentiment.sentiment == bot_sentiment.sentiment:
                conversation_sentiment = user_sentiment.sentiment
            else:
                # Use weighted average based on confidence
                user_weight = user_sentiment.confidence
                bot_weight = bot_sentiment.confidence
                total_weight = user_weight + bot_weight
                
                if total_weight > 0:
                    user_polarity_weighted = user_sentiment.polarity * (user_weight / total_weight)
                    bot_polarity_weighted = bot_sentiment.polarity * (bot_weight / total_weight)
                    combined_polarity = user_polarity_weighted + bot_polarity_weighted
                    
                    if combined_polarity > 0.1:
                        conversation_sentiment = 'positive'
                    elif combined_polarity < -0.1:
                        conversation_sentiment = 'negative'
                    else:
                        conversation_sentiment = 'neutral'
                else:
                    conversation_sentiment = 'neutral'
            
            # Calculate satisfaction score (0-1)
            satisfaction_score = self._calculate_satisfaction_score(user_sentiment, bot_sentiment)
            
            chatbot_message = ChatbotMessage(
                message_id=message_id,
                user_message=user_text,
                bot_response=bot_text,
                timestamp=timestamp,
                conversation_id=conversation_id,
                user_sentiment=user_sentiment,
                bot_sentiment=bot_sentiment,
                conversation_sentiment=conversation_sentiment,
                satisfaction_score=satisfaction_score
            )
            
            results.append(chatbot_message)
        
        return results
    
    def _calculate_satisfaction_score(self, user_sentiment: SentimentResult, bot_sentiment: SentimentResult) -> float:
        """Calculate satisfaction score based on sentiment alignment"""
        # Base score from user sentiment
        base_score = (user_sentiment.polarity + 1) / 2  # Convert -1,1 to 0,1
        
        # Adjust based on bot response sentiment
        if user_sentiment.sentiment == 'positive' and bot_sentiment.sentiment == 'positive':
            adjustment = 0.2
        elif user_sentiment.sentiment == 'negative' and bot_sentiment.sentiment == 'positive':
            adjustment = 0.3  # Bot being positive to negative user is good
        elif user_sentiment.sentiment == 'neutral' and bot_sentiment.sentiment == 'positive':
            adjustment = 0.1
        else:
            adjustment = -0.1
        
        # Factor in confidence
        confidence_factor = (user_sentiment.confidence + bot_sentiment.confidence) / 2
        
        final_score = base_score + adjustment
        final_score = max(0.0, min(1.0, final_score))  # Clamp to 0-1
        
        return final_score * confidence_factor
    
    def get_sentiment_summary(self, results: List[SentimentResult]) -> Dict[str, Any]:
        """Get summary statistics for sentiment analysis results"""
        if not results:
            return {}
        
        sentiments = [r.sentiment for r in results]
        confidences = [r.confidence for r in results]
        polarities = [r.polarity for r in results]
        
        sentiment_counts = {s: sentiments.count(s) for s in set(sentiments)}
        total = len(sentiments)
        
        return {
            'total_messages': total,
            'sentiment_distribution': {k: v/total for k, v in sentiment_counts.items()},
            'average_confidence': np.mean(confidences),
            'average_polarity': np.mean(polarities),
            'sentiment_trend': sentiments,
            'confidence_trend': confidences,
            'polarity_trend': polarities
        }
    
    def export_results(self, results: List[Union[SentimentResult, ChatbotMessage]], 
                      filename: str, format: str = 'json') -> str:
        """
        Export analysis results to file
        
        Args:
            results: List of analysis results
            filename: Output filename
            format: Export format ('json', 'csv', 'excel')
            
        Returns:
            Path to exported file
        """
        output_path = Path(filename)
        
        if format == 'json':
            # Convert results to dictionaries
            data = []
            for result in results:
                if isinstance(result, SentimentResult):
                    data.append({
                        'text': result.text,
                        'sentiment': result.sentiment,
                        'confidence': result.confidence,
                        'polarity': result.polarity,
                        'subjectivity': result.subjectivity,
                        'emotions': result.emotions,
                        'timestamp': result.timestamp.isoformat(),
                        'model_used': result.model_used
                    })
                elif isinstance(result, ChatbotMessage):
                    data.append({
                        'message_id': result.message_id,
                        'user_message': result.user_message,
                        'bot_response': result.bot_response,
                        'timestamp': result.timestamp.isoformat(),
                        'conversation_id': result.conversation_id,
                        'user_sentiment': result.user_sentiment.sentiment,
                        'user_confidence': result.user_sentiment.confidence,
                        'user_polarity': result.user_sentiment.polarity,
                        'bot_sentiment': result.bot_sentiment.sentiment,
                        'bot_confidence': result.bot_sentiment.confidence,
                        'bot_polarity': result.bot_sentiment.polarity,
                        'conversation_sentiment': result.conversation_sentiment,
                        'satisfaction_score': result.satisfaction_score
                    })
            
            with open(output_path, 'w', encoding='utf-8') as f:
                json.dump(data, f, indent=2, ensure_ascii=False)
        
        elif format == 'csv':
            # Convert to DataFrame and save as CSV
            data = []
            for result in results:
                if isinstance(result, SentimentResult):
                    data.append({
                        'text': result.text,
                        'sentiment': result.sentiment,
                        'confidence': result.confidence,
                        'polarity': result.polarity,
                        'subjectivity': result.subjectivity,
                        'timestamp': result.timestamp.isoformat(),
                        'model_used': result.model_used
                    })
                elif isinstance(result, ChatbotMessage):
                    data.append({
                        'message_id': result.message_id,
                        'user_message': result.user_message,
                        'bot_response': result.bot_response,
                        'timestamp': result.timestamp.isoformat(),
                        'conversation_id': result.conversation_id,
                        'user_sentiment': result.user_sentiment.sentiment,
                        'user_confidence': result.user_sentiment.confidence,
                        'bot_sentiment': result.bot_sentiment.sentiment,
                        'bot_confidence': result.bot_sentiment.confidence,
                        'conversation_sentiment': result.conversation_sentiment,
                        'satisfaction_score': result.satisfaction_score
                    })
            
            df = pd.DataFrame(data)
            df.to_csv(output_path, index=False, encoding='utf-8')
        
        elif format == 'excel':
            # Convert to DataFrame and save as Excel
            data = []
            for result in results:
                if isinstance(result, SentimentResult):
                    data.append({
                        'text': result.text,
                        'sentiment': result.sentiment,
                        'confidence': result.confidence,
                        'polarity': result.polarity,
                        'subjectivity': result.subjectivity,
                        'timestamp': result.timestamp.isoformat(),
                        'model_used': result.model_used
                    })
                elif isinstance(result, ChatbotMessage):
                    data.append({
                        'message_id': result.message_id,
                        'user_message': result.user_message,
                        'bot_response': result.bot_response,
                        'timestamp': result.timestamp.isoformat(),
                        'conversation_id': result.conversation_id,
                        'user_sentiment': result.user_sentiment.sentiment,
                        'user_confidence': result.user_sentiment.confidence,
                        'bot_sentiment': result.bot_sentiment.sentiment,
                        'bot_confidence': result.bot_sentiment.confidence,
                        'conversation_sentiment': result.conversation_sentiment,
                        'satisfaction_score': result.satisfaction_score
                    })
            
            df = pd.DataFrame(data)
            df.to_excel(output_path, index=False, engine='openpyxl')
        
        else:
            raise ValueError(f"Unsupported format: {format}")
        
        return str(output_path)


def main():
    """Demo function to showcase SentimentsAI capabilities"""
    print("🤖 SentilensAI - Advanced Sentiment Analysis for AI Chatbot Messages")
    print("=" * 70)
    
    # Initialize analyzer
    analyzer = SentilensAIAnalyzer()
    
    # Sample chatbot messages
    sample_messages = [
        {
            'user': 'I love this chatbot! It\'s so helpful and friendly.',
            'bot': 'Thank you so much! I\'m thrilled to hear that you\'re having a great experience. Is there anything else I can help you with today?',
            'timestamp': datetime.now(),
            'conversation_id': 'demo_001'
        },
        {
            'user': 'This is terrible. The bot keeps giving me wrong answers.',
            'bot': 'I apologize for the confusion. Let me help you get the correct information. Could you please provide more details about what you\'re looking for?',
            'timestamp': datetime.now(),
            'conversation_id': 'demo_002'
        },
        {
            'user': 'Can you help me with my account balance?',
            'bot': 'Of course! I\'d be happy to help you check your account balance. Please provide your account number or login credentials.',
            'timestamp': datetime.now(),
            'conversation_id': 'demo_003'
        }
    ]
    
    print("\n📊 Analyzing sample chatbot conversations...")
    
    # Analyze conversations
    results = analyzer.analyze_chatbot_conversation(sample_messages)
    
    # Display results
    for i, result in enumerate(results, 1):
        print(f"\n--- Conversation {i} ---")
        print(f"User: {result.user_message}")
        print(f"Bot: {result.bot_response}")
        print(f"User Sentiment: {result.user_sentiment.sentiment} (confidence: {result.user_sentiment.confidence:.2f})")
        print(f"Bot Sentiment: {result.bot_sentiment.sentiment} (confidence: {result.bot_sentiment.confidence:.2f})")
        print(f"Conversation Sentiment: {result.conversation_sentiment}")
        print(f"Satisfaction Score: {result.satisfaction_score:.2f}")
    
    # Get summary
    sentiment_results = [r.user_sentiment for r in results] + [r.bot_sentiment for r in results]
    summary = analyzer.get_sentiment_summary(sentiment_results)
    
    print(f"\n📈 Summary Statistics:")
    print(f"Total Messages: {summary['total_messages']}")
    print(f"Sentiment Distribution: {summary['sentiment_distribution']}")
    print(f"Average Confidence: {summary['average_confidence']:.2f}")
    print(f"Average Polarity: {summary['average_polarity']:.2f}")
    
    # Export results
    output_file = analyzer.export_results(results, 'sentiment_analysis_results.json', 'json')
    print(f"\n💾 Results exported to: {output_file}")
    
    print("\n✅ SentilensAI demo completed successfully!")
    print("🚀 Ready for production use with LangChain and ML models!")


if __name__ == "__main__":
    main()