"""
Sentiment Analysis Module
Analyzes sentiment using NLTK and transformers

Developer: RSK World
Website: https://rskworld.in
Email: help@rskworld.in
Phone: +91 93305 39277
Year: 2026
"""

from transformers import pipeline
from nltk.sentiment import SentimentIntensityAnalyzer
import nltk

# Download required NLTK data
try:
    nltk.data.find('vader_lexicon')
except LookupError:
    nltk.download('vader_lexicon', quiet=True)

class SentimentAnalyzer:
    """
    Sentiment analysis class using multiple methods
    Developer: RSK World - https://rskworld.in
    """
    
    def __init__(self):
        """Initialize sentiment analyzers"""
        # VADER sentiment analyzer (NLTK)
        self.vader_analyzer = SentimentIntensityAnalyzer()
        
        # Transformer-based sentiment analyzer
        try:
            self.transformer_analyzer = pipeline(
                "sentiment-analysis",
                model="cardiffnlp/twitter-roberta-base-sentiment-latest",
                device=-1  # Use CPU
            )
        except Exception as e:
            print(f"Warning: Could not load transformer model: {e}")
            self.transformer_analyzer = None
    
    def analyze_vader(self, text):
        """
        Analyze sentiment using VADER
        
        Args:
            text (str): Input text
            
        Returns:
            dict: VADER sentiment scores
        """
        scores = self.vader_analyzer.polarity_scores(text)
        
        # Determine label
        if scores['compound'] >= 0.05:
            label = 'positive'
        elif scores['compound'] <= -0.05:
            label = 'negative'
        else:
            label = 'neutral'
        
        return {
            'label': label,
            'compound': scores['compound'],
            'positive': scores['pos'],
            'neutral': scores['neu'],
            'negative': scores['neg']
        }
    
    def analyze_transformer(self, text):
        """
        Analyze sentiment using transformer model
        
        Args:
            text (str): Input text
            
        Returns:
            dict: Transformer sentiment results or None
        """
        if self.transformer_analyzer is None:
            return None
        
        try:
            # Truncate text if too long
            max_length = 512
            if len(text) > max_length:
                text = text[:max_length]
            
            result = self.transformer_analyzer(text)[0]
            
            # Map labels
            label_mapping = {
                'LABEL_0': 'negative',
                'LABEL_1': 'neutral',
                'LABEL_2': 'positive'
            }
            
            label = label_mapping.get(result['label'], result['label'].lower())
            
            return {
                'label': label,
                'score': result['score']
            }
        except Exception as e:
            print(f"Error in transformer analysis: {e}")
            return None
    
    def analyze(self, text):
        """
        Complete sentiment analysis using multiple methods
        
        Args:
            text (str): Input text
            
        Returns:
            dict: Combined sentiment analysis results
        """
        vader_result = self.analyze_vader(text)
        transformer_result = self.analyze_transformer(text)
        
        # Combine results
        result = {
            'vader': vader_result,
            'label': vader_result['label'],
            'score': vader_result['compound']
        }
        
        if transformer_result:
            result['transformer'] = transformer_result
            # Use transformer result if available (more accurate)
            result['label'] = transformer_result['label']
            result['score'] = transformer_result['score']
        
        return result