"""
Text Summarization Module
Provides extractive and abstractive text summarization

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

from transformers import pipeline
from nltk.tokenize import sent_tokenize
import re

class TextSummarizer:
    """
    Text summarization class using multiple methods
    Developer: RSK World - https://rskworld.in
    """
    
    def __init__(self):
        """Initialize summarization models"""
        try:
            # Abstractive summarization model
            self.abstractive_summarizer = pipeline(
                "summarization",
                model="facebook/bart-large-cnn",
                device=-1  # Use CPU
            )
        except Exception as e:
            print(f"Warning: Could not load abstractive summarizer: {e}")
            self.abstractive_summarizer = None
    
    def extractive_summarize(self, text, num_sentences=3):
        """
        Extractive summarization using sentence scoring
        
        Args:
            text (str): Input text
            num_sentences (int): Number of sentences in summary
            
        Returns:
            str: Extracted summary
        """
        sentences = sent_tokenize(text)
        
        if len(sentences) <= num_sentences:
            return ' '.join(sentences)
        
        # Simple scoring based on word frequency
        words = text.lower().split()
        word_freq = {}
        for word in words:
            if word.isalnum():
                word_freq[word] = word_freq.get(word, 0) + 1
        
        # Score sentences
        sentence_scores = {}
        for sentence in sentences:
            sentence_words = sentence.lower().split()
            score = sum(word_freq.get(word, 0) for word in sentence_words if word.isalnum())
            sentence_scores[sentence] = score
        
        # Get top sentences
        sorted_sentences = sorted(sentence_scores.items(), key=lambda x: x[1], reverse=True)
        summary_sentences = [sent for sent, score in sorted_sentences[:num_sentences]]
        
        # Maintain original order
        summary = []
        for sentence in sentences:
            if sentence in summary_sentences:
                summary.append(sentence)
                if len(summary) >= num_sentences:
                    break
        
        return ' '.join(summary)
    
    def abstractive_summarize(self, text, max_length=130, min_length=30):
        """
        Abstractive summarization using transformer model
        
        Args:
            text (str): Input text
            max_length (int): Maximum summary length
            min_length (int): Minimum summary length
            
        Returns:
            str: Generated summary or None
        """
        if self.abstractive_summarizer is None:
            return None
        
        try:
            # Truncate if too long (model limit is 1024 tokens)
            max_input_length = 1024
            if len(text) > max_input_length:
                text = text[:max_input_length]
            
            result = self.abstractive_summarizer(
                text,
                max_length=max_length,
                min_length=min_length,
                do_sample=False
            )
            
            return result[0]['summary_text']
        except Exception as e:
            print(f"Error in abstractive summarization: {e}")
            return None
    
    def summarize(self, text, method='extractive', num_sentences=3):
        """
        Summarize text using specified method
        
        Args:
            text (str): Input text
            method (str): 'extractive' or 'abstractive'
            num_sentences (int): Number of sentences for extractive
            
        Returns:
            dict: Summary results
        """
        result = {
            'method': method,
            'original_length': len(text),
            'summary': None
        }
        
        if method == 'extractive':
            summary = self.extractive_summarize(text, num_sentences)
            result['summary'] = summary
            result['summary_length'] = len(summary)
            result['compression_ratio'] = len(summary) / len(text) if text else 0
        elif method == 'abstractive':
            summary = self.abstractive_summarize(text)
            if summary:
                result['summary'] = summary
                result['summary_length'] = len(summary)
                result['compression_ratio'] = len(summary) / len(text) if text else 0
            else:
                # Fallback to extractive
                result['method'] = 'extractive (fallback)'
                summary = self.extractive_summarize(text, num_sentences)
                result['summary'] = summary
                result['summary_length'] = len(summary)
                result['compression_ratio'] = len(summary) / len(text) if text else 0
        
        return result