import gradio as gr
import os
import re
import json
import tempfile
import hashlib
from pathlib import Path
from datetime import datetime
from typing import Dict, List, Tuple, Optional, Union
import logging

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

# Optional imports for document processing
try:
    from docx import Document
    DOCX_AVAILABLE = True
except ImportError:
    DOCX_AVAILABLE = False
    logger.warning("python-docx not installed. DOCX processing will be disabled.")

try:
    import PyPDF2
    PDF_AVAILABLE = True
except ImportError:
    PDF_AVAILABLE = False
    logger.warning("PyPDF2 not installed. PDF processing will be disabled.")

try:
    import fitz  # PyMuPDF - alternative PDF processor
    PYMUPDF_AVAILABLE = True
except ImportError:
    PYMUPDF_AVAILABLE = False

# Optional imports for advanced text processing
try:
    import nltk
    from nltk.tokenize import sent_tokenize, word_tokenize
    from nltk.corpus import stopwords
    from nltk.frequency import FreqDist
    from nltk.sentiment import SentimentIntensityAnalyzer
    NLTK_AVAILABLE = True
    # Download required NLTK data
    required_nltk_data = ['punkt', 'stopwords', 'vader_lexicon']
    for data_name in required_nltk_data:
        try:
            if data_name == 'punkt':
                nltk.data.find('tokenizers/punkt')
            elif data_name == 'stopwords':
                nltk.data.find('corpora/stopwords')
            elif data_name == 'vader_lexicon':
                nltk.data.find('vader_lexicon')
        except LookupError:
            nltk.download(data_name, quiet=True)
except ImportError:
    NLTK_AVAILABLE = False
    logger.warning("NLTK not installed. Advanced text analysis will be limited.")

try:
    from transformers import pipeline
    import torch
    TRANSFORMERS_AVAILABLE = True
    DEVICE = 0 if torch.cuda.is_available() else -1
except ImportError:
    TRANSFORMERS_AVAILABLE = False
    DEVICE = -1
    logger.warning("transformers not installed. AI summarization will use basic extraction methods.")

