# Imagine this code is inside another agent's function
from app.agents.sentiment_analysis import get_sentiment_analyzer

# 1. Get the Sentiment Analyzer instance
sentiment_analyzer = get_sentiment_analyzer()

# 2. Call the method to get an overview (it uses the Data Pipeline internally)
sentiment_overview = sentiment_analyzer.get_sentiment_overview()

# 3. The 'sentiment_overview' dictionary now holds the results!
print(sentiment_overview)

# Using the same sentiment_analyzer object...

# A list of text strings you want to analyze
texts_to_check = [
    "The screen is vibrant, but the trackpad is awful.",
    "Just got it, seems okay.",
    "Best laptop I've ever owned!"
]

# Call the method to analyze sentiment for these specific texts
results = sentiment_analyzer.analyze_sentiment(texts_to_check)

# 'results' will be a list with a sentiment label and score for each text
print(results)

# ... inside app/agents/sentiment_analysis.py ...
from transformers import pipeline # Tool to easily use pre-trained models
from app.agents.data_pipeline import get_data_pipeline # To get data

# Name of the pre-trained AI model we want to use
SENTIMENT_MODEL = "distilbert-base-uncased-finetuned-sst-2-english"

class SentimentAnalyzer:
    def __init__(self):
        self.sentiment_analyzer = None # This will hold the AI model tool
        self.data_pipeline = None      # This will hold the Data Pipeline tool

        # Try to load the AI model
        self._initialize_sentiment_analyzer()

        # Get access to the Data Pipeline
        try:
            self.data_pipeline = get_data_pipeline()
            # logger.info(...) # Log success
        except Exception as e:
            # logger.error(...) # Log error
            pass # Data pipeline might not be critical for *all* methods

    def _initialize_sentiment_analyzer(self):
        """Initialize the sentiment analysis model."""
        try:
            # Use the 'pipeline' tool from transformers
            # This downloads the specified model if you don't have it
            self.sentiment_analyzer = pipeline(
                "sentiment-analysis",
                model=SENTIMENT_MODEL,
                return_all_scores=True # Get scores for both positive/negative
            )
            # logger.info(...) # Log success
        except Exception as e:
            # logger.error(...) # Log error
            # If AI model fails, self.sentiment_analyzer remains None,
            # triggering the fallback in analyze_sentiment.
            pass # Use simple fallback instead

# ... inside the SentimentAnalyzer class ...

    def _simple_sentiment_analyzer(self, texts: List[str]) -> List[Dict[str, Any]]:
        """
        Simple rule-based sentiment analyzer as fallback.
        """
        results = []
        # Simple lists of words that suggest positive or negative sentiment
        positive_words = ['good', 'great', 'excellent', 'amazing', 'awesome', 'love', ...]
        negative_words = ['bad', 'poor', 'terrible', 'awful', 'issue', 'problem', ...]

        for text in texts:
            text_lower = text.lower()
            # Count how many positive/negative words appear
            pos_count = sum(1 for word in positive_words if word in text_lower)
            neg_count = sum(1 for word in negative_words if word in text_lower)

            # Basic logic to decide sentiment
            if pos_count > neg_count and pos_count > 0:
                 label = "POSITIVE"
                 score = 1.0 # Simplified score
            elif neg_count > pos_count and neg_count > 0:
                 label = "NEGATIVE"
                 score = 1.0 # Simplified score
            else:
                 label = "NEUTRAL"
                 score = 0.5 # Simplified score

            # Format the result similarly to the AI model output
            results.append([
                {"label": "NEGATIVE", "score": 1.0 - score},
                {"label": "POSITIVE", "score": score}
            ])

        return results

# ... inside the SentimentAnalyzer class ...

    def analyze_sentiment(self, texts: List[str]) -> List[Dict[str, Any]]:
        """
        Analyze sentiment for a list of texts using model or fallback.
        """
        results = []
        try:
            # Check if the AI model was initialized successfully
            if self.sentiment_analyzer:
                # Use the AI model's pipeline
                # logger.info(f"Analyzing {len(texts)} texts using AI model...")
                # Break into small groups (batches) for efficiency
                batch_size = 8
                for i in range(0, len(texts), batch_size):
                    batch_texts = texts[i:i + batch_size]
                    batch_results = self.sentiment_analyzer(batch_texts)
                    results.extend(batch_results)
            else:
                # Use the simple fallback if AI model is not available
                # logger.info(f"Analyzing {len(texts)} texts using fallback...")
                results = self._simple_sentiment_analyzer(texts)

            # Process results into a consistent format
            processed_results = []
            for result in results:
                # Logic to find the highest scoring label (POSITIVE, NEGATIVE, NEUTRAL)
                # ... (detailed in the full code) ...
                label = max(result, key=lambda x: x['score'])['label']
                score = max(result, key=lambda x: x['score'])['score']

                processed_results.append({
                    'sentiment': label, # e.g., 'POSITIVE'
                    'score': score,      # e.g., 0.95
                    'label': label.lower() # e.g., 'positive'
                })

            return processed_results

        except Exception as e:
            # logger.error(...) # Log the error
            # Even if analysis fails midway, use the fallback as a last resort
            return self._simple_sentiment_analyzer(texts)

# ... inside the SentimentAnalyzer class ...

    def get_sentiment_overview(self, reviews: List[Dict[str, Any]] = None) -> Dict[str, Any]:
        """
        Get overall sentiment overview for a list of reviews.
        Fetches reviews from data pipeline if not provided.
        """
        # If no reviews are given, get them from the Data Pipeline
        if reviews is None:
            if self.data_pipeline:
                reviews = self.data_pipeline.get_processed_reviews()
                # logger.info(...) # Log count
            else:
                # logger.error(...) # Log error
                return {'error': 'No reviews available'}

        try:
            # Extract just the text from the list of reviews
            review_texts = [review['text'] for review in reviews if 'text' in review and review['text']]

            # Analyze sentiment for all extracted texts
            sentiments = self.analyze_sentiment(review_texts)

            # Count how many are positive, neutral, or negative
            sentiment_counts = {
                'positive': sum(1 for s in sentiments if s['label'] == 'positive'),
                'neutral': sum(1 for s in sentiments if s['label'] == 'neutral'),
                'negative': sum(1 for s in sentiments if s['label'] == 'negative')
            }

            # Calculate percentages
            total = len(sentiments)
            sentiment_percentages = {
                'positive': round(sentiment_counts['positive'] / total * 100, 1) if total > 0 else 0,
                # ... calculate neutral and negative percentages ...
            }

            # Determine an overall label (e.g., 'Very Positive') based on percentages
            overall_sentiment = "Mixed or Neutral" # Default
            if sentiment_percentages['positive'] > 60:
                 overall_sentiment = "Very Positive"
            # ... other conditions for Somewhat Positive/Negative, Very Negative ...


            # Return the summary
            return {
                'sentiment_distribution': sentiment_counts,
                'sentiment_percentages': sentiment_percentages,
                'overall_sentiment': overall_sentiment,
                # ... include average rating if available ...
                'total_reviews': total
            }

        except Exception as e:
            # logger.error(...) # Log the error
            return {'error': str(e), 'overall_sentiment': 'Unknown'}