text_analyzer.py

"""
=============================================================================
TEXT ANALYSIS APPLICATION - Standalone Complete Version
=============================================================================
Project: Developing Text Analysis Application in Python

This single file contains:
- Version 1: Functional/Modular implementation
- Version 2: Object-Oriented implementation (TextAnalyzer class)
- Modern GUI with drag-and-drop support
- All text processing features
- Word frequency analysis
- Matplotlib visualization

Features:
✓ Type/paste text directly
✓ Load text from file (Browse button)
✓ Drag & drop .txt files
✓ Count characters (with/without spaces)
✓ Count words, sentences, paragraphs
✓ Unique word frequency analysis
✓ Top 10 most common words
✓ Bar chart visualization
✓ Two analysis methods: Functional and OOP

Author: AarontheGalaxy
GitHub: https://github.com/AarontheGalaxy
Date: December 1, 2025

        🐢 Slow and steady wins the race!
=============================================================================
"""

import re
import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox, filedialog
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
from collections import Counter
import os
import sys

# Try to import document readers
try:
    import docx
    HAS_DOCX = True
except ImportError:
    HAS_DOCX = False

try:
    import PyPDF2
    HAS_PDF = True
except ImportError:
    HAS_PDF = False

try:
    from striprtf.striprtf import rtf_to_text
    HAS_RTF = True
except ImportError:
    HAS_RTF = False

# Try to import tkinterdnd2 for drag-and-drop, fallback if not available
try:
    from tkinterdnd2 import DND_FILES, TkinterDnD
    HAS_DND = True
except ImportError:
    HAS_DND = False
    print("⚠️  tkinterdnd2 not available. Drag-and-drop feature will be disabled.")
    print("   Install with: pip install tkinterdnd2")


# =============================================================================
# MULTI-LANGUAGE SUPPORT SYSTEM
# =============================================================================
# 🐢 < "I speak turtle in every language!"

# Stop words for different languages
STOP_WORDS = {
    'en': ['the', 'and', 'is', 'are', 'was', 'were', 'of', 'to', 'in', 'for', 'a', 'an',
           'on', 'at', 'by', 'with', 'from', 'as', 'be', 'been', 'being', 'have', 'has',
           'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might',
           'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they'],
    'tr': ['bir', 've', 'bu', 'şu', 'için', 'ile', 'de', 'da', 'den', 'dan', 'ise', 'mi',
           'mı', 'mu', 'mü', 'değil', 'daha', 'çok', 'gibi', 'var', 'yok', 'ben', 'sen',
           'o', 'biz', 'siz', 'onlar', 'şey', 'ne', 'nasıl', 'neden', 'niçin', 'nerede'],
    'de': ['der', 'die', 'das', 'und', 'ist', 'in', 'zu', 'den', 'dem', 'des', 'ein',
           'eine', 'von', 'mit', 'auf', 'für', 'an', 'als', 'auch', 'aus', 'bei', 'nach',
           'um', 'über', 'ich', 'du', 'er', 'sie', 'es', 'wir', 'ihr', 'nicht', 'sich'],
    'ar': ['في', 'من', 'إلى', 'على', 'هذا', 'ذلك', 'التي', 'الذي', 'هو', 'هي', 'أن',
           'ما', 'لا', 'نحن', 'أنا', 'أنت', 'هم', 'كان', 'كانت', 'يكون', 'عن', 'مع'],
    'es': ['el', 'la', 'de', 'que', 'y', 'a', 'en', 'un', 'una', 'los', 'las', 'del',
           'por', 'para', 'con', 'no', 'se', 'lo', 'como', 'más', 'pero', 'sus', 'es',
           'yo', 'tú', 'él', 'ella', 'nosotros', 'ellos', 'estar', 'ser', 'tener'],
    'fr': ['le', 'la', 'de', 'et', 'un', 'une', 'est', 'pour', 'dans', 'que', 'les',
           'des', 'du', 'à', 'il', 'elle', 'on', 'nous', 'vous', 'ils', 'elles', 'ce',
           'ne', 'pas', 'plus', 'avec', 'par', 'sur', 'être', 'avoir', 'son', 'sa'],
    'zh': ['的', '是', '在', '了', '和', '有', '我', '你', '他', '她', '它', '们', '这',
           '那', '不', '也', '就', '都', '要', '会', '能', '可以', '没有', '什么', '为']
}

# Language-specific punctuation for sentence detection
SENTENCE_ENDINGS = {
    'en': ['.', '!', '?'],
    'tr': ['.', '!', '?'],
    'de': ['.', '!', '?'],
    'ar': ['。', '！', '؟', '.', '!', '?'],
    'es': ['.', '!', '?', '¡', '¿'],
    'fr': ['.', '!', '?'],
    'zh': ['。', '！', '？', '.', '!', '?']
}

# UI Translations
TRANSLATIONS = {
    'en': {
        'app_title': '📊 Text Analysis Application',
        'subtitle': 'Complete Version - Functional & OOP Methods',
        'settings': '⚙️ Settings',
        'download_modules': '📦 Download Modules',
        'text_input': '📝 Text Input Area',
        'instructions': '💡 Enter text OR load file (TXT, RTF, DOCX, PDF supported)',
        'instructions_dnd': ' OR drag & drop files here',
        'browse_file': '📁 Browse File',
        'analysis_method': 'Analysis Method:',
        'functional': '⚙️ Functional',
        'oop': '🎯 OOP (Class)',
        'analyze_text': '🔍 Analyze Text',
        'clear_all': '🗑️ Clear All',
        'analysis_results': '📊 Analysis Results',
        'analyze_lang': 'Analyze Language:',
        'auto_detect': '🌍 Auto-Detect',
        'overview': '📊 Overview',
        'word_analysis': '📝 Word Analysis',
        'detailed_report': '📋 Detailed Report',
        'language_stats': '🌐 Language Stats',
        'advanced': '🔬 Advanced',
        'info': 'ℹ️ Info'
    },
    'tr': {
        'app_title': '📊 Metin Analiz Uygulaması',
        'subtitle': 'Tam Sürüm - Fonksiyonel & OOP Yöntemler',
        'settings': '⚙️ Ayarlar',
        'download_modules': '📦 Modül İndir',
        'text_input': '📝 Metin Giriş Alanı',
        'instructions': '💡 Metin girin VEYA dosya yükleyin (TXT, RTF, DOCX, PDF desteklenir)',
        'instructions_dnd': ' VEYA dosyaları sürükle bırak',
        'browse_file': '📁 Dosya Seç',
        'analysis_method': 'Analiz Yöntemi:',
        'functional': '⚙️ Fonksiyonel',
        'oop': '🎯 OOP (Sınıf)',
        'analyze_text': '🔍 Metni Analiz Et',
        'clear_all': '🗑️ Tümünü Temizle',
        'analysis_results': '📊 Analiz Sonuçları',
        'analyze_lang': 'Analiz Dili:',
        'auto_detect': '🌍 Otomatik Algıla',
        'overview': '📊 Genel Bakış',
        'word_analysis': '📝 Kelime Analizi',
        'detailed_report': '📋 Detaylı Rapor',
        'language_stats': '🌐 Dil İstatistikleri',
        'advanced': '🔬 Gelişmiş',
        'info': 'ℹ️ Bilgi'
    },
    'de': {
        'app_title': '📊 Textanalyse-Anwendung',
        'subtitle': 'Vollversion - Funktionale & OOP-Methoden',
        'settings': '⚙️ Einstellungen',
        'download_modules': '📦 Module Herunterladen',
        'text_input': '📝 Texteingabebereich',
        'instructions': '💡 Text eingeben ODER Datei laden (TXT, RTF, DOCX, PDF unterstützt)',
        'instructions_dnd': ' ODER Dateien hier ablegen',
        'browse_file': '📁 Datei Durchsuchen',
        'analysis_method': 'Analysemethode:',
        'functional': '⚙️ Funktional',
        'oop': '🎯 OOP (Klasse)',
        'analyze_text': '🔍 Text Analysieren',
        'clear_all': '🗑️ Alles Löschen',
        'analysis_results': '📊 Analyseergebnisse',
        'analyze_lang': 'Analysesprache:',
        'auto_detect': '🌍 Auto-Erkennung',
        'overview': '📊 Übersicht',
        'word_analysis': '📝 Wortanalyse',
        'detailed_report': '📋 Detaillierter Bericht',
        'language_stats': '🌐 Sprachstatistik',
        'advanced': '🔬 Erweitert',
        'info': 'ℹ️ Info'
    },
    'ar': {
        'app_title': '📊 تطبيق تحليل النصوص',
        'subtitle': 'النسخة الكاملة - الطرق الوظيفية والكائنية',
        'settings': '⚙️ الإعدادات',
        'download_modules': '📦 تحميل الوحدات',
        'text_input': '📝 منطقة إدخال النص',
        'instructions': '💡 أدخل النص أو حمل ملف (TXT, RTF, DOCX, PDF مدعوم)',
        'instructions_dnd': ' أو اسحب وأفلت الملفات هنا',
        'browse_file': '📁 تصفح الملف',
        'analysis_method': 'طريقة التحليل:',
        'functional': '⚙️ وظيفي',
        'oop': '🎯 OOP (فئة)',
        'analyze_text': '🔍 تحليل النص',
        'clear_all': '🗑️ مسح الكل',
        'analysis_results': '📊 نتائج التحليل',
        'analyze_lang': 'لغة التحليل:',
        'auto_detect': '🌍 الكشف التلقائي',
        'overview': '📊 نظرة عامة',
        'word_analysis': '📝 تحليل الكلمات',
        'detailed_report': '📋 تقرير مفصل',
        'language_stats': '🌐 إحصائيات اللغة',
        'advanced': '🔬 متقدم',
        'info': 'ℹ️ معلومات'
    },
    'es': {
        'app_title': '📊 Aplicación de Análisis de Texto',
        'subtitle': 'Versión Completa - Métodos Funcionales y OOP',
        'settings': '⚙️ Configuración',
        'download_modules': '📦 Descargar Módulos',
        'text_input': '📝 Área de Entrada de Texto',
        'instructions': '💡 Ingrese texto O cargue archivo (TXT, RTF, DOCX, PDF compatible)',
        'instructions_dnd': ' O arrastre y suelte archivos aquí',
        'browse_file': '📁 Examinar Archivo',
        'analysis_method': 'Método de Análisis:',
        'functional': '⚙️ Funcional',
        'oop': '🎯 OOP (Clase)',
        'analyze_text': '🔍 Analizar Texto',
        'clear_all': '🗑️ Borrar Todo',
        'analysis_results': '📊 Resultados del Análisis',
        'analyze_lang': 'Idioma de Análisis:',
        'auto_detect': '🌍 Detección Automática',
        'overview': '📊 Resumen',
        'word_analysis': '📝 Análisis de Palabras',
        'detailed_report': '📋 Informe Detallado',
        'language_stats': '🌐 Estadísticas de Idioma',
        'advanced': '🔬 Avanzado',
        'info': 'ℹ️ Información'
    },
    'fr': {
        'app_title': "📊 Application d'Analyse de Texte",
        'subtitle': 'Version Complète - Méthodes Fonctionnelles et POO',
        'settings': '⚙️ Paramètres',
        'download_modules': '📦 Télécharger Modules',
        'text_input': '📝 Zone de Saisie de Texte',
        'instructions': '💡 Entrez du texte OU chargez un fichier (TXT, RTF, DOCX, PDF pris en charge)',
        'instructions_dnd': ' OU glissez-déposez les fichiers ici',
        'browse_file': '📁 Parcourir Fichier',
        'analysis_method': "Méthode d'Analyse:",
        'functional': '⚙️ Fonctionnelle',
        'oop': '🎯 POO (Classe)',
        'analyze_text': '🔍 Analyser le Texte',
        'clear_all': '🗑️ Tout Effacer',
        'analysis_results': "📊 Résultats de l'Analyse",
        'analyze_lang': "Langue d'Analyse:",
        'auto_detect': '🌍 Détection Automatique',
        'overview': '📊 Vue d\'ensemble',
        'word_analysis': '📝 Analyse des Mots',
        'detailed_report': '📋 Rapport Détaillé',
        'language_stats': '🌐 Statistiques Linguistiques',
        'advanced': '🔬 Avancé',
        'info': 'ℹ️ Info'
    },
    'zh': {
        'app_title': '📊 文本分析应用程序',
        'subtitle': '完整版 - 函数式和面向对象方法',
        'settings': '⚙️ 设置',
        'download_modules': '📦 下载模块',
        'text_input': '📝 文本输入区域',
        'instructions': '💡 输入文本或加载文件（支持TXT、RTF、DOCX、PDF）',
        'instructions_dnd': ' 或将文件拖放到此处',
        'browse_file': '📁 浏览文件',
        'analysis_method': '分析方法：',
        'functional': '⚙️ 函数式',
        'oop': '🎯 面向对象（类）',
        'analyze_text': '🔍 分析文本',
        'clear_all': '🗑️ 清除全部',
        'analysis_results': '📊 分析结果',
        'analyze_lang': '分析语言：',
        'auto_detect': '🌍 自动检测',
        'overview': '📊 概述',
        'word_analysis': '📝 词汇分析',
        'detailed_report': '📋 详细报告',
        'language_stats': '🌐 语言统计',
        'advanced': '🔬 高级',
        'info': 'ℹ️ 信息'
    }
}