class AdvancedDocumentSummarizer:
    """CatalystGPT-4 Advanced Document Summarizer with enhanced features"""
    
    def __init__(self):
        self.summarizer = None
        self.sentiment_analyzer = None
        self.cache = {}
        
        # Initialize AI models
        if TRANSFORMERS_AVAILABLE:
            self._initialize_ai_models()
        
        # Initialize sentiment analyzer
        if NLTK_AVAILABLE:
            try:
                self.sentiment_analyzer = SentimentIntensityAnalyzer()
            except Exception as e:
                logger.warning(f"Failed to initialize sentiment analyzer: {e}")
    
    def _initialize_ai_models(self):
        """Initialize AI models with error handling and fallbacks"""
        models_to_try = [
            "facebook/bart-large-cnn",
            "t5-small",
            "google/pegasus-xsum"
        ]
        
        for model_name in models_to_try:
            try:
                self.summarizer = pipeline(
                    "summarization", 
                    model=model_name,
                    device=DEVICE,
                    torch_dtype=torch.float16 if DEVICE >= 0 else torch.float32
                )
                logger.info(f"Successfully loaded {model_name}")
                break
            except Exception as e:
                logger.warning(f"Failed to load {model_name}: {e}")
                continue
    
    def _get_file_hash(self, file_path: str) -> str:
        """Generate hash for file caching"""
        try:
            with open(file_path, 'rb') as f:
                content = f.read()
            return hashlib.md5(content).hexdigest()
        except Exception:
            return str(datetime.now().timestamp())
    
    def extract_text_from_pdf(self, file_path: str) -> str:
        """Enhanced PDF text extraction with better error handling"""
        text = ""
        
        # Try PyMuPDF first (generally better)
        if PYMUPDF_AVAILABLE:
            try:
                doc = fitz.open(file_path)
                for page_num, page in enumerate(doc):
                    page_text = page.get_text()
                    if page_text.strip():  # Only add non-empty pages
                        text += f"\n--- Page {page_num + 1} ---\n{page_text}\n"
                doc.close()
                
                if text.strip():
                    return text
            except Exception as e:
                logger.error(f"PyMuPDF extraction failed: {e}")
        
        # Fallback to PyPDF2
        if PDF_AVAILABLE:
            try:
                with open(file_path, 'rb') as file:
                    pdf_reader = PyPDF2.PdfReader(file)
                    for page_num, page in enumerate(pdf_reader.pages):
                        page_text = page.extract_text()
                        if page_text.strip():
                            text += f"\n--- Page {page_num + 1} ---\n{page_text}\n"
                
                if text.strip():
                    return text
            except Exception as e:
                logger.error(f"PyPDF2 extraction failed: {e}")
        
        return "PDF processing libraries not available or extraction failed."
    
    def extract_text_from_docx(self, file_path: str) -> str:
        """Enhanced DOCX extraction with better formatting preservation"""
        if not DOCX_AVAILABLE:
            return "python-docx library not available."
        
        try:
            doc = Document(file_path)
            text_parts = []
            
            # Extract paragraphs
            for paragraph in doc.paragraphs:
                if paragraph.text.strip():
                    text_parts.append(paragraph.text)
            
            # Extract tables
            for table_num, table in enumerate(doc.tables):
                text_parts.append(f"\n--- Table {table_num + 1} ---")
                for row in table.rows:
                    row_text = " | ".join(cell.text.strip() for cell in row.cells)
                    if row_text.strip():
                        text_parts.append(row_text)
            
            return "\n".join(text_parts)
        except Exception as e:
            logger.error(f"Error processing DOCX file: {e}")
            return f"Error processing DOCX file: {str(e)}"
    
    def get_enhanced_document_stats(self, text: str) -> Dict:
        """Get comprehensive document statistics with sentiment analysis"""
        if not text.strip():
            return {}
        
        # Basic stats
        word_count = len(text.split())
        char_count = len(text)
        char_count_no_spaces = len(text.replace(' ', ''))
        paragraph_count = len([p for p in text.split('\n\n') if p.strip()])
        
        stats = {
            'word_count': word_count,
            'character_count': char_count,
            'character_count_no_spaces': char_count_no_spaces,
            'paragraph_count': paragraph_count,
            'estimated_reading_time': max(1, round(word_count / 200)),  # 200 WPM average
            'estimated_speaking_time': max(1, round(word_count / 150))  # 150 WPM speaking
        }
        
        if NLTK_AVAILABLE:
            sentences = sent_tokenize(text)
            stats['sentence_count'] = len(sentences)
            stats['avg_sentence_length'] = round(word_count / len(sentences), 1) if sentences else 0
            
            # Word frequency analysis
            words = word_tokenize(text.lower())
            stop_words = set(stopwords.words('english'))
            filtered_words = [w for w in words if w.isalpha() and w not in stop_words and len(w) > 2]
            
            if filtered_words:
                freq_dist = FreqDist(filtered_words)
                stats['top_words'] = freq_dist.most_common(15)
                stats['unique_words'] = len(set(filtered_words))
                stats['lexical_diversity'] = round(len(set(filtered_words)) / len(filtered_words), 3) if filtered_words else 0
            
            # Sentiment analysis
            if self.sentiment_analyzer:
                try:
                    sentiment_scores = self.sentiment_analyzer.polarity_scores(text[:5000])  # Limit for performance
                    stats['sentiment'] = {
                        'compound': round(sentiment_scores['compound'], 3),
                        'positive': round(sentiment_scores['pos'], 3),
                        'negative': round(sentiment_scores['neg'], 3),
                        'neutral': round(sentiment_scores['neu'], 3)
                    }
                except Exception as e:
                    logger.error(f"Sentiment analysis failed: {e}")
        else:
            # Fallback without NLTK
            sentences = [s.strip() for s in text.split('.') if s.strip()]
            stats['sentence_count'] = len(sentences)
            stats['avg_sentence_length'] = round(word_count / len(sentences), 1) if sentences else 0
            
            words = re.findall(r'\b\w+\b', text.lower())
            word_freq = {}
            for word in words:
                if len(word) > 2:
                    word_freq[word] = word_freq.get(word, 0) + 1
            
            stats['top_words'] = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:15]
            stats['unique_words'] = len(set(words))
        
        return stats
    
    def advanced_extractive_summary(self, text: str, num_sentences: int = 3) -> str:
        """Enhanced extractive summarization with improved sentence scoring"""
        if not text.strip():
            return "No text to summarize."
        
        if NLTK_AVAILABLE:
            sentences = sent_tokenize(text)
        else:
            sentences = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip()]
        
        if len(sentences) <= num_sentences:
            return text
        
        # Enhanced sentence scoring
        scored_sentences = []
        total_sentences = len(sentences)
        
        # Calculate word frequencies for TF scoring
        all_words = re.findall(r'\b\w+\b', text.lower())
        word_freq = {}
        for word in all_words:
            if len(word) > 2:
                word_freq[word] = word_freq.get(word, 0) + 1
        
        # Important keywords that boost sentence scores
        importance_keywords = [
            'conclusion', 'summary', 'result', 'finding', 'important', 'significant',
            'key', 'main', 'primary', 'essential', 'crucial', 'objective', 'goal',
            'recommendation', 'suggest', 'propose', 'indicate', 'show', 'demonstrate'
        ]
        
        for i, sentence in enumerate(sentences):
            if len(sentence.split()) < 5:  # Skip very short sentences
                continue
            
            score = 0
            sentence_lower = sentence.lower()
            sentence_words = sentence.split()
            
            # Position scoring (beginning and end are more important)
            if i < total_sentences * 0.15:  # First 15%
                score += 3
            elif i > total_sentences * 0.85:  # Last 15%
                score += 2
            elif total_sentences * 0.4 <= i <= total_sentences * 0.6:  # Middle section
                score += 1
            
            # Length scoring (prefer moderate length)
            word_count = len(sentence_words)
            if 12 <= word_count <= 25:
                score += 3
            elif 8 <= word_count <= 35:
                score += 2
            elif 5 <= word_count <= 45:
                score += 1
            
            # Keyword importance scoring
            keyword_score = sum(2 if keyword in sentence_lower else 0 for keyword in importance_keywords)
            score += min(keyword_score, 6)  # Cap keyword bonus
            
            # TF-based scoring (frequency of important words)
            tf_score = 0
            for word in sentence_words:
                word_lower = word.lower()
                if word_lower in word_freq and len(word_lower) > 3:
                    tf_score += min(word_freq[word_lower], 5)  # Cap individual word contribution
            score += min(tf_score / len(sentence_words), 3)  # Normalize by sentence length
            
            # Structural indicators
            if any(indicator in sentence for indicator in [':', '—', '"', '(']):
                score += 1
            
            # Numerical data (often important)
            if re.search(r'\b\d+(?:\.\d+)?%?\b', sentence):
                score += 1
            
            scored_sentences.append((sentence, score, i))
        
        # Sort by score and select top sentences
        scored_sentences.sort(key=lambda x: x[1], reverse=True)
        selected_sentences = scored_sentences[:num_sentences]
        
        # Sort selected sentences by original position to maintain flow
        selected_sentences.sort(key=lambda x: x[2])
        
        return ' '.join([s[0] for s in selected_sentences])
    
    def intelligent_chunking(self, text: str, max_chunk_size: int = 1024) -> List[str]:
        """Intelligently chunk text while preserving semantic boundaries"""
        if len(text) <= max_chunk_size:
            return [text]
        
        chunks = []
        
        # Try to split by double newlines first (paragraphs)
        paragraphs = text.split('\n\n')
        current_chunk = ""
        
        for paragraph in paragraphs:
            # If single paragraph is too long, split by sentences
            if len(paragraph) > max_chunk_size:
                if current_chunk:
                    chunks.append(current_chunk.strip())
                    current_chunk = ""
                
                # Split long paragraph by sentences
                if NLTK_AVAILABLE:
                    sentences = sent_tokenize(paragraph)
                else:
                    sentences = [s.strip() for s in paragraph.split('.') if s.strip()]
                
                temp_chunk = ""
                for sentence in sentences:
                    if len(temp_chunk + sentence) <= max_chunk_size:
                        temp_chunk += sentence + ". "
                    else:
                        if temp_chunk:
                            chunks.append(temp_chunk.strip())
                        temp_chunk = sentence + ". "
                
                if temp_chunk:
                    current_chunk = temp_chunk
            else:
                # Normal paragraph processing
                if len(current_chunk + paragraph) <= max_chunk_size:
                    current_chunk += paragraph + "\n\n"
                else:
                    if current_chunk:
                        chunks.append(current_chunk.strip())
                    current_chunk = paragraph + "\n\n"
        
        if current_chunk:
            chunks.append(current_chunk.strip())
        
        return [chunk for chunk in chunks if chunk.strip()]
    
    def ai_summary(self, text: str, max_length: int = 150, min_length: int = 50) -> str:
        """Enhanced AI-powered summarization with better chunking and error handling"""
        if not self.summarizer:
            return self.advanced_extractive_summary(text)
        
        try:
            # Intelligent chunking
            chunks = self.intelligent_chunking(text, 1000)  # Slightly smaller chunks for better quality
            
            if not chunks:
                return "No meaningful content found for summarization."
            
            summaries = []
            for i, chunk in enumerate(chunks):
                if len(chunk.strip()) < 50:  # Skip very short chunks
                    continue
                
                try:
                    # Adjust parameters based on chunk size
                    chunk_max_length = min(max_length, max(50, len(chunk.split()) // 3))
                    chunk_min_length = min(min_length, chunk_max_length // 2)
                    
                    summary = self.summarizer(
                        chunk, 
                        max_length=chunk_max_length, 
                        min_length=chunk_min_length, 
                        do_sample=False,
                        truncation=True
                    )
                    summaries.append(summary[0]['summary_text'])
                    
                except Exception as e:
                    logger.warning(f"Error summarizing chunk {i}: {e}")
                    # Fallback to extractive summary for this chunk
                    fallback_summary = self.advanced_extractive_summary(chunk, 2)
                    if fallback_summary and fallback_summary != "No text to summarize.":
                        summaries.append(fallback_summary)
            
            if not summaries:
                return self.advanced_extractive_summary(text)
            
            # Combine and refine summaries
            if len(summaries) == 1:
                return summaries[0]
            else:
                combined_summary = ' '.join(summaries)
                
                # If combined summary is still too long, summarize again
                if len(combined_summary.split()) > max_length * 1.5:
                    try:
                        final_summary = self.summarizer(
                            combined_summary,
                            max_length=max_length,
                            min_length=min_length,
                            do_sample=False,
                            truncation=True
                        )
                        return final_summary[0]['summary_text']
                    except Exception:
                        return combined_summary[:max_length * 10]  # Rough character limit fallback
                
                return combined_summary
                
        except Exception as e:
            logger.error(f"AI summarization failed: {e}")
            return self.advanced_extractive_summary(text)
    
    def generate_enhanced_key_points(self, text: str, num_points: int = 7) -> List[str]:
        """Generate key points with improved extraction and categorization"""
        if not text.strip():
            return []
        
        if NLTK_AVAILABLE:
            sentences = sent_tokenize(text)
        else:
            sentences = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip()]
        
        # Enhanced key point indicators with categories
        key_indicators = {
            'conclusions': ['conclusion', 'conclude', 'result', 'outcome', 'finding', 'discovered'],
            'objectives': ['objective', 'goal', 'purpose', 'aim', 'target', 'mission'],
            'methods': ['method', 'approach', 'technique', 'procedure', 'process', 'way'],
            'importance': ['important', 'significant', 'crucial', 'essential', 'key', 'main', 'primary'],
            'recommendations': ['recommend', 'suggest', 'propose', 'should', 'must', 'need to'],
            'problems': ['problem', 'issue', 'challenge', 'difficulty', 'obstacle', 'concern'],
            'benefits': ['benefit', 'advantage', 'improvement', 'enhancement', 'positive', 'gain']
        }
        
        scored_sentences = []
        for sentence in sentences:
            if len(sentence.split()) < 6:  # Skip very short sentences
                continue
                
            score = 0
            sentence_lower = sentence.lower()
            category = 'general'
            
            # Category-based scoring
            for cat, indicators in key_indicators.items():
                category_score = sum(2 if indicator in sentence_lower else 0 for indicator in indicators)
                if category_score > score:
                    score = category_score
                    category = cat
            
            # Structural scoring
            if sentence.strip().startswith(('•', '-', '1.', '2.', '3.', '4.', '5.')):
                score += 4
            
            # Punctuation indicators
            if any(punct in sentence for punct in [':', ';', '—', '"']):
                score += 1
            
            # Length scoring (prefer moderate length for key points)
            word_count = len(sentence.split())
            if 8 <= word_count <= 20:
                score += 3
            elif 6 <= word_count <= 30:
                score += 2
            elif 4 <= word_count <= 40:
                score += 1
            
            # Numerical data bonus
            if re.search(r'\b\d+(?:\.\d+)?%?\b', sentence):
                score += 2
            
            # Avoid very generic sentences
            generic_words = ['the', 'this', 'that', 'there', 'it', 'they']
            if sentence.split()[0].lower() in generic_words:
                score -= 1
            
            if score > 0:
                scored_sentences.append((sentence.strip(), score, category))
        
        # Sort by score and diversify by category
        scored_sentences.sort(key=lambda x: x[1], reverse=True)
        
        # Select diverse key points
        selected_points = []
        used_categories = set()
        
        # First pass: get the highest scoring point from each category
        for sentence, score, category in scored_sentences:
            if len(selected_points) >= num_points:
                break
            if category not in used_categories:
                selected_points.append(sentence)
                used_categories.add(category)
        
        # Second pass: fill remaining slots with highest scoring sentences
        for sentence, score, category in scored_sentences:
            if len(selected_points) >= num_points:
                break
            if sentence not in selected_points:
                selected_points.append(sentence)
        
        return selected_points[:num_points]
    
    def generate_document_outline(self, text: str) -> List[str]:
        """Generate a structured outline of the document"""
        if not text.strip():
            return []
        
        lines = text.split('\n')
        outline = []
        
        # Look for headers, numbered sections, etc.
        header_patterns = [
            r'^#{1,6}\s+(.+)$',  # Markdown headers
            r'^(\d+\.?\s+[A-Z][^.]{10,})$',  # Numbered sections
            r'^([A-Z][A-Z\s]{5,})$',  # ALL CAPS headers
            r'^([A-Z][a-z\s]{10,}:)$',  # Title Case with colon
        ]
        
        for line in lines:
            line = line.strip()
            if not line:
                continue
                
            for pattern in header_patterns:
                match = re.match(pattern, line)
                if match:
                    outline.append(match.group(1).strip())
                    break
        
        return outline[:10]  # Limit to 10 outline items
    
    def process_document(self, file_path: str, summary_type: str = "ai", 
                        summary_length: str = "medium") -> Tuple[Optional[Dict], Optional[str]]:
        """Enhanced document processing with caching and comprehensive analysis"""
        if not file_path:
            return None, "No file provided."
        
        try:
            # Check cache
            file_hash = self._get_file_hash(file_path)
            cache_key = f"{file_hash}_{summary_type}_{summary_length}"
            
            if cache_key in self.cache:
                logger.info("Returning cached result")
                return self.cache[cache_key], None
            
            # Extract text based on file type
            file_extension = Path(file_path).suffix.lower()
            
            if file_extension == '.pdf':
                text = self.extract_text_from_pdf(file_path)
            elif file_extension == '.docx':
                text = self.extract_text_from_docx(file_path)
            elif file_extension in ['.txt', '.md', '.rtf']:
                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    text = f.read()
            else:
                return None, f"Unsupported file type: {file_extension}"
            
            if not text.strip() or "not available" in text.lower():
                return None, "No text could be extracted from the document or extraction failed."
            
            # Clean text
            text = re.sub(r'\n{3,}', '\n\n', text)  # Reduce excessive newlines
            text = re.sub(r' {2,}', ' ', text)  # Reduce excessive spaces
            
            # Get comprehensive statistics
            stats = self.get_enhanced_document_stats(text)
            
            # Generate summary based on type and length
            length_params = {
                "short": {"sentences": 2, "max_length": 80, "min_length": 30},
                "medium": {"sentences": 4, "max_length": 150, "min_length": 50},
                "long": {"sentences": 6, "max_length": 250, "min_length": 100},
                "detailed": {"sentences": 8, "max_length": 400, "min_length": 150}
            }
            
            params = length_params.get(summary_length, length_params["medium"])
            
            # Generate summary
            if summary_type == "ai" and self.summarizer:
                summary = self.ai_summary(text, params["max_length"], params["min_length"])
            else:
                summary = self.advanced_extractive_summary(text, params["sentences"])
            
            # Generate enhanced features
            key_points = self.generate_enhanced_key_points(text, 7)
            outline = self.generate_document_outline(text)
            
            # Calculate readability (simple approximation)
            avg_sentence_length = stats.get('avg_sentence_length', 0)
            readability_score = max(0, min(100, 100 - (avg_sentence_length * 2)))
            
            result = {
                'original_text': text[:2000] + "..." if len(text) > 2000 else text,  # Truncate for display
                'full_text_length': len(text),
                'summary': summary,
                'key_points': key_points,
                'outline': outline,
                'stats': stats,
                'readability_score': readability_score,
                'file_name': Path(file_path).name,
                'file_size': os.path.getsize(file_path),
                'processing_time': datetime.now().isoformat(),
                'summary_type': summary_type,
                'summary_length': summary_length,
                'model_used': 'AI (BART/T5)' if self.summarizer else 'Extractive'
            }
            
            # Cache result
            self.cache[cache_key] = result
            
            return result, None
            
        except Exception as e:
            logger.error(f"Document processing error: {e}")
            return None, f"Error processing document: {str(e)}"

def create_catalyst_interface():
    """Create the CatalystGPT-4 document summarizer interface"""
    
    summarizer = AdvancedDocumentSummarizer()
    
    # Enhanced CSS with modern styling
    css = """
    .catalyst-header {
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        color: white;
        padding: 30px;
        border-radius: 20px;
        text-align: center;
        margin-bottom: 25px;
        box-shadow: 0 10px 30px rgba(0,0,0,0.2);
    }
    
    .summary-container {
        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
        color: white;
        padding: 25px;
        border-radius: 15px;
        margin: 15px 0;
        box-shadow: 0 8px 25px rgba(0,0,0,0.15);
    }
    
    .stats-container {
        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
        color: white;
        padding: 20px;
        border-radius: 12px;
        margin: 15px 0;
        box-shadow: 0 6px 20px rgba(0,0,0,0.1);
    }
    
    .key-points-container {
        background: linear-gradient(135deg, #4ecdc4 0%, #44a08d 100%);
        color: white;
        padding: 20px;
        border-radius: 12px;
        margin: 15px 0;
        box-shadow: 0 6px 20px rgba(0,0,0,0.1);
    }
    
    .outline-container {
        background: linear-gradient(135deg, #fa709a 0%, #fee140 100%);
        color: white;
        padding: 20px;
        border-radius: 12px;
        margin: 15px 0;
        box-shadow: 0 6px 20px rgba(0,0,0,0.1);
    }
    
    .error-container {
        background: linear-gradient(135deg, #ff9a9e 0%, #fecfef 100%);
        color: #721c24;
        padding: 20px;
        border-radius: 12px;
        margin: 15px 0;
        border-left: 5px solid #dc3545;
    }
    
    .control-panel {
        background: linear-gradient(135deg, #f6f9fc 0%, #e9ecef 100%);
        padding: 25px;
        border-radius: 15px;
        margin: 15px 0;
        border: 1px solid #dee2e6;
        box-shadow: 0 4px 15px rgba(0,0,0,0.05);
    }
    
    .file-upload-area {
        border: 3px dashed #007bff;
        border-radius: 15px;
        padding: 40px;
        text-align: center;
        background: linear-gradient(135deg, #f8f9ff 0%, #e3f2fd 100%);
        transition: all 0.3s ease;
        margin: 15px 0;
    }
    
    .file-upload-area:hover {
        border-color: #0056b3;
        background: linear-gradient(135deg, #f0f7ff 0%, #e1f5fe 100%);
        transform: translateY(-2px);
    }
    
    .metric-card {
        background: white;
        padding: 15px;
        border-radius: 10px;
        margin: 5px;
        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
        text-align: center;
    }
    
    .sentiment-indicator {
        display: inline-block;
        padding: 5px 12px;
        border-radius: 20px;
        font-weight: bold;
        font-size: 12px;
        margin: 2px;
    }
    
    .sentiment-positive { background: #d4edda; color: #155724; }
    .sentiment-negative { background: #f8d7da; color: #721c24; }
    .sentiment-neutral { background: #d1ecf1; color: #0c5460; }
    
    .progress-bar {
        background: #e9ecef;
        border-radius: 10px;
        overflow: hidden;
        height: 8px;
        margin: 5px 0;
    }
    
    .progress-fill {
        height: 100%;
        background: linear-gradient(90deg, #28a745, #20c997);
        transition: width 0.3s ease;
    }
    """
    
    def format_file_size(size_bytes):
        """Convert bytes to human readable format"""
        for unit in ['B', 'KB', 'MB', 'GB']:
            if size_bytes < 1024.0:
                return f"{size_bytes:.1f} {unit}"
            size_bytes /= 1024.0
        return f"{size_bytes:.1f} TB"
    
    def get_sentiment_indicator(sentiment_score):
        """Get sentiment indicator HTML"""
        if sentiment_score > 0.1:
            return '<span class="sentiment-indicator sentiment-positive">Positive</span>'
        elif sentiment_score < -0.1:
            return '<span class="sentiment-indicator sentiment-negative">Negative</span>'
        else:
            return '<span class="sentiment-indicator sentiment-neutral">Neutral</span>'
    
    def process_and_display(file, summary_type, summary_length, enable_ai_features):
        """Enhanced processing with comprehensive results display"""
        if file is None:
            return (
                gr.update(visible=False),
                gr.update(visible=False), 
                gr.update(visible=False),
                gr.update(visible=False),
                gr.update(value="""
                    <div style="text-align: center; padding: 60px; color: #666;">
                        <h3>CatalystGPT-4 Ready</h3>
                        <p>Upload a document to begin advanced AI-powered analysis</p>
                        <p><small>Supports: PDF, Word (.docx), Text (.txt, .md, .rtf)</small></p>
                    </div>
                """, visible=True)
            )
        
        try:
            # Use AI features based on toggle
            actual_summary_type = summary_type if enable_ai_features else "extractive"
            
            result, error = summarizer.process_document(file.name, actual_summary_type, summary_length)
            
            if error:
                error_html = f'''
                <div class="error-container">
                    <h4>Processing Error</h4>
                    <p><strong>Error:</strong> {error}</p>
                    <p><small>Please try a different file or check the file format.</small></p>
                </div>
                '''
                return (
                    gr.update(visible=False),
                    gr.update(visible=False),
                    gr.update(visible=False),
                    gr.update(visible=False),
                    gr.update(value=error_html, visible=True)
                )
            
            # Format summary display
            summary_html = f'''
            <div class="summary-container">
                <h3>Document Summary</h3>
                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 15px;">
                    <div><strong>File:</strong> {result["file_name"]}</div>
                    <div><strong>Size:</strong> {format_file_size(result["file_size"])}</div>
                    <div><strong>Model:</strong> {result["model_used"]}</div>
                    <div><strong>Length:</strong> {result["summary_length"].title()}</div>
                </div>
                <div style="background: rgba(255,255,255,0.15); padding: 20px; border-radius: 10px; line-height: 1.6;">
                    {result["summary"]}
                </div>
            </div>
            '''
            
            # Format comprehensive statistics
            stats = result["stats"]
            readability = result["readability_score"]
            
            # Create readability indicator
            readability_color = "#28a745" if readability > 70 else "#ffc107" if readability > 40 else "#dc3545"
            readability_text = "Easy" if readability > 70 else "Moderate" if readability > 40 else "Complex"
            
            stats_html = f'''
            <div class="stats-container">
                <h3>Document Analytics</h3>
                
                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 20px 0;">
                    <div class="metric-card">
                        <h4 style="margin: 0; color: #007bff;">{stats["word_count"]:,}</h4>
                        <small>Words</small>
                    </div>
                    <div class="metric-card">
                        <h4 style="margin: 0; color: #28a745;">{stats["estimated_reading_time"]} min</h4>
                        <small>Reading Time</small>
                    </div>
                    <div class="metric-card">
                        <h4 style="margin: 0; color: #17a2b8;">{stats["sentence_count"]:,}</h4>
                        <small>Sentences</small>
                    </div>
                    <div class="metric-card">
                        <h4 style="margin: 0; color: #6f42c1;">{stats.get("unique_words", "N/A")}</h4>
                        <small>Unique Words</small>
                    </div>
                </div>
                
                <div style="margin: 20px 0;">
                    <h4>Readability Score</h4>
                    <div class="progress-bar">
                        <div class="progress-fill" style="width: {readability}%; background-color: {readability_color};"></div>
                    </div>
                    <p><strong>{readability:.1f}/100</strong> - {readability_text} to read</p>
                </div>
            '''
            
            # Add sentiment analysis if available
            if stats.get('sentiment'):
                sentiment = stats['sentiment']
                sentiment_html = get_sentiment_indicator(sentiment['compound'])
                stats_html += f'''
                <div style="margin: 20px 0;">
                    <h4>Document Sentiment</h4>
                    {sentiment_html}
                    <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; margin-top: 10px;">
                        <small>Positive: {sentiment['positive']:.2f}</small>
                        <small>Negative: {sentiment['negative']:.2f}</small>
                        <small>Neutral: {sentiment['neutral']:.2f}</small>
                    </div>
                </div>
                '''
            
            # Add word frequency
            if stats.get('top_words'):
                stats_html += f'''
                <div style="margin: 20px 0;">
                    <h4>Most Frequent Words</h4>
                    <div style="display: flex; flex-wrap: wrap; gap: 8px; margin-top: 10px;">
                        {" ".join([f'<span style="background: rgba(255,255,255,0.2); padding: 6px 12px; border-radius: 15px; font-size: 13px;">{word} ({count})</span>' for word, count in stats["top_words"][:10]])}
                    </div>
                </div>
                '''
            
            stats_html += '</div>'
            
            # Format key points
            key_points_html = f'''
            <div class="key-points-container">
                <h3>Key Insights</h3>
                <ul style="list-style: none; padding: 0;">
            '''
            for i, point in enumerate(result["key_points"], 1):
                key_points_html += f'<li style="margin-bottom: 12px; padding: 10px; background: rgba(255,255,255,0.15); border-radius: 8px;"><strong>{i}.</strong> {point}</li>'
            key_points_html += '</ul></div>'
            
            # Format document outline
            outline_html = ""
            if result.get("outline"):
                outline_html = f'''
                <div class="outline-container">
                    <h3>Document Structure</h3>
                    <ol style="padding-left: 20px;">
                '''
                for item in result["outline"]:
                    outline_html += f'<li style="margin-bottom: 8px; padding: 5px 0;">{item}</li>'
                outline_html += '</ol></div>'
            
            return (
                gr.update(value=summary_html, visible=True),
                gr.update(value=stats_html, visible=True),
                gr.update(value=key_points_html, visible=True),
                gr.update(value=outline_html, visible=True if outline_html else False),
                gr.update(visible=False)
            )
            
        except Exception as e:
            error_html = f'''
            <div class="error-container">
                <h4>Unexpected Error</h4>
                <p><strong>Details:</strong> {str(e)}</p>
                <p><small>Please try again or contact support if the issue persists.</small></p>
            </div>
            '''
            return (
                gr.update(visible=False),
                gr.update(visible=False),
                gr.update(visible=False),
                gr.update(visible=False),
                gr.update(value=error_html, visible=True)
            )
    
    # Create the main interface
    with gr.Blocks(css=css, title="CatalystGPT-4 Document Summarizer", theme=gr.themes.Soft()) as demo:
        
        # Header
        gr.HTML("""
        <div class="catalyst-header">
            <h1 style="margin: 0; font-size: 3em; font-weight: bold;">CatalystGPT-4</h1>
            <h2 style="margin: 10px 0; font-size: 1.5em; opacity: 0.9;">Advanced Document Summarizer</h2>
            <p style="margin: 15px 0 0 0; font-size: 1.1em; opacity: 0.8;">
                Powered by AI • Extractive & Abstractive Summarization • Comprehensive Analytics
            </p>
        </div>
        """)
        
        with gr.Row():
            # Left column - Enhanced Controls
            with gr.Column(scale=1):
                with gr.Group():
                    gr.HTML('<div class="control-panel">')
                    
                    gr.Markdown("### Document Upload")
                    file_upload = gr.File(
                        label="Choose your document",
                        file_types=[".pdf", ".docx", ".txt", ".md", ".rtf"],
                        elem_classes="file-upload-area"
                    )
                    
                    gr.Markdown("### Analysis Settings")
                    
                    enable_ai_features = gr.Checkbox(
                        label="Enable AI Features",
                        value=TRANSFORMERS_AVAILABLE,
                        info="Use advanced AI models for better summarization",
                        interactive=TRANSFORMERS_AVAILABLE
                    )
                    
                    summary_type = gr.Radio(
                        choices=[
                            ("AI Summary (Neural)", "ai"), 
                            ("Extractive Summary", "extractive")
                        ],
                        value="ai" if TRANSFORMERS_AVAILABLE else "extractive",
                        label="Summarization Method",
                        info="AI generates new text, Extractive selects key sentences"
                    )
                    
                    summary_length = gr.Radio(
                        choices=[
                            ("Short & Concise", "short"),
                            ("Standard Length", "medium"), 
                            ("Detailed Analysis", "long"),
                            ("Comprehensive Report", "detailed")
                        ],
                        value="medium",
                        label="Analysis Depth",
                        info="Choose the level of detail for your analysis"
                    )
                    
                    analyze_btn = gr.Button(
                        "Analyze Document", 
                        variant="primary", 
                        size="lg",
                        elem_classes="analyze-button"
                    )
                    
                    gr.HTML('</div>')
                
                # Enhanced Library Status
                gr.Markdown(f"""
                ### System Status
                
                **Core Features:**
                - **PDF Processing:** {"✅ PyMuPDF" if PYMUPDF_AVAILABLE else ("✅ PyPDF2" if PDF_AVAILABLE else "❌ Not Available")}
                - **Word Documents:** {"✅ Available" if DOCX_AVAILABLE else "❌ Install python-docx"}
                - **AI Summarization:** {"✅ Available" if TRANSFORMERS_AVAILABLE else "❌ Install transformers"}
                - **Advanced NLP:** {"✅ Available" if NLTK_AVAILABLE else "⚠️ Basic processing"}
                - **Sentiment Analysis:** {"✅ Available" if (NLTK_AVAILABLE and summarizer.sentiment_analyzer) else "❌ Not Available"}
                
                **Performance:**
                - **Device:** {"GPU" if DEVICE >= 0 else "CPU"}
                - **Cache:** {"Enabled" if summarizer.cache is not None else "Disabled"}
                """)
            
            # Right column - Enhanced Results
            with gr.Column(scale=2):
                
                # Welcome message
                welcome_msg = gr.HTML(
                    value="""
                    <div style="text-align: center; padding: 80px 20px; color: #666;">
                        <div style="font-size: 4em; margin-bottom: 20px;">📚</div>
                        <h2 style="color: #333; margin-bottom: 15px;">Ready for Analysis</h2>
                        <p style="font-size: 1.1em; margin-bottom: 10px;">Upload any document to unlock AI-powered insights</p>
                        <p><small style="color: #888;">Supports PDF, Word, Text, Markdown, and RTF files</small></p>
                        <div style="margin-top: 30px; padding: 20px; background: #f8f9fa; border-radius: 10px; display: inline-block;">
                            <strong>Features:</strong> AI Summarization • Key Points • Analytics • Sentiment Analysis
                        </div>
                    </div>
                    """,
                    visible=True
                )
                
                # Results sections
                summary_display = gr.HTML(visible=False)
                stats_display = gr.HTML(visible=False)
                key_points_display = gr.HTML(visible=False)
                outline_display = gr.HTML(visible=False)
                error_display = gr.HTML(visible=False)
        
        # Event handlers
        def on_file_change(file):
            if file is None:
                return (
                    gr.update(visible=True), 
                    gr.update(visible=False), 
                    gr.update(visible=False), 
                    gr.update(visible=False),
                    gr.update(visible=False),
                    gr.update(visible=False)
                )
            else:
                return (
                    gr.update(visible=False), 
                    gr.update(visible=False), 
                    gr.update(visible=False), 
                    gr.update(visible=False),
                    gr.update(visible=False),
                    gr.update(visible=False)
                )
        
        # Auto-hide welcome when file uploaded
        file_upload.change(
            fn=on_file_change,
            inputs=[file_upload],
            outputs=[welcome_msg, summary_display, stats_display, key_points_display, outline_display, error_display]
        )
        
        # Process document on button click
        analyze_btn.click(
            fn=process_and_display,
            inputs=[file_upload, summary_type, summary_length, enable_ai_features],
            outputs=[summary_display, stats_display, key_points_display, outline_display, error_display]
        )
        
        # Auto-process when settings change (if file uploaded)
        for component in [summary_type, summary_length, enable_ai_features]:
            component.change(
                fn=process_and_display,
                inputs=[file_upload, summary_type, summary_length, enable_ai_features],
                outputs=[summary_display, stats_display, key_points_display, outline_display, error_display]
            )
        
        # Enhanced Footer
        gr.HTML("""
        <div style="margin-top: 50px; padding: 30px; background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); 
                    border-radius: 15px; text-align: center; border-top: 3px solid #007bff;">
            <h3 style="color: #333; margin-bottom: 20px;">Installation & Setup</h3>
            
            <div style="background: #343a40; color: #fff; padding: 15px; border-radius: 8px; 
                        font-family: 'Courier New', monospace; margin: 15px 0;">
                <strong>Quick Install:</strong><br>
                pip install gradio python-docx PyPDF2 transformers torch nltk PyMuPDF
            </div>
            
            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-top: 20px;">
                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
                    <strong>Core Features</strong><br>
                    <small>Multi-format support, AI summarization, key insights extraction</small>
                </div>
                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
                    <strong>Advanced Analytics</strong><br>
                    <small>Sentiment analysis, readability scoring, word frequency</small>
                </div>
                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
                    <strong>Performance</strong><br>
                    <small>Intelligent caching, GPU acceleration, batch processing</small>
                </div>
            </div>
            
            <p style="margin-top: 20px; color: #666;">
                <strong>CatalystGPT-4</strong> - Advanced Document Analysis Platform
            </p>
        </div>
        """)
    
    return demo

if __name__ == "__main__":
    demo = create_catalyst_interface()
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        show_error=True
    )