"""
Advanced Keyword Extraction Module
Uses TF-IDF and other advanced methods for keyword extraction

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

from sklearn.feature_extraction.text import TfidfVectorizer
from collections import Counter
import re
from text_preprocessing import TextPreprocessor

class AdvancedKeywordExtractor:
    """
    Advanced keyword extraction using TF-IDF
    Developer: RSK World - https://rskworld.in
    """
    
    def __init__(self):
        """Initialize keyword extractor"""
        self.preprocessor = TextPreprocessor()
        self.tfidf_vectorizer = TfidfVectorizer(
            max_features=100,
            stop_words='english',
            ngram_range=(1, 2),  # Unigrams and bigrams
            min_df=1
        )
    
    def extract_tfidf_keywords(self, text, top_n=10):
        """
        Extract keywords using TF-IDF
        
        Args:
            text (str): Input text
            top_n (int): Number of top keywords to return
            
        Returns:
            list: List of top keywords with scores
        """
        try:
            # Preprocess text
            preprocessed = self.preprocessor.preprocess(text)
            cleaned_text = preprocessed['cleaned_text']
            
            if not cleaned_text or len(cleaned_text.split()) < 2:
                return []
            
            # Calculate TF-IDF
            tfidf_matrix = self.tfidf_vectorizer.fit_transform([cleaned_text])
            feature_names = self.tfidf_vectorizer.get_feature_names_out()
            
            # Get scores
            scores = tfidf_matrix.toarray()[0]
            
            # Create keyword-score pairs
            keywords = [
                {'keyword': feature_names[i], 'score': float(scores[i])}
                for i in range(len(feature_names))
            ]
            
            # Sort by score
            keywords.sort(key=lambda x: x['score'], reverse=True)
            
            return keywords[:top_n]
        except Exception as e:
            print(f"Error in TF-IDF extraction: {e}")
            return []
    
    def extract_ngrams(self, text, n=2, top_n=10):
        """
        Extract n-grams from text
        
        Args:
            text (str): Input text
            n (int): N-gram size (1=unigrams, 2=bigrams, etc.)
            top_n (int): Number of top n-grams to return
            
        Returns:
            list: List of top n-grams
        """
        preprocessed = self.preprocessor.preprocess(text)
        tokens = preprocessed['filtered_tokens']
        
        if len(tokens) < n:
            return []
        
        # Generate n-grams
        ngrams = []
        for i in range(len(tokens) - n + 1):
            ngram = ' '.join(tokens[i:i+n])
            ngrams.append(ngram)
        
        # Count frequency
        ngram_freq = Counter(ngrams)
        
        return [
            {'ngram': ngram, 'frequency': count}
            for ngram, count in ngram_freq.most_common(top_n)
        ]
    
    def extract_key_phrases(self, text, top_n=10):
        """
        Extract key phrases using multiple methods
        
        Args:
            text (str): Input text
            top_n (int): Number of phrases to return
            
        Returns:
            dict: Key phrases from different methods
        """
        tfidf_keywords = self.extract_tfidf_keywords(text, top_n)
        bigrams = self.extract_ngrams(text, n=2, top_n=top_n)
        trigrams = self.extract_ngrams(text, n=3, top_n=top_n)
        
        return {
            'tfidf_keywords': tfidf_keywords,
            'bigrams': bigrams,
            'trigrams': trigrams,
            'top_keywords': [kw['keyword'] for kw in tfidf_keywords[:5]]
        }