# Language names for display
LANGUAGE_NAMES = {
    'en': '🇬🇧 English',
    'tr': '🇹🇷 Türkçe',
    'de': '🇩🇪 Deutsch',
    'ar': '🇸🇦 العربية',
    'es': '🇪🇸 Español',
    'fr': '🇫🇷 Français',
    'zh': '🇨🇳 中文'
}


def detect_language(text):
    """
    Detect the language of the given text.
    Returns tuple: (language_code, confidence, distribution)
    """
    text_lower = text.lower()
    words = re.findall(r'\w+', text_lower)

    if not words:
        return 'en', 0.0, {}

    # Count matches for each language
    language_scores = {}
    for lang, stop_words in STOP_WORDS.items():
        matches = sum(1 for word in words if word in stop_words)
        language_scores[lang] = matches

    # Calculate total matches
    total_matches = sum(language_scores.values())

    if total_matches == 0:
        # Check for language-specific characters
        if any('\u4e00' <= c <= '\u9fff' for c in text):
            return 'zh', 0.95, {'zh': 0.95}
        elif any('\u0600' <= c <= '\u06ff' for c in text):
            return 'ar', 0.95, {'ar': 0.95}
        else:
            return 'en', 0.50, {'en': 0.50}

    # Calculate distribution
    distribution = {lang: score/total_matches for lang,
                    score in language_scores.items() if score > 0}

    # Find dominant language
    dominant_lang = max(language_scores, key=language_scores.get)
    confidence = language_scores[dominant_lang] / total_matches

    return dominant_lang, confidence, distribution


# =============================================================================
# VERSION 1: FUNCTIONAL/MODULAR IMPLEMENTATION
# =============================================================================
# 🐢 < "I count characters one by one..."

def count_characters_with_spaces(text_lines):
    """
    Count total characters including spaces.

    Args:
        text_lines (list): List of text lines

    Returns:
        int: Total character count including spaces
    """
    full_text = '\n'.join(text_lines)
    return len(full_text)


def count_characters_without_spaces(text_lines):
    """
    Count total characters excluding whitespace.

    Args:
        text_lines (list): List of text lines

    Returns:
        int: Total character count excluding spaces
    """
    full_text = '\n'.join(text_lines)
    return len(re.sub(r'\s', '', full_text))


def count_words(text_lines):
    """
    Count total words in the text (ignoring punctuation).
    Words are separated by spaces and punctuation is removed.

    Args:
        text_lines (list): List of text lines

    Returns:
        int: Total word count
    """
    full_text = ' '.join(text_lines)
    # Extract words using regex (alphanumeric sequences)
    words = re.findall(r'\b\w+\b', full_text)
    return len(words)


def count_sentences(text_lines):
    """
    Count total sentences based on sentence-ending punctuation (. ! ?).

    Args:
        text_lines (list): List of text lines

    Returns:
        int: Total sentence count
    """
    full_text = ' '.join(text_lines)
    # Split by sentence-ending punctuation
    sentences = re.split(r'[.!?]+', full_text)
    # Filter out empty strings
    sentences = [s for s in sentences if s.strip()]
    return len(sentences)


def count_paragraphs(text_lines):
    """
    Count paragraphs (blocks of text separated by empty lines).

    Args:
        text_lines (list): List of text lines

    Returns:
        int: Total paragraph count
    """
    paragraph_count = 0
    in_paragraph = False

    for line in text_lines:
        if line.strip():  # Non-empty line
            if not in_paragraph:
                paragraph_count += 1
                in_paragraph = True
        else:  # Empty line
            in_paragraph = False

    return paragraph_count


def analyze_word_frequency(text_lines):
    """
    Analyze word frequency (lowercase, no punctuation).

    Args:
        text_lines (list): List of text lines

    Returns:
        dict: Dictionary with words as keys and their frequencies as values
    """
    full_text = ' '.join(text_lines)
    # Convert to lowercase and extract words
    words = re.findall(r'\b\w+\b', full_text.lower())
    # Count frequencies using Counter
    word_freq = Counter(words)
    return dict(word_freq)


def get_text_statistics_functional(text_lines):
    """
    Generate all text statistics using functional approach.
    This is the main function for Version 1 (Functional Implementation).

    Args:
        text_lines (list): List of text lines

    Returns:
        tuple: (stats dict, word_freq dict)
    """
    stats = {
        'total_chars_with_spaces': count_characters_with_spaces(text_lines),
        'total_chars_without_spaces': count_characters_without_spaces(text_lines),
        'total_words': count_words(text_lines),
        'total_sentences': count_sentences(text_lines),
        'total_paragraphs': count_paragraphs(text_lines)
    }
    word_freq = analyze_word_frequency(text_lines)
    return stats, word_freq


# =============================================================================
# FILE READING FUNCTIONS (Multiple Format Support)
# =============================================================================
# 🐢 < "I can read anything... slowly but surely!"

def read_txt_file(file_path):
    """Read plain text file."""
    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        return f.read()


def read_rtf_file(file_path):
    """Read RTF file."""
    if not HAS_RTF:
        raise ImportError(
            "striprtf library required. Install: pip install striprtf")

    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        rtf_content = f.read()
    return rtf_to_text(rtf_content)


def read_docx_file(file_path):
    """Read DOCX file."""
    if not HAS_DOCX:
        raise ImportError(
            "python-docx library required. Install: pip install python-docx")

    doc = docx.Document(file_path)
    full_text = []
    for para in doc.paragraphs:
        full_text.append(para.text)
    return '\n'.join(full_text)


def read_pdf_file(file_path):
    """Read PDF file."""
    if not HAS_PDF:
        raise ImportError(
            "PyPDF2 library required. Install: pip install PyPDF2")

    text = []
    with open(file_path, 'rb') as f:
        pdf_reader = PyPDF2.PdfReader(f)
        for page in pdf_reader.pages:
            text.append(page.extract_text())
    return '\n'.join(text)


def read_file_auto(file_path):
    """
    Automatically detect file type and read content.

    Args:
        file_path (str): Path to file

    Returns:
        str: File content as text
    """
    ext = os.path.splitext(file_path)[1].lower()

    readers = {
        '.txt': read_txt_file,
        '.rtf': read_rtf_file,
        '.docx': read_docx_file,
        '.pdf': read_pdf_file,
        '.doc': read_docx_file  # Try with docx reader
    }

    if ext in readers:
        return readers[ext](file_path)
    else:
        # Try as plain text
        return read_txt_file(file_path)


# =============================================================================
# VERSION 2: OBJECT-ORIENTED IMPLEMENTATION
# =============================================================================
# 🐢 < "OOP makes me feel classy!"

class TextAnalyzer:
    """
    A class to analyze text and provide comprehensive statistics.
    This is Version 2 (Object-Oriented Implementation).

    Attributes:
        text_lines (list): Text stored as a list of strings (lines)
        stats (dict): Dictionary containing text statistics
        word_freq (dict): Dictionary containing word frequency data
    """

    def __init__(self, text_lines):
        """
        Initialize the TextAnalyzer with text lines.

        Args:
            text_lines (list): List of text lines to analyze
        """
        self.text_lines = text_lines
        self.stats = {}
        self.word_freq = {}

    def count_characters_with_spaces(self):
        """
        Count total characters including spaces.

        Returns:
            int: Total character count including spaces
        """
        full_text = '\n'.join(self.text_lines)
        return len(full_text)

    def count_characters_without_spaces(self):
        """
        Count total characters excluding whitespace.

        Returns:
            int: Total character count excluding spaces
        """
        full_text = '\n'.join(self.text_lines)
        return len(re.sub(r'\s', '', full_text))

    def count_words(self):
        """
        Count total words in the text (ignoring punctuation).

        Returns:
            int: Total word count
        """
        full_text = ' '.join(self.text_lines)
        words = re.findall(r'\b\w+\b', full_text)
        return len(words)

    def count_sentences(self):
        """
        Count total sentences based on sentence-ending punctuation.

        Returns:
            int: Total sentence count
        """
        full_text = ' '.join(self.text_lines)
        sentences = re.split(r'[.!?]+', full_text)
        sentences = [s for s in sentences if s.strip()]
        return len(sentences)

    def count_paragraphs(self):
        """
        Count paragraphs (blocks of text separated by empty lines).

        Returns:
            int: Total paragraph count
        """
        paragraph_count = 0
        in_paragraph = False

        for line in self.text_lines:
            if line.strip():
                if not in_paragraph:
                    paragraph_count += 1
                    in_paragraph = True
            else:
                in_paragraph = False

        return paragraph_count

    def analyze_word_frequency(self):
        """
        Analyze word frequency (lowercase, no punctuation).

        Returns:
            dict: Dictionary with words as keys and their frequencies as values
        """
        full_text = ' '.join(self.text_lines)
        words = re.findall(r'\b\w+\b', full_text.lower())
        word_freq = Counter(words)
        return dict(word_freq)

    def calculate_statistics(self):
        """
        Calculate all text statistics and store in the stats dictionary.
        This is the main method that performs all analysis.

        Returns:
            tuple: (stats dict, word_freq dict)
        """
        self.stats = {
            'total_chars_with_spaces': self.count_characters_with_spaces(),
            'total_chars_without_spaces': self.count_characters_without_spaces(),
            'total_words': self.count_words(),
            'total_sentences': self.count_sentences(),
            'total_paragraphs': self.count_paragraphs()
        }
        self.word_freq = self.analyze_word_frequency()
        return self.stats, self.word_freq


# =============================================================================
# GUI APPLICATION
# =============================================================================
# 🐢 < "GUIs are my shell!"

class TextAnalysisApp:
    """
    Main GUI application for text analysis with drag-and-drop support.
    Combines both Functional and OOP analysis methods in one interface.
    """

    def __init__(self, root):
        """
        Initialize the GUI application.

        Args:
            root: Tkinter root window
        """
        self.root = root

        # Language settings
        self.ui_language = 'en'  # Interface language
        self.analysis_language = 'auto'  # Text analysis language
        self.detected_language = None  # Auto-detected language
        self.language_confidence = 0.0
        self.language_distribution = {}

        self.root.title("📊 Text Analysis Application - Complete Version")
        self.root.geometry("1100x850")

        # Theme settings
        self.current_theme = 'light'  # 'light' or 'dark'
        self.mini_project_mode = False  # Simple mode for teacher requirements
        self.themes = {
            'light': {
                'bg': '#ffffff',
                'fg': '#000000',
                'text_bg': '#ffffff',
                'text_fg': '#000000',
                'button_bg': '#e0e0e0',
                'frame_bg': '#f5f5f5'
            },
            'dark': {
                'bg': '#2b2b2b',
                'fg': '#ffffff',
                'text_bg': '#1e1e1e',
                'text_fg': '#d4d4d4',
                'button_bg': '#3c3c3c',
                'frame_bg': '#252525'
            }
        }

        # Configure style
        style = ttk.Style()
        try:
            style.theme_use('clam')
        except tk.TclError:
            pass  # Use default theme if clam is not available

        self.create_widgets()

    def tr(self, key):
        """Get translation for current UI language."""
        return TRANSLATIONS.get(self.ui_language, TRANSLATIONS['en']).get(key, key)

    def change_ui_language(self, _event=None):
        """Change the UI language."""
        selected = self.ui_lang_var.get()
        # Find language code from display name
        for code, name in LANGUAGE_NAMES.items():
            if name == selected:
                self.ui_language = code
                break
        self.update_ui_language()

    def change_analysis_language(self, _event=None):
        """Change the analysis language."""
        selected = self.analysis_lang_var.get()
        # Check if Auto-Detect is selected
        if selected == self.tr('auto_detect'):
            self.analysis_language = 'auto'
            return
        # Find language code from display name
        for code, name in LANGUAGE_NAMES.items():
            if name == selected:
                self.analysis_language = code
                break

    def update_ui_language(self):
        """Update all UI elements with new language."""
        self.title_label.config(text=self.tr('app_title'))
        self.subtitle_label.config(text=self.tr('subtitle'))
        self.download_btn.config(text=self.tr('download_modules'))
        self.settings_btn.config(text=self.tr('settings'))
        # Update other widgets if they exist
        if hasattr(self, 'input_label_frame'):
            self.input_label_frame.config(text=self.tr('text_input'))
        if hasattr(self, 'browse_btn'):
            self.browse_btn.config(text=self.tr('browse_file'))
        if hasattr(self, 'analyze_btn'):
            self.analyze_btn.config(text=self.tr('analyze_text'))
        if hasattr(self, 'clear_btn'):
            self.clear_btn.config(text=self.tr('clear_all'))
        if hasattr(self, 'results_label_frame'):
            self.results_label_frame.config(text=self.tr('analysis_results'))

    def create_widgets(self):
        """Create and layout all GUI widgets."""
        # Main container
        main_frame = ttk.Frame(self.root, padding="15")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Configure grid weights for responsiveness
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(0, weight=1)
        main_frame.rowconfigure(1, weight=1)
        main_frame.rowconfigure(3, weight=1)

        # =====================================================================
        # HEADER SECTION
        # =====================================================================
        header_frame = ttk.Frame(main_frame)
        header_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), pady=(0, 15))

        self.title_label = ttk.Label(
            header_frame,
            text="📊 Text Analysis - Mini Project Mode" if self.mini_project_mode else self.tr(
                'app_title'),
            font=('Helvetica', 22, 'bold'),
            foreground='#2c3e50'
        )
        self.title_label.pack(side=tk.LEFT)

        self.subtitle_label = ttk.Label(
            header_frame,
            text=self.tr(
                'subtitle') if not self.mini_project_mode else "Basic Implementation - Functional & OOP Methods",
            font=('Helvetica', 10),
            foreground='#7f8c8d'
        )
        self.subtitle_label.pack(side=tk.LEFT, padx=(10, 0))

        # UI Language selector frame - Always create, conditionally show
        self.ui_lang_frame = ttk.Frame(header_frame)

        self.ui_lang_label = ttk.Label(self.ui_lang_frame, text="Language:")
        self.ui_lang_label.pack(side=tk.LEFT, padx=(0, 5))

        self.ui_lang_var = tk.StringVar(
            value=LANGUAGE_NAMES.get(self.ui_language, '🇬🇧 English'))
        self.ui_lang_combo = ttk.Combobox(
            self.ui_lang_frame,
            textvariable=self.ui_lang_var,
            values=list(LANGUAGE_NAMES.values()),
            state='readonly',
            width=15
        )
        self.ui_lang_combo.pack(side=tk.LEFT)
        self.ui_lang_combo.bind('<<ComboboxSelected>>',
                                self.change_ui_language)

        # Pack frame only if not in mini mode
        if not self.mini_project_mode:
            self.ui_lang_frame.pack(side=tk.RIGHT, padx=(5, 0))

        # Download Modules button - Always create, conditionally show
        self.download_btn = ttk.Button(
            header_frame,
            text=self.tr('download_modules'),
            command=self.open_download_manager,
            width=18
        )
        if not self.mini_project_mode:
            self.download_btn.pack(side=tk.RIGHT, padx=(5, 0))

        # Settings button (always visible)
        self.settings_btn = ttk.Button(
            header_frame,
            text=self.tr('settings'),
            command=self.open_settings,
            width=12
        )
        self.settings_btn.pack(side=tk.RIGHT, padx=(10, 0))

        # =====================================================================
        # INPUT SECTION
        # =====================================================================
        self.input_label_frame = ttk.LabelFrame(
            main_frame,
            text=self.tr('text_input'),
            padding="15"
        )
        self.input_label_frame.grid(row=1, column=0, sticky=(
            tk.W, tk.E, tk.N, tk.S), pady=(0, 15))
        self.input_label_frame.columnconfigure(0, weight=1)
        self.input_label_frame.rowconfigure(1, weight=1)

        # Instructions with language selector (simplified in mini mode)
        inst_frame = ttk.Frame(self.input_label_frame)
        inst_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), pady=(0, 8))
        self.inst_frame = inst_frame  # Save reference for toggling

        instructions_text = "💡 Enter text OR load file (TXT, RTF, DOCX, PDF supported)" if self.mini_project_mode else self.tr(
            'instructions')
        if HAS_DND:
            instructions_text += " OR drag & drop files here" if self.mini_project_mode else self.tr(
                'instructions_dnd')

        self.inst_label = ttk.Label(
            inst_frame,
            text=instructions_text,
            foreground='#3498db',
            font=('Helvetica', 10)
        )
        self.inst_label.pack(side=tk.LEFT)

        # Analysis Language selector - Always create, conditionally show
        self.analysis_lang_label = ttk.Label(
            inst_frame,
            text=" | " + self.tr('analyze_lang'),
            font=('Helvetica', 10, 'bold'),
            foreground='#2c3e50'
        )

        self.analysis_lang_var = tk.StringVar(value=self.tr('auto_detect'))
        analysis_langs = [self.tr('auto_detect')] + \
            list(LANGUAGE_NAMES.values())
        self.analysis_lang_combo = ttk.Combobox(
            inst_frame,
            textvariable=self.analysis_lang_var,
            values=analysis_langs,
            state='readonly',
            width=18
        )
        self.analysis_lang_combo.bind(
            '<<ComboboxSelected>>', self.change_analysis_language)

        # Pack only if not in mini mode
        if not self.mini_project_mode:
            self.analysis_lang_label.pack(side=tk.LEFT, padx=(15, 5))
            self.analysis_lang_combo.pack(side=tk.LEFT)

        # Text area with scrollbar
        theme = self.themes[self.current_theme]
        self.text_area = scrolledtext.ScrolledText(
            self.input_label_frame,
            wrap=tk.WORD,
            width=90,
            height=12,
            font=('Courier', 11),
            borderwidth=2,
            relief=tk.GROOVE,
            background=theme['text_bg'],
            foreground=theme['text_fg'],
            insertbackground=theme['text_fg']
        )
        self.text_area.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Enable drag and drop if available
        if HAS_DND:
            try:
                self.text_area.drop_target_register(DND_FILES)  # type: ignore
                self.text_area.dnd_bind(
                    '<<Drop>>', self.drop_file)  # type: ignore
            except AttributeError:
                pass  # Drag and drop not available

        # =====================================================================
        # CONTROL BUTTONS SECTION
        # =====================================================================
        button_frame = ttk.Frame(main_frame)
        button_frame.grid(row=2, column=0, pady=12)

        # Browse button
        self.browse_btn = ttk.Button(
            button_frame,
            text=self.tr('browse_file'),
            command=self.browse_file,
            width=15
        )
        self.browse_btn.grid(row=0, column=0, padx=8)

        # Separator
        ttk.Separator(button_frame, orient=tk.VERTICAL).grid(
            row=0, column=1, sticky='ns', padx=15
        )

        # Analysis method selection
        method_label = ttk.Label(
            button_frame,
            text=self.tr('analysis_method'),
            font=('Helvetica', 10, 'bold')
        )
        method_label.grid(row=0, column=2, padx=(5, 10))

        self.analysis_method = tk.StringVar(value="functional")

        functional_radio = ttk.Radiobutton(
            button_frame,
            text=self.tr('functional'),
            variable=self.analysis_method,
            value="functional"
        )
        functional_radio.grid(row=0, column=3, padx=5)

        oop_radio = ttk.Radiobutton(
            button_frame,
            text=self.tr('oop'),
            variable=self.analysis_method,
            value="oop"
        )
        oop_radio.grid(row=0, column=4, padx=5)

        # Separator
        ttk.Separator(button_frame, orient=tk.VERTICAL).grid(
            row=0, column=5, sticky='ns', padx=15
        )

        # Analyze button (highlighted)
        self.analyze_btn = ttk.Button(
            button_frame,
            text=self.tr('analyze_text'),
            command=self.analyze_text,
            width=18
        )
        self.analyze_btn.grid(row=0, column=6, padx=8)

        # Clear button
        self.clear_btn = ttk.Button(
            button_frame,
            text=self.tr('clear_all'),
            command=self.clear_all,
            width=12
        )
        self.clear_btn.grid(row=0, column=7, padx=8)

        # =====================================================================
        # RESULTS SECTION
        # =====================================================================
        self.results_label_frame = ttk.LabelFrame(
            main_frame,
            text=self.tr('analysis_results'),
            padding="15"
        )
        self.results_label_frame.grid(
            row=3, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        self.results_label_frame.columnconfigure(0, weight=1)
        self.results_label_frame.rowconfigure(0, weight=1)

        # Results text area
        theme = self.themes[self.current_theme]
        self.results_area = scrolledtext.ScrolledText(
            self.results_label_frame,
            wrap=tk.WORD,
            width=90,
            height=12,
            font=('Courier', 10),
            state='disabled',
            borderwidth=2,
            relief=tk.GROOVE,
            background=theme['text_bg'],
            foreground=theme['text_fg']
        )
        self.results_area.grid(
            row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Configure tags for colored output
        self.results_area.tag_configure(
            'header', foreground='#2c3e50', font=('Courier', 10, 'bold'))
        self.results_area.tag_configure(
            'subheader', foreground='#3498db', font=('Courier', 10, 'bold'))
        self.results_area.tag_configure('data', foreground='#27ae60')

    def drop_file(self, event):
        """
        Handle drag and drop file event.

        Args:
            event: Drop event containing file path
        """
        file_path = event.data
        # Remove curly braces if present (Windows/Mac compatibility)
        file_path = file_path.strip('{}').strip('"').strip("'")

        # Check if file extension is supported
        supported_ext = ['.txt', '.rtf', '.docx', '.pdf', '.doc']
        file_ext = os.path.splitext(file_path)[1].lower()

        if file_ext in supported_ext:
            self.load_file(file_path)
        else:
            messagebox.showwarning(
                "Invalid File Type",
                f"Unsupported file type: {file_ext}\n\nSupported formats:\n• TXT (Plain text)\n• RTF (Rich Text Format)\n• DOCX (Word Document)\n• PDF (Portable Document Format)"
            )

    def browse_file(self):
        """Open file browser dialog to select a document file."""
        filetypes = [
            ("All supported", "*.txt *.rtf *.docx *.pdf"),
            ("Text files", "*.txt"),
        ]

        if HAS_RTF:
            filetypes.append(("RTF files", "*.rtf"))
        if HAS_DOCX:
            filetypes.append(("Word documents", "*.docx"))
        if HAS_PDF:
            filetypes.append(("PDF files", "*.pdf"))

        filetypes.append(("All files", "*.*"))

        file_path = filedialog.askopenfilename(
            title="Select a Document File",
            filetypes=filetypes
        )
        if file_path:
            self.load_file(file_path)

    def load_file(self, file_path):
        """
        Load text from various file formats into the text area.

        Args:
            file_path (str): Path to the file
        """
        try:
            # Use auto reader to detect format
            content = read_file_auto(file_path)

            self.text_area.delete(1.0, tk.END)
            self.text_area.insert(1.0, content)

            filename = os.path.basename(file_path)
            ext = os.path.splitext(filename)[1].upper()
            messagebox.showinfo(
                "✓ File Loaded Successfully",
                f"File: {filename}\nFormat: {ext}\nLines: {len(content.splitlines())}\nCharacters: {len(content)}"
            )
        except ImportError as e:
            messagebox.showerror(
                "Missing Library",
                f"Cannot read this file format:\n{str(e)}\n\nInstall required library to continue."
            )
        except (OSError, IOError) as e:
            messagebox.showerror(
                "Error Loading File",
                f"Failed to load file:\n{str(e)}"
            )

    def analyze_text(self):
        """Analyze the text using the selected method (Functional or OOP)."""
        # Get text from text area
        text_content = self.text_area.get(1.0, tk.END).strip()

        if not text_content:
            messagebox.showwarning(
                "No Text Found",
                "Please enter some text or load a file first!"
            )
            return

        # Detect language if set to auto - Skip in mini mode
        if not self.mini_project_mode and self.analysis_language == 'auto':
            detected_lang, confidence, distribution = detect_language(
                text_content)
            self.detected_language = detected_lang
            self.language_confidence = confidence
            self.language_distribution = distribution
        elif not self.mini_project_mode:
            # Manual language selection
            self.detected_language = self.analysis_language
            self.language_confidence = 1.0
            self.language_distribution = {self.analysis_language: 1.0}
        else:
            # Mini mode: default to English
            self.detected_language = 'en'
            self.language_confidence = 1.0
            self.language_distribution = {'en': 1.0}

        # Convert to list of lines (as required by the specification)
        text_lines = text_content.split('\n')

        # Perform analysis based on selected method
        method = self.analysis_method.get()

        try:
            if method == "functional":
                stats, word_freq = get_text_statistics_functional(text_lines)
                method_name = "Functional/Modular"
                method_icon = "⚙️"
            else:  # OOP
                analyzer = TextAnalyzer(text_lines)
                stats, word_freq = analyzer.calculate_statistics()
                method_name = "Object-Oriented (TextAnalyzer Class)"
                method_icon = "🎯"

            # Display results
            self.display_results(stats, word_freq, method_name, method_icon)

            # Show visualization
            self.create_visualization(stats, word_freq, method_name)

        except (ValueError, AttributeError, KeyError) as e:
            messagebox.showerror(
                "Analysis Error",
                f"An error occurred during analysis:\n{str(e)}"
            )

    def display_results(self, stats, word_freq, method_name, method_icon):
        """
        Display analysis results in the results area.

        Args:
            stats (dict): Dictionary containing text statistics
            word_freq (dict): Dictionary containing word frequencies
            method_name (str): Name of the analysis method used
            method_icon (str): Icon for the method
        """
        self.results_area.config(state='normal')
        self.results_area.delete(1.0, tk.END)

        # Header
        separator = "=" * 75
        result_text = f"{separator}\n"
        result_text += f"{method_icon} TEXT ANALYSIS RESULTS - {method_name}\n"
        result_text += f"{separator}\n\n"

        # Language Detection Section - Hidden in mini mode
        if self.detected_language and not self.mini_project_mode:
            # Get language display name
            lang_display = LANGUAGE_NAMES.get(
                self.detected_language, self.detected_language.upper())

            # Determine if mixed language
            is_mixed = len(
                [d for d in self.language_distribution.values() if d > 0.1]) > 1

            result_text += "🌐 LANGUAGE DETECTION:\n"
            result_text += f"{'-' * 75}\n"

            if is_mixed:
                # Show all detected languages
                result_text += "Detected Language:                 MIXED LANGUAGES\n"
                result_text += "Language Distribution:\n"
                for lang_code, percentage in sorted(
                    self.language_distribution.items(),
                    key=lambda x: x[1],
                    reverse=True
                ):
                    if percentage > 0.05:  # Show languages with >5%
                        lang_name = LANGUAGE_NAMES.get(
                            lang_code, lang_code.upper())
                        result_text += f"  • {lang_name:<20} {percentage*100:>6.1f}%\n"
            else:
                # Single language
                result_text += f"Detected Language:                 {lang_display}\n"
                result_text += f"Confidence:                        {self.language_confidence*100:.1f}%\n"

            result_text += "\n"

        # Statistics Section
        result_text += "📈 TEXT STATISTICS:\n"
        result_text += f"{'-' * 75}\n"
        result_text += f"Total characters (with spaces):    {stats['total_chars_with_spaces']:,}\n"
        result_text += f"Total characters (without spaces): {stats['total_chars_without_spaces']:,}\n"
        result_text += f"Total words:                       {stats['total_words']:,}\n"
        result_text += f"Total sentences:                   {stats['total_sentences']:,}\n"
        result_text += f"Total paragraphs:                  {stats['total_paragraphs']:,}\n"
        result_text += f"Total unique words:                {len(word_freq):,}\n"

        # Top 10 Words Section
        result_text += f"\n{separator}\n"
        result_text += "🏆 TOP 10 MOST COMMON WORDS:\n"
        result_text += f"{separator}\n\n"

        top_words = sorted(word_freq.items(),
                           key=lambda x: x[1], reverse=True)[:10]

        if top_words:
            # Calculate max word length for formatting
            max_word_len = max(len(word) for word, _ in top_words)

            for idx, (word, frequency) in enumerate(top_words, 1):
                # Scale to max
                bar_length = int(frequency / top_words[0][1] * 30)
                bar = "█" * bar_length
                result_text += f"{idx:2d}. {word:<{max_word_len}} : {frequency:4d} {bar}\n"
        else:
            result_text += "No words found.\n"

        result_text += f"\n{separator}\n"
        result_text += f"✓ Analysis completed successfully using {method_name} method!\n"
        result_text += f"{separator}\n"

        self.results_area.insert(1.0, result_text)
        self.results_area.config(state='disabled')

    def create_visualization(self, stats, word_freq, method_name):
        """
        Create comprehensive detailed visualization with multiple charts.

        Args:
            stats (dict): Dictionary containing text statistics
            word_freq (dict): Dictionary containing word frequencies
            method_name (str): Name of the analysis method used
        """
        # Create new window for detailed visualization
        viz_window = tk.Toplevel(self.root)
        viz_window.title(f"📊 Detailed Analysis Visualization - {method_name}")
        viz_window.geometry("1400x900")

        # Create notebook for tabs
        notebook = ttk.Notebook(viz_window)
        notebook.pack(fill='both', expand=True, padx=10, pady=10)

        # Tab 1: Overview Charts - Always shown
        overview_frame = ttk.Frame(notebook)
        notebook.add(overview_frame, text="📊 Overview")
        self._create_overview_charts(
            overview_frame, stats, word_freq, method_name)

        # Advanced tabs - Hidden in mini mode
        if not self.mini_project_mode:
            # Tab 2: Word Analysis
            word_frame = ttk.Frame(notebook)
            notebook.add(word_frame, text="📝 Word Analysis")
            self._create_word_analysis(word_frame, word_freq, stats)

            # Tab 3: Detailed Statistics
            detail_frame = ttk.Frame(notebook)
            notebook.add(detail_frame, text="📋 Detailed Report")
            self._create_detailed_report(
                detail_frame, stats, word_freq, method_name)

            # Tab 4: Language Info (if language detected)
            if self.detected_language:
                lang_frame = ttk.Frame(notebook)
                notebook.add(lang_frame, text="🌐 Language Info")
                self._create_language_info(lang_frame, stats, word_freq)

    def _create_overview_charts(self, parent, stats, word_freq, method_name):
        """Create overview charts with multiple visualizations."""
        # Get theme colors
        theme = self.themes[self.current_theme]
        fig_bg = theme['bg'] if self.current_theme == 'dark' else '#f8f9fa'
        text_color = theme['fg']

        # Create figure with subplots
        fig = Figure(figsize=(14, 8), facecolor=fig_bg)

        # 1. Main Statistics Bar Chart (top left)
        ax1 = fig.add_subplot(2, 3, 1)
        ax1.set_facecolor(fig_bg)
        unique_words = len(word_freq)
        categories = ['Words', 'Sentences', 'Paragraphs', 'Unique\nWords']
        values = [stats['total_words'], stats['total_sentences'],
                  stats['total_paragraphs'], unique_words]
        colors = ['#3498db', '#e74c3c', '#2ecc71', '#f39c12']
        bars = ax1.bar(categories, values, color=colors,
                       alpha=0.8, edgecolor='black', linewidth=1.5)
        ax1.set_title('Main Statistics', fontsize=12,
                      fontweight='bold', color=text_color)
        ax1.set_ylabel('Count', fontsize=10,
                       fontweight='bold', color=text_color)
        ax1.tick_params(colors=text_color)
        ax1.grid(axis='y', alpha=0.3, linestyle='--')

        for bar, val in zip(bars, values):
            height = bar.get_height()
            ax1.text(bar.get_x() + bar.get_width()/2., height,
                     f'{val:,}', ha='center', va='bottom', fontweight='bold', fontsize=9, color=text_color)

        # 2. Character Analysis (top middle)
        ax2 = fig.add_subplot(2, 3, 2)
        ax2.set_facecolor(fig_bg)
        char_labels = ['With\nSpaces', 'Without\nSpaces']
        char_values = [stats['total_chars_with_spaces'],
                       stats['total_chars_without_spaces']]
        colors2 = ['#9b59b6', '#e74c3c']
        bars2 = ax2.bar(char_labels, char_values, color=colors2,
                        alpha=0.8, edgecolor='black', linewidth=1.5)
        ax2.set_title('Character Count', fontsize=12,
                      fontweight='bold', color=text_color)
        ax2.set_ylabel('Characters', fontsize=10,
                       fontweight='bold', color=text_color)
        ax2.tick_params(colors=text_color)
        ax2.grid(axis='y', alpha=0.3, linestyle='--')

        for bar, val in zip(bars2, char_values):
            height = bar.get_height()
            ax2.text(bar.get_x() + bar.get_width()/2., height,
                     f'{val:,}', ha='center', va='bottom', fontweight='bold', fontsize=9, color=text_color)

        # 3. Word Length Distribution (top right)
        ax3 = fig.add_subplot(2, 3, 3)
        ax3.set_facecolor(fig_bg)
        word_lengths = [len(word) for word in word_freq.keys()]
        if word_lengths:
            length_dist = Counter(word_lengths)
            lengths = sorted(length_dist.keys())
            counts = [length_dist[l] for l in lengths]
            ax3.bar(lengths, counts, color='#1abc9c',
                    alpha=0.8, edgecolor='black', linewidth=1.5)
            ax3.set_title('Word Length Distribution',
                          fontsize=12, fontweight='bold', color=text_color)
            ax3.set_xlabel('Word Length (characters)',
                           fontsize=10, color=text_color)
            ax3.set_ylabel('Frequency', fontsize=10,
                           fontweight='bold', color=text_color)
            ax3.tick_params(colors=text_color)
            ax3.grid(axis='y', alpha=0.3, linestyle='--')

        # 4. Top 10 Words (bottom left - wider)
        ax4 = fig.add_subplot(2, 3, (4, 5))
        ax4.set_facecolor(fig_bg)
        top_words = sorted(word_freq.items(),
                           key=lambda x: x[1], reverse=True)[:10]
        if top_words:
            words, freqs = zip(*top_words)
            colors4 = plt.colormaps['Spectral'](
                [i/len(words) for i in range(len(words))])
            bars4 = ax4.barh(range(len(words)), freqs, color=colors4,
                             alpha=0.8, edgecolor='black', linewidth=1.5)
            ax4.set_yticks(range(len(words)))
            ax4.set_yticklabels(words, fontsize=9)
            ax4.set_xlabel('Frequency', fontsize=10,
                           fontweight='bold', color=text_color)
            ax4.set_title('Top 10 Most Common Words',
                          fontsize=12, fontweight='bold', color=text_color)
            ax4.tick_params(colors=text_color)
            ax4.grid(axis='x', alpha=0.3, linestyle='--')
            ax4.invert_yaxis()

            for i, (bar, freq) in enumerate(zip(bars4, freqs)):
                width = bar.get_width()
                ax4.text(width, i, f' {freq}', va='center',
                         fontweight='bold', fontsize=9, color=text_color)

        # 5. Pie Chart - Text Composition (bottom right)
        ax5 = fig.add_subplot(2, 3, 6)
        ax5.set_facecolor(fig_bg)
        pie_labels = ['Words', 'Sentences', 'Paragraphs']
        pie_values = [stats['total_words'],
                      stats['total_sentences'], stats['total_paragraphs']]
        colors5 = ['#3498db', '#e74c3c', '#2ecc71']
        ax5.pie(pie_values, labels=pie_labels, colors=colors5,
                autopct='%1.1f%%', startangle=90, textprops={'fontsize': 9, 'fontweight': 'bold', 'color': text_color})
        ax5.set_title('Text Composition', fontsize=12,
                      fontweight='bold', color=text_color)

        fig.suptitle(f'Comprehensive Text Analysis - {method_name} Method',
                     fontsize=16, fontweight='bold', y=0.98, color=text_color)
        fig.tight_layout(rect=[0, 0, 1, 0.96])

        # Embed in tkinter
        canvas = FigureCanvasTkAgg(fig, parent)
        canvas.draw()
        canvas.get_tk_widget().pack(fill='both', expand=True)

    def _create_word_analysis(self, parent, word_freq, stats):
        """Create detailed word frequency analysis charts."""
        # Get theme colors
        theme = self.themes[self.current_theme]
        fig_bg = theme['bg'] if self.current_theme == 'dark' else '#f8f9fa'
        text_color = theme['fg']

        fig = Figure(figsize=(14, 8), facecolor=fig_bg)

        # Top 20 words
        ax1 = fig.add_subplot(2, 1, 1)
        ax1.set_facecolor(fig_bg)
        top_words = sorted(word_freq.items(),
                           key=lambda x: x[1], reverse=True)[:20]
        if top_words:
            words, freqs = zip(*top_words)
            colors = plt.colormaps['viridis'](
                [i/len(words) for i in range(len(words))])
            bars = ax1.bar(range(len(words)), freqs, color=colors,
                           alpha=0.8, edgecolor='black', linewidth=1.5)
            ax1.set_xticks(range(len(words)))
            ax1.set_xticklabels(words, rotation=45, ha='right', fontsize=9)
            ax1.set_ylabel('Frequency', fontsize=11,
                           fontweight='bold', color=text_color)
            ax1.set_title('Top 20 Most Frequent Words',
                          fontsize=14, fontweight='bold', color=text_color)
            ax1.tick_params(colors=text_color)
            ax1.grid(axis='y', alpha=0.3, linestyle='--')

            for bar, freq in zip(bars, freqs):
                height = bar.get_height()
                ax1.text(bar.get_x() + bar.get_width()/2., height,
                         f'{freq}', ha='center', va='bottom', fontweight='bold', fontsize=8, color=text_color)

        # Word frequency distribution
        ax2 = fig.add_subplot(2, 2, 3)
        ax2.set_facecolor(fig_bg)
        freq_dist = Counter(word_freq.values())
        frequencies = sorted(freq_dist.keys())[:15]  # Top 15 frequency levels
        counts = [freq_dist[f] for f in frequencies]
        ax2.bar(frequencies, counts, color='#e67e22',
                alpha=0.8, edgecolor='black', linewidth=1.5)
        ax2.set_xlabel('Word Frequency', fontsize=10,
                       fontweight='bold', color=text_color)
        ax2.set_ylabel('Number of Words', fontsize=10,
                       fontweight='bold', color=text_color)
        ax2.set_title('Frequency Distribution', fontsize=12,
                      fontweight='bold', color=text_color)
        ax2.tick_params(colors=text_color)
        ax2.grid(axis='y', alpha=0.3, linestyle='--')

        # Unique vs Total Words
        ax3 = fig.add_subplot(2, 2, 4)
        ax3.set_facecolor(fig_bg)
        labels = ['Unique\nWords', 'Total\nWords', 'Repeated\nWords']
        values = [len(word_freq), stats['total_words'],
                  stats['total_words'] - len(word_freq)]
        colors3 = ['#f39c12', '#3498db', '#e74c3c']
        bars3 = ax3.bar(labels, values, color=colors3,
                        alpha=0.8, edgecolor='black', linewidth=1.5)
        ax3.set_ylabel('Count', fontsize=10,
                       fontweight='bold', color=text_color)
        ax3.set_title('Word Repetition Analysis',
                      fontsize=12, fontweight='bold', color=text_color)
        ax3.tick_params(colors=text_color)
        ax3.grid(axis='y', alpha=0.3, linestyle='--')

        for bar, val in zip(bars3, values):
            height = bar.get_height()
            ax3.text(bar.get_x() + bar.get_width()/2., height,
                     f'{val:,}', ha='center', va='bottom', fontweight='bold', fontsize=10, color=text_color)

        fig.tight_layout()

        canvas = FigureCanvasTkAgg(fig, parent)
        canvas.draw()
        canvas.get_tk_widget().pack(fill='both', expand=True)

    def _create_detailed_report(self, parent, stats, word_freq, method_name):
        """Create detailed textual report with clickable sections."""
        # Create main frame with scrollbar
        main_frame = ttk.Frame(parent)
        main_frame.pack(fill='both', expand=True, padx=10, pady=10)

        # Title
        title_label = ttk.Label(
            main_frame,
            text=f"📋 Comprehensive Analysis Report - {method_name}",
            font=('Helvetica', 16, 'bold')
        )
        title_label.pack(pady=(0, 15))

        # Create scrolled text with proper colors based on theme
        theme = self.themes[self.current_theme]
        report_text = scrolledtext.ScrolledText(
            main_frame,
            wrap=tk.WORD,
            width=100,
            height=30,
            font=('Courier', 10),
            background=theme['text_bg'],
            foreground=theme['text_fg'],
            insertbackground=theme['text_fg'],
            borderwidth=2,
            relief=tk.GROOVE
        )
        report_text.pack(fill='both', expand=True)

        # Generate detailed report
        report = self._generate_detailed_text_report(
            stats, word_freq, method_name)
        report_text.insert(1.0, report)
        report_text.config(state='disabled')

    def _generate_detailed_text_report(self, stats, word_freq, method_name):
        """Generate comprehensive text report."""
        report = []
        sep = "=" * 80
        subsep = "-" * 80

        report.append(sep)
        report.append("  COMPREHENSIVE TEXT ANALYSIS REPORT")
        report.append(f"  Analysis Method: {method_name}")
        report.append(sep)
        report.append("")

        # Section 1: Basic Statistics
        report.append("📊 BASIC STATISTICS")
        report.append(subsep)
        report.append(
            f"Total Characters (with spaces):     {stats['total_chars_with_spaces']:>10,}")
        report.append(
            f"Total Characters (without spaces):  {stats['total_chars_without_spaces']:>10,}")
        report.append(
            f"Spaces and whitespace:              {stats['total_chars_with_spaces'] - stats['total_chars_without_spaces']:>10,}")
        report.append(
            f"Total Words:                        {stats['total_words']:>10,}")
        report.append(
            f"Total Sentences:                    {stats['total_sentences']:>10,}")
        report.append(
            f"Total Paragraphs:                   {stats['total_paragraphs']:>10,}")
        report.append(
            f"Unique Words:                       {len(word_freq):>10,}")
        report.append("")

        # Section 2: Calculated Metrics
        report.append("🔢 CALCULATED METRICS")
        report.append(subsep)
        if stats['total_words'] > 0:
            avg_word_len = stats['total_chars_without_spaces'] / \
                stats['total_words']
            report.append(
                f"Average Word Length:                {avg_word_len:>10.2f} characters")
        if stats['total_sentences'] > 0:
            avg_words_per_sent = stats['total_words'] / \
                stats['total_sentences']
            report.append(
                f"Average Words per Sentence:         {avg_words_per_sent:>10.2f} words")
        if stats['total_paragraphs'] > 0:
            avg_sent_per_para = stats['total_sentences'] / \
                stats['total_paragraphs']
            report.append(
                f"Average Sentences per Paragraph:    {avg_sent_per_para:>10.2f} sentences")
        if stats['total_words'] > 0:
            lexical_diversity = (len(word_freq) / stats['total_words']) * 100
            report.append(
                f"Lexical Diversity:                  {lexical_diversity:>10.2f}%")
        report.append("")

        # Section 3: Word Frequency Analysis
        report.append("📝 WORD FREQUENCY ANALYSIS")
        report.append(subsep)
        top_20 = sorted(word_freq.items(),
                        key=lambda x: x[1], reverse=True)[:20]
        report.append(
            f"{'Rank':<6} {'Word':<20} {'Frequency':<12} {'Percentage':<12} {'Bar Chart'}")
        report.append(subsep)

        for idx, (word, freq) in enumerate(top_20, 1):
            percentage = (freq / stats['total_words']) * 100
            bar_length = int((freq / top_20[0][1]) * 40)
            bar = "█" * bar_length
            report.append(
                f"{idx:<6} {word:<20} {freq:<12,} {percentage:<11.2f}% {bar}")
        report.append("")

        # Section 4: Word Length Analysis
        report.append("📏 WORD LENGTH ANALYSIS")
        report.append(subsep)
        word_lengths = [len(word) for word in word_freq.keys()]
        if word_lengths:
            length_dist = Counter(word_lengths)
            report.append(f"{'Length':<10} {'Count':<10} {'Percentage'}")
            report.append(subsep[:40])
            for length in sorted(length_dist.keys())[:15]:
                count = length_dist[length]
                percentage = (count / len(word_freq)) * 100
                report.append(f"{length:<10} {count:<10} {percentage:>6.2f}%")
        report.append("")

        # Section 5: Rare Words
        report.append("🔍 RARE WORDS (appearing only once)")
        report.append(subsep)
        rare_words = [word for word, freq in word_freq.items() if freq == 1]
        report.append(f"Total rare words: {len(rare_words)}")
        if rare_words:
            report.append(f"Examples: {', '.join(sorted(rare_words)[:30])}")
            if len(rare_words) > 30:
                report.append(f"... and {len(rare_words) - 30} more")
        report.append("")

        # Section 6: Summary
        report.append("📋 SUMMARY")
        report.append(subsep)
        report.append(
            f"This text contains {stats['total_words']:,} words across {stats['total_sentences']:,} sentences")
        report.append(
            f"and {stats['total_paragraphs']:,} paragraphs. The vocabulary includes {len(word_freq):,} unique")
        if stats['total_words'] > 0:
            lexical_div = (len(word_freq)/stats['total_words'])*100
        else:
            lexical_div = 0.0
        report.append(
            f"words, with a lexical diversity of {lexical_div:.2f}%.")
        report.append("")
        report.append(sep)
        report.append("✓ Analysis completed successfully!")
        report.append(sep)

        return '\n'.join(report)

    def _create_language_info(self, parent, stats, word_freq):
        """Create detailed language information tab."""
        # Get theme colors
        theme = self.themes[self.current_theme]
        fig_bg = theme['bg'] if self.current_theme == 'dark' else '#f8f9fa'
        text_color = theme['fg']

        # Create main container
        main_container = ttk.Frame(parent)
        main_container.pack(fill='both', expand=True, padx=10, pady=10)

        # Title
        title_label = ttk.Label(
            main_container,
            text="🌐 Language Analysis & Detection Information",
            font=('Helvetica', 16, 'bold')
        )
        title_label.pack(pady=(0, 15))

        # Create figure with subplots
        fig = Figure(figsize=(14, 8), facecolor=fig_bg)

        # Get language display name
        lang_display = LANGUAGE_NAMES.get(
            self.detected_language, self.detected_language.upper())

        # Check if mixed language
        is_mixed = len(
            [d for d in self.language_distribution.values() if d > 0.1]) > 1

        # 1. Language Distribution Pie Chart
        ax1 = fig.add_subplot(2, 2, 1)
        ax1.set_facecolor(fig_bg)

        # Filter out very small percentages
        display_dist = {
            k: v for k,
            v in self.language_distribution.items() if v > 0.02}
        if display_dist:
            labels = [LANGUAGE_NAMES.get(
                code, code.upper()) for code in display_dist.keys()]
            sizes = list(display_dist.values())
            colors = plt.colormaps['Set3'](range(len(labels)))

            ax1.pie(sizes, labels=labels, autopct='%1.1f%%',
                    startangle=90, colors=colors,
                    textprops={'fontsize': 9, 'fontweight': 'bold', 'color': text_color})
            ax1.set_title('Language Distribution',
                          fontsize=12, fontweight='bold', color=text_color)

        # 2. Language Confidence Bar
        ax2 = fig.add_subplot(2, 2, 2)
        ax2.set_facecolor(fig_bg)

        if not is_mixed:
            categories = ['Confidence', 'Uncertainty']
            values = [self.language_confidence, 1 - self.language_confidence]
            colors2 = ['#2ecc71', '#e74c3c']

            bars = ax2.barh(categories, values, color=colors2, alpha=0.8)
            ax2.set_xlim(0, 1)
            ax2.set_title(f'Detection Confidence - {lang_display}',
                          fontsize=12, fontweight='bold', color=text_color)
            ax2.set_xlabel('Confidence Level',
                           fontsize=10, color=text_color)
            ax2.tick_params(colors=text_color)
            ax2.grid(axis='x', alpha=0.3, linestyle='--')

            # Add percentage labels
            for bar, val in zip(bars, values):
                width = bar.get_width()
                ax2.text(width / 2, bar.get_y() + bar.get_height() / 2,
                         f'{val*100:.1f}%', ha='center', va='center',
                         fontweight='bold', fontsize=10, color='white')
        else:
            # Show top languages in mixed text
            top_langs = sorted(
                self.language_distribution.items(),
                key=lambda x: x[1],
                reverse=True)[
                :5]
            langs = [LANGUAGE_NAMES.get(code, code.upper())
                     for code, _ in top_langs]
            percentages = [pct * 100 for _, pct in top_langs]

            bars = ax2.barh(range(len(langs)), percentages,
                            color=plt.colormaps['viridis'](range(len(langs))), alpha=0.8)
            ax2.set_yticks(range(len(langs)))
            ax2.set_yticklabels(langs)
            ax2.set_title('Top Languages in Mixed Text',
                          fontsize=12, fontweight='bold', color=text_color)
            ax2.set_xlabel('Percentage (%)', fontsize=10, color=text_color)
            ax2.tick_params(colors=text_color)
            ax2.grid(axis='x', alpha=0.3, linestyle='--')

            # Add percentage labels
            for bar, pct in zip(bars, percentages):
                width = bar.get_width()
                ax2.text(width, bar.get_y() + bar.get_height() / 2,
                         f' {pct:.1f}%', ha='left', va='center',
                         fontweight='bold', fontsize=9, color=text_color)

        # 3. Character Set Analysis
        ax3 = fig.add_subplot(2, 2, 3)
        ax3.set_facecolor(fig_bg)

        # Analyze character types
        text_sample = self.text_area.get(1.0, tk.END)
        char_types = {
            'Latin': sum(1 for c in text_sample if ord(c) < 0x0250 and c.isalpha()),
            'Cyrillic': sum(1 for c in text_sample if 0x0400 <= ord(c) <= 0x04FF),
            'Arabic': sum(1 for c in text_sample if 0x0600 <= ord(c) <= 0x06FF),
            'Chinese': sum(1 for c in text_sample if 0x4E00 <= ord(c) <= 0x9FFF),
            'Japanese': sum(1 for c in text_sample if (0x3040 <= ord(c) <= 0x309F) or (0x30A0 <= ord(c) <= 0x30FF)),
            'Numbers': sum(1 for c in text_sample if c.isdigit()),
            'Punctuation': sum(1 for c in text_sample if c in '.,!?;:'),
        }

        # Filter out zero counts
        char_types = {k: v for k, v in char_types.items() if v > 0}

        if char_types:
            categories = list(char_types.keys())
            counts = list(char_types.values())
            colors3 = plt.colormaps['tab10'](range(len(categories)))

            bars = ax3.bar(categories, counts, color=colors3, alpha=0.8)
            ax3.set_title('Character Set Distribution',
                          fontsize=12, fontweight='bold', color=text_color)
            ax3.set_ylabel('Count', fontsize=10, color=text_color)
            ax3.tick_params(axis='x', rotation=45, colors=text_color)
            ax3.tick_params(axis='y', colors=text_color)
            ax3.grid(axis='y', alpha=0.3, linestyle='--')

            # Add count labels
            for bar in bars:
                height = bar.get_height()
                ax3.text(bar.get_x() + bar.get_width() / 2., height,
                         f'{int(height):,}', ha='center', va='bottom',
                         fontweight='bold', fontsize=8, color=text_color)

        # 4. Stop Words Analysis
        ax4 = fig.add_subplot(2, 2, 4)
        ax4.set_facecolor(fig_bg)

        # Count stop words for detected language
        if self.detected_language in STOP_WORDS:
            stop_words_list = STOP_WORDS[self.detected_language]

            stop_word_count = sum(
                word_freq[w] for w in word_freq if w.lower() in stop_words_list)
            content_word_count = stats['total_words'] - stop_word_count

            categories = ['Stop Words', 'Content Words']
            values = [stop_word_count, content_word_count]
            colors4 = ['#e74c3c', '#3498db']

            bars = ax4.bar(categories, values, color=colors4, alpha=0.8)
            ax4.set_title(
                f'Stop Words vs Content Words ({lang_display})',
                fontsize=12,
                fontweight='bold',
                color=text_color)
            ax4.set_ylabel('Word Count', fontsize=10, color=text_color)
            ax4.tick_params(colors=text_color)
            ax4.grid(axis='y', alpha=0.3, linestyle='--')

            # Add count and percentage labels
            for bar, val in zip(bars, values):
                height = bar.get_height()
                pct = (val / stats['total_words']) * 100
                ax4.text(bar.get_x() + bar.get_width() / 2., height,
                         f'{val:,}\n({pct:.1f}%)', ha='center', va='bottom',
                         fontweight='bold', fontsize=9, color=text_color)
        else:
            ax4.text(0.5, 0.5, 'Stop words analysis\nnot available\nfor this language',
                     ha='center', va='center', fontsize=12, color=text_color,
                     transform=ax4.transAxes)
            ax4.set_title('Stop Words Analysis',
                          fontsize=12, fontweight='bold', color=text_color)
            ax4.axis('off')

        fig.suptitle(
            f'Language Information - Detected: {lang_display}{"  (MIXED)" if is_mixed else ""}',
            fontsize=16,
            fontweight='bold',
            y=0.98,
            color=text_color)
        fig.tight_layout(rect=[0, 0, 1, 0.96])

        # Embed in tkinter
        canvas = FigureCanvasTkAgg(fig, main_container)
        canvas.draw()
        canvas.get_tk_widget().pack(fill='both', expand=True)

    def open_settings(self):
        """Open settings window for theme selection."""
        settings_window = tk.Toplevel(self.root)
        settings_window.title("⚙️ Settings")
        settings_window.geometry("450x380")
        settings_window.resizable(False, False)

        # Center the window
        settings_window.update_idletasks()
        x = (settings_window.winfo_screenwidth() // 2) - 225
        y = (settings_window.winfo_screenheight() // 2) - 190
        settings_window.geometry(f'450x380+{x}+{y}')

        # Main frame
        main_frame = ttk.Frame(settings_window, padding="20")
        main_frame.pack(fill='both', expand=True)

        # Title
        title_label = ttk.Label(
            main_frame,
            text="⚙️ Application Settings",
            font=('Helvetica', 16, 'bold')
        )
        title_label.pack(pady=(0, 20))

        # Mini Project Mode (Teacher Mode)
        mini_frame = ttk.LabelFrame(
            main_frame, text="🎓 Mini Project Mode (For Teachers)", padding="15")
        mini_frame.pack(fill='x', pady=(0, 15))

        # Mini mode variable
        mini_var = tk.BooleanVar(value=self.mini_project_mode)

        # Mini mode checkbox
        mini_check = ttk.Checkbutton(
            mini_frame,
            text="📚 Enable Mini Project Mode",
            variable=mini_var
        )
        mini_check.pack(anchor='w', pady=5)

        # Description label
        desc_label = ttk.Label(
            mini_frame,
            text="When enabled, only basic features from the assignment\n"
            "will be available (drag & drop files, functional/OOP methods,\n"
            "simple visualization). Advanced features will be hidden.",
            font=('Helvetica', 9),
            foreground='#7f8c8d',
            wraplength=380,
            justify='left'
        )
        desc_label.pack(anchor='w', padx=(25, 0), pady=(5, 0))

        # Theme selection
        theme_frame = ttk.LabelFrame(
            main_frame, text="🎨 Theme Selection", padding="15")
        theme_frame.pack(fill='x', pady=(0, 20))

        # Theme variable
        theme_var = tk.StringVar(value=self.current_theme)

        # Auto-apply theme changes
        def on_theme_change(*args):
            new_theme = theme_var.get()
            if new_theme != self.current_theme:
                self.current_theme = new_theme
                self.apply_theme_to_app()
                messagebox.showinfo(
                    "Theme Changed",
                    f"Theme changed to: {'Light' if new_theme == 'light' else 'Dark'}"
                )

        theme_var.trace('w', on_theme_change)

        # Light theme radio button
        light_radio = ttk.Radiobutton(
            theme_frame,
            text="☀️ Light Theme",
            variable=theme_var,
            value='light'
        )
        light_radio.pack(anchor='w', pady=5)

        # Dark theme radio button
        dark_radio = ttk.Radiobutton(
            theme_frame,
            text="🌙 Dark Theme",
            variable=theme_var,
            value='dark'
        )
        dark_radio.pack(anchor='w', pady=5)

        # Auto-apply mini mode changes
        def on_mini_mode_change():
            new_mini_mode = mini_var.get()
            if new_mini_mode != self.mini_project_mode:
                self.mini_project_mode = new_mini_mode
                self.toggle_mini_project_mode()

        mini_check.config(command=on_mini_mode_change)

        # Close button at bottom
        close_btn = ttk.Button(
            main_frame,
            text="Close",
            command=settings_window.destroy
        )
        close_btn.pack(pady=20)

    def apply_theme_to_app(self):
        """Apply the selected theme to the application."""
        theme = self.themes[self.current_theme]

        # Update text area
        self.text_area.config(
            background=theme['text_bg'],
            foreground=theme['text_fg'],
            insertbackground=theme['text_fg']
        )

        # Update results area
        self.results_area.config(
            background=theme['text_bg'],
            foreground=theme['text_fg']
        )

        # Update root background
        self.root.config(bg=theme['bg'])

    def toggle_mini_project_mode(self):
        """Toggle between mini project mode and advanced mode without restart."""
        if self.mini_project_mode:
            # MINI PROJECT MODE: Hide advanced features

            # Hide UI language selector frame
            if hasattr(self, 'ui_lang_frame'):
                self.ui_lang_frame.pack_forget()

            # Hide download modules button
            if hasattr(self, 'download_btn'):
                self.download_btn.pack_forget()

            # Hide analysis language selector
            if hasattr(self, 'analysis_lang_label'):
                self.analysis_lang_label.pack_forget()
            if hasattr(self, 'analysis_lang_combo'):
                self.analysis_lang_combo.pack_forget()

            # Update title to show mini mode
            if hasattr(self, 'title_label'):
                self.title_label.config(
                    text="📊 Text Analysis - Mini Project Mode")
            if hasattr(self, 'subtitle_label'):
                self.subtitle_label.config(
                    text="Basic Implementation - Functional & OOP Methods")

            # Update instructions to simpler version
            if hasattr(self, 'inst_label'):
                instructions_text = "💡 Enter text OR load file (TXT, RTF, DOCX, PDF supported)"
                if HAS_DND:
                    instructions_text += " OR drag & drop files here"
                self.inst_label.config(text=instructions_text)

        else:
            # ADVANCED MODE: Show all features

            # Show UI language selector frame
            if hasattr(self, 'ui_lang_frame'):
                self.ui_lang_frame.pack(side=tk.RIGHT, padx=(5, 0))

            # Show download modules button
            if hasattr(self, 'download_btn'):
                self.download_btn.pack(side=tk.RIGHT, padx=(5, 0))

            # Show analysis language selector
            if hasattr(self, 'analysis_lang_label'):
                self.analysis_lang_label.pack(side=tk.LEFT, padx=(15, 5))
            if hasattr(self, 'analysis_lang_combo'):
                self.analysis_lang_combo.pack(side=tk.LEFT)

            # Restore original title
            if hasattr(self, 'title_label'):
                self.title_label.config(text=self.tr('app_title'))
            if hasattr(self, 'subtitle_label'):
                self.subtitle_label.config(text=self.tr('subtitle'))

            # Restore full instructions
            if hasattr(self, 'inst_label'):
                instructions_text = self.tr('instructions')
                if HAS_DND:
                    instructions_text += self.tr('instructions_dnd')
                self.inst_label.config(text=instructions_text)

        # Show confirmation message
        mode_text = "Mini Project Mode" if self.mini_project_mode else "Advanced Mode"
        messagebox.showinfo(
            "Mode Changed",
            f"Mode changed to: {mode_text}\n\n"
            "Interface has been updated successfully!"
        )

    def open_download_manager(self):
        """Open module download manager window."""
        download_window = tk.Toplevel(self.root)
        download_window.title("📦 Module Download Manager")
        download_window.geometry("600x400")
        download_window.resizable(False, False)

        # Center the window
        download_window.update_idletasks()
        x = (download_window.winfo_screenwidth() // 2) - 300
        y = (download_window.winfo_screenheight() // 2) - 200
        download_window.geometry(f'600x400+{x}+{y}')

        # Main frame
        main_frame = ttk.Frame(download_window, padding="20")
        main_frame.pack(fill='both', expand=True)

        # Title
        title_label = ttk.Label(
            main_frame,
            text="📦 Python Module Manager",
            font=('Helvetica', 16, 'bold')
        )
        title_label.pack(pady=(0, 10))

        # Subtitle
        subtitle_label = ttk.Label(
            main_frame,
            text="Install optional modules for enhanced features",
            font=('Helvetica', 10),
            foreground='#7f8c8d'
        )
        subtitle_label.pack(pady=(0, 20))

        # Download All button
        download_all_frame = ttk.Frame(main_frame)
        download_all_frame.pack(fill='x', pady=(0, 15))

        def install_all():
            modules_to_install = []
            if not HAS_DOCX:
                modules_to_install.append('python-docx')
            if not HAS_PDF:
                modules_to_install.append('PyPDF2')
            if not HAS_RTF:
                modules_to_install.append('striprtf')
            if not HAS_DND:
                modules_to_install.append('tkinterdnd2')

            if not modules_to_install:
                messagebox.showinfo(
                    "All Installed", "All modules are already installed!")
                return

            result = messagebox.askyesno(
                "Install All Modules",
                f"This will install {len(modules_to_install)} modules:\n\n" +
                "\n".join(f"• {m}" for m in modules_to_install) +
                "\n\nProceed with installation?"
            )

            if result:
                self.install_modules(modules_to_install, download_window)

        download_all_btn = ttk.Button(
            download_all_frame,
            text="⬇️ DOWNLOAD ALL",
            command=install_all,
            width=20
        )
        download_all_btn.pack()

        # Separator
        ttk.Separator(main_frame, orient='horizontal').pack(fill='x', pady=15)

        # Modules list frame
        modules_frame = ttk.LabelFrame(
            main_frame, text="📋 Available Modules", padding="15")
        modules_frame.pack(fill='both', expand=True)

        # Module definitions
        modules = [
            {
                'name': 'python-docx',
                'description': 'Read Microsoft Word (.docx) files',
                'installed': HAS_DOCX
            },
            {
                'name': 'PyPDF2',
                'description': 'Read PDF documents',
                'installed': HAS_PDF
            },
            {
                'name': 'striprtf',
                'description': 'Read Rich Text Format (.rtf) files',
                'installed': HAS_RTF
            },
            {
                'name': 'tkinterdnd2',
                'description': 'Enable drag & drop functionality',
                'installed': HAS_DND
            }
        ]

        # Create module entries
        for module in modules:
            module_frame = ttk.Frame(modules_frame)
            module_frame.pack(fill='x', pady=5)

            # Status icon
            status_icon = "✅" if module['installed'] else "❌"
            status_label = ttk.Label(
                module_frame,
                text=status_icon,
                font=('Helvetica', 12)
            )
            status_label.pack(side=tk.LEFT, padx=(0, 10))

            # Module info
            info_frame = ttk.Frame(module_frame)
            info_frame.pack(side=tk.LEFT, fill='x', expand=True)

            name_label = ttk.Label(
                info_frame,
                text=module['name'],
                font=('Helvetica', 10, 'bold')
            )
            name_label.pack(anchor='w')

            desc_label = ttk.Label(
                info_frame,
                text=module['description'],
                font=('Helvetica', 9),
                foreground='#7f8c8d'
            )
            desc_label.pack(anchor='w')

            # Install button
            if not module['installed']:
                def make_install_func(mod_name):
                    return lambda: self.install_modules([mod_name], download_window)

                install_btn = ttk.Button(
                    module_frame,
                    text="⬇️ Install",
                    command=make_install_func(module['name']),
                    width=12
                )
                install_btn.pack(side=tk.RIGHT, padx=(10, 0))
            else:
                installed_label = ttk.Label(
                    module_frame,
                    text="Installed",
                    font=('Helvetica', 9),
                    foreground='#27ae60'
                )
                installed_label.pack(side=tk.RIGHT, padx=(10, 0))

        # Close button
        close_frame = ttk.Frame(main_frame)
        close_frame.pack(fill='x', pady=(15, 0))

        close_btn = ttk.Button(
            close_frame,
            text="✖️ Close",
            command=download_window.destroy,
            width=15
        )
        close_btn.pack()

    def install_modules(self, modules, parent_window):
        """Install specified modules using pip."""
        import subprocess

        progress_window = tk.Toplevel(parent_window)
        progress_window.title("Installing...")
        progress_window.geometry("400x200")
        progress_window.resizable(False, False)

        # Center the window
        progress_window.update_idletasks()
        x = (progress_window.winfo_screenwidth() // 2) - 200
        y = (progress_window.winfo_screenheight() // 2) - 100
        progress_window.geometry(f'400x200+{x}+{y}')

        frame = ttk.Frame(progress_window, padding="20")
        frame.pack(fill='both', expand=True)

        title_label = ttk.Label(
            frame,
            text="📦 Installing Modules...",
            font=('Helvetica', 14, 'bold')
        )
        title_label.pack(pady=(0, 20))

        status_label = ttk.Label(
            frame,
            text="Please wait...",
            font=('Helvetica', 10)
        )
        status_label.pack(pady=(0, 20))

        progress_text = scrolledtext.ScrolledText(
            frame,
            wrap=tk.WORD,
            width=45,
            height=6,
            font=('Courier', 9)
        )
        progress_text.pack(fill='both', expand=True)

        def run_installation():
            try:
                for module in modules:
                    progress_text.insert(tk.END, f"Installing {module}...\n")
                    progress_text.see(tk.END)
                    progress_window.update()

                    result = subprocess.run(
                        [sys.executable, '-m', 'pip', 'install', module],
                        capture_output=True,
                        text=True,
                        check=False
                    )

                    if result.returncode == 0:
                        progress_text.insert(
                            tk.END, f"✅ {module} installed successfully!\n\n")
                    else:
                        progress_text.insert(
                            tk.END, f"❌ Failed to install {module}\n{result.stderr}\n\n")

                    progress_text.see(tk.END)
                    progress_window.update()

                status_label.config(text="✅ Installation Complete!")
                messagebox.showinfo(
                    "Installation Complete",
                    f"Successfully installed {len(modules)} module(s)!\n\n"
                    "Please restart the application to use the new modules."
                )
                progress_window.destroy()
                parent_window.destroy()

            except (subprocess.SubprocessError, OSError) as e:
                messagebox.showerror(
                    "Installation Error",
                    f"An error occurred during installation:\n\n{str(e)}"
                )
                progress_window.destroy()

        # Run installation in after callback to not block UI
        progress_window.after(100, run_installation)

    def clear_all(self):
        """Clear all text areas (input and results)."""
        # Clear input
        self.text_area.delete(1.0, tk.END)

        # Clear results
        self.results_area.config(state='normal')
        self.results_area.delete(1.0, tk.END)
        self.results_area.config(state='disabled')

        # Show confirmation
        self.root.after(100, lambda: messagebox.showinfo(
            "Cleared",
            "All text has been cleared!"
        ))


# =============================================================================
# MAIN APPLICATION ENTRY POINT
# =============================================================================
# 🐢 < "Here we go!"

def main():
    """
    Main function to run the Text Analysis Application.
    Creates the GUI window and starts the application.
    """
    # Create root window
    if HAS_DND:
        root = TkinterDnD.Tk()
    else:
        root = tk.Tk()

    # Create application
    TextAnalysisApp(root)

    # Center window on screen
    root.update_idletasks()
    width = root.winfo_width()
    height = root.winfo_height()
    x = (root.winfo_screenwidth() // 2) - (width // 2)
    y = (root.winfo_screenheight() // 2) - (height // 2)
    root.geometry(f'{width}x{height}+{x}+{y}')

    # Start the application
    root.mainloop()


# =============================================================================
# RUN THE APPLICATION
# =============================================================================
# 🐢 < "Thanks for reading my code, fellow developer!"

if __name__ == "__main__":
    print("=" * 90)
    print("  TEXT ANALYSIS APPLICATION - Enhanced Version with Multi-Format Support")
    print("=" * 90)
    print()
    print("✓ Version 1: Functional/Modular implementation loaded")
    print("✓ Version 2: Object-Oriented implementation (TextAnalyzer class) loaded")
    print("✓ GUI interface with tabbed visualization ready")
    print("✓ Advanced matplotlib charts ready")
    print()
    print("📄 SUPPORTED FILE FORMATS:")
    print("   • TXT  - Plain text files ✓")
    print("   • RTF  - Rich Text Format",
          "✓" if HAS_RTF else "⚠️  (install striprtf)")
    print("   • DOCX - Word documents",
          "✓" if HAS_DOCX else "⚠️  (install python-docx)")
    print("   • PDF  - PDF documents",
          "✓" if HAS_PDF else "⚠️  (install PyPDF2)")
    print()
    if HAS_DND:
        print("✓ Drag-and-drop support: ENABLED")
    else:
        print("⚠️  Drag-and-drop support: DISABLED (install tkinterdnd2)")
    print()
    print("📊 VISUALIZATION FEATURES:")
    print("   • Multiple detailed charts with tabs")
    print("   • Overview, Word Analysis, and Detailed Report tabs")
    print("   • Interactive graphs with comprehensive statistics")
    print()
    print("=" * 90)
    print("Starting application window...")
    print("=" * 90)
    print()

    main()