"""
Python Number Pattern Generator
Author: Molla Samser (Founder, RSK World)
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Email: hello@rskworld.in, support@rskworld.in
Phone: +91 93305 39277
Address: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India - 713147
Year: 2026
Description: Comprehensive number pattern generator using Python with GUI interface
"""

import tkinter as tk
from tkinter import ttk, messagebox, filedialog, scrolledtext
import os
import threading
import time
from datetime import datetime
from patterns import PatternAlgorithms

# Try to import PIL for image export (optional)
try:
    from PIL import Image, ImageDraw, ImageFont
    HAS_PIL = True
except ImportError:
    HAS_PIL = False


class PatternGenerator:
    """Main class for generating number patterns"""
    
    def __init__(self, root):
        self.root = root
        self.root.title("Python Number Pattern Generator - RSK World")
        self.root.geometry("800x600")
        self.root.configure(bg='#f0f0f0')

        # Initialize pattern algorithms
        self.algorithms = PatternAlgorithms()

        # Theme settings
        self.themes = {
            'default': {
                'bg': '#f0f0f0',
                'header_bg': '#2c3e50',
                'header_fg': 'white',
                'control_bg': '#ecf0f1',
                'output_bg': 'white',
                'text_fg': '#00FF00',
                'text_bg': '#000000'
            },
            'dark': {
                'bg': '#2c2c2c',
                'header_bg': '#1a1a1a',
                'header_fg': 'white',
                'control_bg': '#3c3c3c',
                'output_bg': '#1e1e1e',
                'text_fg': '#00FF00',
                'text_bg': '#000000'
            },
            'light': {
                'bg': '#ffffff',
                'header_bg': '#4a90e2',
                'header_fg': 'white',
                'control_bg': '#f8f9fa',
                'output_bg': 'white',
                'text_fg': '#0066CC',
                'text_bg': '#F8F8F8'
            }
        }
        self.current_theme = 'default'

        # Create menu bar
        self.create_menu()

        # Add header with author info
        header_frame = tk.Frame(root, bg=self.themes[self.current_theme]['header_bg'], height=60)
        header_frame.pack(fill=tk.X)
        header_frame.pack_propagate(False)
        
        header_label = tk.Label(
            header_frame,
            text="🔢 Python Number Pattern Generator",
            font=('Arial', 16, 'bold'),
            fg=self.themes[self.current_theme]['header_fg'],
            bg=self.themes[self.current_theme]['header_bg']
        )
        header_label.pack(pady=15)

        # Author info label
        author_label = tk.Label(
            header_frame,
            text="Developed by Molla Samser (RSK World) | Designed by Rima Khatun | © 2026",
            font=('Arial', 8),
            fg=self.themes[self.current_theme]['header_fg'],
            bg=self.themes[self.current_theme]['header_bg']
        )
        author_label.pack()

        self.setup_ui()

    def create_menu(self):
        """Create the application menu bar"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)

        # File menu
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="File", menu=file_menu)
        file_menu.add_command(label="Export as Text", command=self.export_pattern, accelerator="Ctrl+E")
        if HAS_PIL:
            file_menu.add_command(label="Export as PNG", command=self.export_as_png, accelerator="Ctrl+P")
        else:
            file_menu.add_command(label="Export as PNG (PIL required)", state="disabled")
        file_menu.add_separator()
        file_menu.add_command(label="Exit", command=self.root.quit, accelerator="Ctrl+Q")

        # View menu
        view_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="View", menu=view_menu)

        # Theme submenu
        theme_menu = tk.Menu(view_menu, tearoff=0)
        view_menu.add_cascade(label="Theme", menu=theme_menu)
        theme_menu.add_command(label="Default", command=lambda: self.change_theme('default'))
        theme_menu.add_command(label="Dark", command=lambda: self.change_theme('dark'))
        theme_menu.add_command(label="Light", command=lambda: self.change_theme('light'))

        view_menu.add_separator()
        view_menu.add_command(label="Analyze Pattern", command=self.analyze_pattern)

        # Help menu
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Help", menu=help_menu)
        help_menu.add_command(label="About", command=self.show_about)

        # Bind keyboard shortcuts
        self.root.bind('<Control-e>', lambda e: self.export_pattern())
        self.root.bind('<Control-p>', lambda e: self.export_as_png())
        self.root.bind('<Control-q>', lambda e: self.root.quit())

    def change_theme(self, theme_name):
        """Change the application theme"""
        if theme_name not in self.themes:
            return

        self.current_theme = theme_name
        theme = self.themes[theme_name]

        # Update root window
        self.root.configure(bg=theme['bg'])

        # Update all frames and widgets
        for widget in self.root.winfo_children():
            self._update_widget_theme(widget, theme)

        # Update status bar
        if hasattr(self, 'status_var'):
            # Find status bar and update it
            for widget in self.root.winfo_children():
                if isinstance(widget, tk.Label) and hasattr(widget, 'cget'):
                    try:
                        if widget.cget('bd') == 1:  # Status bar has border
                            widget.configure(bg='#34495e' if theme_name == 'default' else theme['header_bg'])
                    except:
                        pass

        # Recreate pattern buttons with new theme
        if hasattr(self, '_create_pattern_buttons') and hasattr(self, 'pattern_frame'):
            self._create_pattern_buttons()

        self.status_var.set(f"Theme changed to {theme_name.title()}")

    def _update_widget_theme(self, widget, theme):
        """Recursively update widget themes"""
        try:
            if isinstance(widget, tk.Frame):
                if 'header' in str(widget.cget('bg')).lower() or widget.cget('bg') in ['#2c3e50', '#1a1a1a', '#4a90e2']:
                    widget.configure(bg=theme['header_bg'])
                elif widget.cget('bg') in ['#ecf0f1', '#3c3c3c', '#f8f9fa']:
                    widget.configure(bg=theme['control_bg'])
                elif widget.cget('bg') in ['white', '#1e1e1e']:
                    widget.configure(bg=theme['output_bg'])
                else:
                    widget.configure(bg=theme['bg'])
            elif isinstance(widget, tk.Label):
                if widget.cget('fg') in ['white', '#ecf0f1']:
                    widget.configure(fg=theme['header_fg'], bg=theme['header_bg'])
                else:
                    widget.configure(bg=theme['control_bg'])
            elif isinstance(widget, tk.Button):
                widget.configure(bg=theme['control_bg'])
            elif isinstance(widget, tk.Radiobutton):
                widget.configure(bg=theme['control_bg'])
            elif isinstance(widget, tk.Spinbox):
                widget.configure(bg='white')
            elif isinstance(widget, scrolledtext.ScrolledText):
                widget.configure(bg=theme['text_bg'], fg=theme['text_fg'])
        except:
            pass

        # Recursively update children
        for child in widget.winfo_children():
            self._update_widget_theme(child, theme)

    def show_about(self):
        """Show about dialog"""
        about_text = """Python Number Pattern Generator

Version: 2.0
Author: Molla Samser (Founder, RSK World)
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Year: 2026

A comprehensive number pattern generator with GUI interface.
Features 13 different pattern types with advanced analysis tools.

© 2026 RSK World. All rights reserved."""

        messagebox.showinfo("About", about_text)
    
    def _validate_inputs(self, size, start_num):
        """Validate user inputs"""
        try:
            size = int(size)
            start_num = int(start_num)
        except ValueError:
            messagebox.showerror("Invalid Input", "Size and start number must be integers!")
            return False

        if size < 1 or size > 50:
            messagebox.showerror("Invalid Size", "Size must be between 1 and 50!")
            return False

        if start_num < 0 or start_num > 1000:
            messagebox.showerror("Invalid Start Number", "Start number must be between 0 and 1000!")
            return False

        return True

    def _generate_pattern_sync(self, pattern_type, size, start_num):
        """Generate pattern synchronously"""
        try:
            pattern = self._get_pattern(pattern_type, size, start_num)
            self._display_pattern(pattern_type, size, start_num, pattern)
        except Exception as e:
            self._handle_generation_error(str(e))

    def _generate_pattern_async(self, pattern_type, size, start_num):
        """Generate pattern asynchronously"""
        try:
            pattern = self._get_pattern(pattern_type, size, start_num)
            # Use after() to safely update GUI from background thread
            self.root.after(0, lambda: self._display_pattern(pattern_type, size, start_num, pattern))
        except Exception as e:
            self.root.after(0, lambda: self._handle_generation_error(str(e)))

    def _get_pattern(self, pattern_type, size, start_num):
        """Get pattern from algorithms"""
        if pattern_type == "pyramid":
            return self.algorithms.pyramid(size, start_num)
        elif pattern_type == "reverse_pyramid":
            return self.algorithms.reverse_pyramid(size, start_num)
        elif pattern_type == "triangle":
            return self.algorithms.triangle(size, start_num)
        elif pattern_type == "pascal":
            return self.algorithms.pascal_triangle(size)
        elif pattern_type == "floyd":
            return self.algorithms.floyd_triangle(size)
        elif pattern_type == "square":
            return self.algorithms.square(size, start_num)
        elif pattern_type == "diamond":
            return self.algorithms.diamond(size, start_num)
        elif pattern_type == "hourglass":
            return self.algorithms.hourglass(size, start_num)
        elif pattern_type == "spiral":
            return self.algorithms.spiral(size)
        elif pattern_type == "prime":
            return self.algorithms.prime_numbers(size)
        elif pattern_type == "fibonacci":
            return self.algorithms.fibonacci_triangle(size)
        elif pattern_type == "multiplication":
            return self.algorithms.multiplication_table(size)
        elif pattern_type == "magic":
            return self.algorithms.magic_square(size)
        elif pattern_type == "sierpinski":
            return self.algorithms.sierpinski_triangle(min(size, 5))  # Limit depth
        elif pattern_type == "mandelbrot":
            return self.algorithms.mandelbrot_set(min(size, 15))  # Limit size
        elif pattern_type == "hilbert":
            return self.algorithms.hilbert_curve(min(size, 4))  # Limit order
        elif pattern_type == "dragon":
            return self.algorithms.dragon_curve(min(size, 8))  # Limit iterations
        elif pattern_type == "koch":
            return self.algorithms.koch_snowflake(min(size, 3))  # Limit iterations
        elif pattern_type == "cellular":
            return self.algorithms.cellular_automaton(size, start_num if start_num <= 255 else 30)
        elif pattern_type == "binary_tree":
            return self.algorithms.binary_tree(min(size, 5))  # Limit depth
        else:
            return "Pattern not implemented yet."

    def _display_pattern(self, pattern_type, size, start_num, pattern):
        """Display the generated pattern"""
        # Add header information
        header = f"Pattern: {pattern_type.replace('_', ' ').title()}\n"
        header += f"Size: {size} | Start: {start_num}\n"
        header += "=" * 40 + "\n\n"

        # Insert header and pattern
        self.output_text.insert(tk.END, header)
        self.output_text.insert(tk.END, pattern)

        # Force update to ensure display
        self.output_text.update()
        self.root.update()

        self.status_var.set(f"Generated {pattern_type.replace('_', ' ').title()} pattern")

        # Debug output to console
        print(f"Pattern generated successfully: {pattern_type}")
        print(f"Pattern length: {len(pattern)}")
        print(f"Pattern preview: {pattern[:100]}...")

    def _handle_generation_error(self, error_msg):
        """Handle pattern generation errors"""
        full_error = f"Error generating pattern: {error_msg}"
        messagebox.showerror("Error", full_error)
        self.status_var.set("Error occurred while generating pattern")
        print(f"ERROR: {full_error}")

        # Show error in output area
        self.output_text.insert(tk.END, f"ERROR: {full_error}")
        self.output_text.update()

    def _validate_size(self, value):
        """Validate size input"""
        if value == "":
            return True
        try:
            size = int(value)
            return 1 <= size <= 50
        except ValueError:
            return False

    def _validate_start_num(self, value):
        """Validate start number input"""
        if value == "":
            return True
        try:
            start_num = int(value)
            return 0 <= start_num <= 1000
        except ValueError:
            return False

    def setup_ui(self):
        """Setup the main user interface"""
        theme = self.themes[self.current_theme]

        # Main container
        main_frame = tk.Frame(self.root, bg=theme['bg'])
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

        # Left panel for controls
        control_frame = tk.Frame(main_frame, bg=theme['control_bg'], width=300)
        control_frame.pack(side=tk.LEFT, fill=tk.Y, padx=(0, 5))
        control_frame.pack_propagate(False)
        
        # Pattern selection
        tk.Label(control_frame, text="Select Pattern Type:", font=('Arial', 12, 'bold'), bg=theme['control_bg']).pack(pady=10)

        # Search box
        search_frame = tk.Frame(control_frame, bg=theme['control_bg'])
        search_frame.pack(pady=(0, 10))
        tk.Label(search_frame, text="Search:", bg=theme['control_bg']).pack(side=tk.LEFT)
        self.search_var = tk.StringVar()
        self.search_var.trace("w", self._filter_patterns)
        search_entry = tk.Entry(search_frame, textvariable=self.search_var, width=15)
        search_entry.pack(side=tk.LEFT, padx=5)
        tk.Button(search_frame, text="Clear", command=self._clear_search, bg='#95a5a6', fg='white').pack(side=tk.LEFT)

        self.pattern_var = tk.StringVar(value="pyramid")
        self.all_patterns = [
            ("Pyramid Pattern", "pyramid"),
            ("Reverse Pyramid", "reverse_pyramid"),
            ("Number Triangle", "triangle"),
            ("Pascal's Triangle", "pascal"),
            ("Floyd's Triangle", "floyd"),
            ("Number Square", "square"),
            ("Diamond Pattern", "diamond"),
            ("Hourglass Pattern", "hourglass"),
            ("Number Spiral", "spiral"),
            ("Prime Numbers", "prime"),
            ("Fibonacci Triangle", "fibonacci"),
            ("Multiplication Table", "multiplication"),
            ("Magic Square", "magic"),
            ("Sierpinski Triangle", "sierpinski"),
            ("Mandelbrot Set", "mandelbrot"),
            ("Hilbert Curve", "hilbert"),
            ("Dragon Curve", "dragon"),
            ("Koch Snowflake", "koch"),
            ("Cellular Automaton", "cellular"),
            ("Binary Tree", "binary_tree")
        ]

        # Frame to hold pattern radio buttons
        self.pattern_frame = tk.Frame(control_frame, bg=theme['control_bg'])
        self.pattern_frame.pack(fill=tk.X, padx=10)

        self._create_pattern_buttons()
        
        # Parameters
        tk.Label(control_frame, text="Parameters:", font=('Arial', 12, 'bold'), bg=theme['control_bg']).pack(pady=(20, 10))

        # Size input
        size_frame = tk.Frame(control_frame, bg=theme['control_bg'])
        size_frame.pack(pady=5)
        tk.Label(size_frame, text="Size/Rows (1-50):", bg=theme['control_bg']).pack(side=tk.LEFT)
        self.size_var = tk.IntVar(value=5)
        size_spinbox = tk.Spinbox(size_frame, from_=1, to=50, textvariable=self.size_var, width=10)
        size_spinbox.pack(side=tk.LEFT, padx=5)
        size_spinbox.config(validate="key", validatecommand=(self.root.register(self._validate_size), '%P'))

        # Start number input
        start_frame = tk.Frame(control_frame, bg=theme['control_bg'])
        start_frame.pack(pady=5)
        tk.Label(start_frame, text="Start Number (0-1000):", bg=theme['control_bg']).pack(side=tk.LEFT)
        self.start_var = tk.IntVar(value=1)
        start_spinbox = tk.Spinbox(start_frame, from_=0, to=1000, textvariable=self.start_var, width=10)
        start_spinbox.pack(side=tk.LEFT, padx=5)
        start_spinbox.config(validate="key", validatecommand=(self.root.register(self._validate_start_num), '%P'))

        # Buttons
        button_frame = tk.Frame(control_frame, bg=theme['control_bg'])
        button_frame.pack(pady=20)
        
        tk.Button(
            button_frame,
            text="Generate Pattern",
            command=self.generate_pattern,
            bg='#3498db',
            fg='white',
            font=('Arial', 10, 'bold'),
            padx=20
        ).pack(pady=5)
        
        tk.Button(
            button_frame,
            text="Clear Output",
            command=self.clear_output,
            bg='#e74c3c',
            fg='white',
            font=('Arial', 10, 'bold'),
            padx=20
        ).pack(pady=5)
        
        tk.Button(
            button_frame,
            text="Export Pattern",
            command=self.export_pattern,
            bg='#27ae60',
            fg='white',
            font=('Arial', 10, 'bold'),
            padx=20
        ).pack(pady=5)

        tk.Button(
            button_frame,
            text="Analyze Pattern",
            command=self.analyze_pattern,
            bg='#9b59b6',
            fg='white',
            font=('Arial', 10, 'bold'),
            padx=20
        ).pack(pady=5)
        
        # Right panel for output
        output_frame = tk.Frame(main_frame, bg=theme['output_bg'])
        output_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

        tk.Label(output_frame, text="Pattern Output:", font=('Arial', 12, 'bold'), bg=theme['output_bg']).pack(pady=10)

        self.output_text = scrolledtext.ScrolledText(
            output_frame,
            wrap=tk.WORD,
            font=('Courier New', 14, 'bold'),
            bg=theme['text_bg'],
            fg=theme['text_fg'],
            height=20,
            insertbackground='white',
            selectbackground='#333333'
        )
        self.output_text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        # Status bar
        self.status_var = tk.StringVar(value="Ready to generate patterns...")
        status_bar = tk.Label(self.root, textvariable=self.status_var, bd=1, relief=tk.SUNKEN, anchor=tk.W, bg=theme['header_bg'], fg=theme['header_fg'])
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
    
    def generate_pattern(self):
        """Generate the selected pattern"""
        pattern_type = self.pattern_var.get()
        size = self.size_var.get()
        start_num = self.start_var.get()

        # Input validation
        if not self._validate_inputs(size, start_num):
            return

        # Show generating status
        self.status_var.set(f"Generating {pattern_type.replace('_', ' ').title()} pattern...")
        self.root.update()  # Force GUI update

        # Clear output first
        self.output_text.delete(1.0, tk.END)

        # For complex patterns, use threading to keep GUI responsive
        complex_patterns = ['mandelbrot', 'cellular', 'sierpinski', 'hilbert', 'dragon', 'koch']
        if pattern_type in complex_patterns:
            # Run complex patterns in background thread
            thread = threading.Thread(target=self._generate_pattern_async,
                                    args=(pattern_type, size, start_num))
            thread.daemon = True
            thread.start()
        else:
            # Run simple patterns directly
            self._generate_pattern_sync(pattern_type, size, start_num)
    
    def clear_output(self):
        """Clear the output text area"""
        self.output_text.delete(1.0, tk.END)
        self.status_var.set("Output cleared")
    
    def export_pattern(self):
        """Export the pattern to a text file"""
        pattern_text = self.output_text.get(1.0, tk.END).strip()
        
        if not pattern_text:
            messagebox.showwarning("Warning", "No pattern to export!")
            return
        
        filename = filedialog.asksaveasfilename(
            defaultextension=".txt",
            filetypes=[("Text files", "*.txt"), ("All files", "*.*")],
            initialfile=f"pattern_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
        )
        
        if filename:
            try:
                with open(filename, 'w', encoding='utf-8') as f:
                    f.write("Python Number Pattern Generator\n")
                    f.write("=" * 40 + "\n")
                    f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                    f.write(f"Pattern Type: {self.pattern_var.get().replace('_', ' ').title()}\n")
                    f.write(f"Size: {self.size_var.get()}\n")
                    f.write(f"Start Number: {self.start_var.get()}\n")
                    f.write("\n" + "=" * 40 + "\n")
                    f.write("Pattern Output:\n")
                    f.write("-" * 20 + "\n\n")
                    f.write(pattern_text)
                    f.write("\n\n" + "=" * 40 + "\n")
                    f.write("Generated by Python Number Pattern Generator\n")
                    f.write("Developed by Molla Samser (RSK World)\n")
                    f.write("Designed by Rima Khatun\n")
                    f.write("Website: https://rskworld.in\n")
                    f.write("© 2026 RSK World. All rights reserved.\n")
                
                messagebox.showinfo("Success", f"Pattern exported successfully to:\n{filename}")
                self.status_var.set(f"Pattern exported to {os.path.basename(filename)}")
                
            except Exception as e:
                messagebox.showerror("Error", f"Error exporting pattern: {str(e)}")

    def export_as_png(self):
        """Export the pattern as a PNG image"""
        if not HAS_PIL:
            messagebox.showerror("Error", "PIL (Pillow) library is required for PNG export.\nInstall with: pip install pillow")
            return

        pattern_text = self.output_text.get(1.0, tk.END).strip()

        if not pattern_text:
            messagebox.showwarning("Warning", "No pattern to export! Generate a pattern first.")
            return

        # Extract just the pattern part (remove header)
        lines = pattern_text.split('\n')
        pattern_start = 0
        for i, line in enumerate(lines):
            if '=' * 10 in line:
                pattern_start = i + 2
                break

        actual_pattern = '\n'.join(lines[pattern_start:])

        filename = filedialog.asksaveasfilename(
            defaultextension=".png",
            filetypes=[("PNG files", "*.png"), ("All files", "*.*")],
            initialfile=f"pattern_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        )

        if filename:
            try:
                # Create image
                lines = actual_pattern.split('\n')
                font_size = 20
                line_height = font_size + 5
                char_width = font_size // 2

                # Calculate image dimensions
                max_line_length = max(len(line) for line in lines) if lines else 0
                img_width = max_line_length * char_width + 40
                img_height = len(lines) * line_height + 40

                # Create image with dark background (terminal style)
                img = Image.new('RGB', (img_width, img_height), color='#000000')
                draw = ImageDraw.Draw(img)

                try:
                    font = ImageFont.truetype("cour.ttf", font_size)  # Courier New
                except:
                    try:
                        font = ImageFont.truetype("cour.ttf", font_size)
                    except:
                        font = ImageFont.load_default()

                # Draw text
                y = 20
                for line in lines:
                    draw.text((20, y), line, fill='#00FF00', font=font)
                    y += line_height

                # Save image
                img.save(filename)

                messagebox.showinfo("Success", f"Pattern exported successfully as PNG to:\n{filename}")
                self.status_var.set(f"Pattern exported as PNG to {os.path.basename(filename)}")

            except Exception as e:
                messagebox.showerror("Error", f"Error exporting pattern as PNG: {str(e)}")

    def analyze_pattern(self):
        """Analyze the current pattern and show statistics"""
        pattern_text = self.output_text.get(1.0, tk.END).strip()

        if not pattern_text:
            messagebox.showwarning("Warning", "No pattern to analyze! Generate a pattern first.")
            return

        # Extract just the pattern part (remove header)
        lines = pattern_text.split('\n')
        # Find where the actual pattern starts (after the separator line)
        pattern_start = 0
        for i, line in enumerate(lines):
            if '=' * 10 in line:  # Look for separator
                pattern_start = i + 2  # Skip separator and empty line
                break

        actual_pattern = '\n'.join(lines[pattern_start:])

        # Calculate statistics
        stats = self._calculate_pattern_stats(actual_pattern)

        # Show analysis in a new window
        analysis_window = tk.Toplevel(self.root)
        analysis_window.title("Pattern Analysis - RSK World")
        analysis_window.geometry("400x350")
        analysis_window.configure(bg='#f0f0f0')

        tk.Label(analysis_window, text="Pattern Analysis", font=('Arial', 16, 'bold'), bg='#f0f0f0').pack(pady=10)

        # Create a frame for statistics
        stats_frame = tk.Frame(analysis_window, bg='#f0f0f0')
        stats_frame.pack(pady=10)

        stats_labels = [
            f"Pattern Type: {self.pattern_var.get().replace('_', ' ').title()}",
            f"Size: {self.size_var.get()}",
            f"Start Number: {self.start_var.get()}",
            f"Total Lines: {stats['lines']}",
            f"Total Characters: {stats['characters']}",
            f"Number Count: {stats['numbers']}",
            f"Max Number: {stats['max_num']}",
            f"Min Number: {stats['min_num']}",
            f"Sum of Numbers: {stats['sum_nums']}",
            f"Average per Line: {stats['avg_per_line']:.2f}"
        ]

        for stat in stats_labels:
            tk.Label(stats_frame, text=stat, font=('Arial', 10), bg='#f0f0f0', anchor='w').pack(fill='x', padx=20, pady=2)

        tk.Button(analysis_window, text="Close", command=analysis_window.destroy, bg='#e74c3c', fg='white').pack(pady=10)

    def _create_pattern_buttons(self):
        """Create pattern radio button widgets"""
        theme = self.themes[self.current_theme]

        # Clear existing buttons
        for widget in self.pattern_frame.winfo_children():
            widget.destroy()

        # Filter patterns based on search
        search_term = self.search_var.get().lower()
        filtered_patterns = [p for p in self.all_patterns if search_term in p[0].lower()]

        # Create radio buttons for filtered patterns
        for text, value in filtered_patterns:
            tk.Radiobutton(
                self.pattern_frame,
                text=text,
                variable=self.pattern_var,
                value=value,
                bg=theme['control_bg'],
                font=('Arial', 10)
            ).pack(anchor=tk.W, pady=2)

        # If current selection is not in filtered list, select first available
        current_value = self.pattern_var.get()
        if not any(p[1] == current_value for p in filtered_patterns):
            if filtered_patterns:
                self.pattern_var.set(filtered_patterns[0][1])

    def _filter_patterns(self, *args):
        """Filter patterns based on search term"""
        self._create_pattern_buttons()

    def _clear_search(self):
        """Clear the search box"""
        self.search_var.set("")
        self._create_pattern_buttons()

    def _calculate_pattern_stats(self, pattern):
        """Calculate detailed statistics for a pattern"""
        if not pattern.strip():
            return {"lines": 0, "characters": 0, "numbers": 0, "max_num": 0, "min_num": 0, "sum_nums": 0, "avg_per_line": 0}

        lines = pattern.split('\n')
        total_chars = len(pattern)
        numbers = []
        total_nums = 0

        for line in lines:
            # Extract numbers from the line
            line_nums = []
            current_num = ""
            for char in line:
                if char.isdigit():
                    current_num += char
                else:
                    if current_num:
                        line_nums.append(int(current_num))
                        current_num = ""
            if current_num:
                line_nums.append(int(current_num))

            numbers.extend(line_nums)
            total_nums += len(line_nums)

        if numbers:
            max_num = max(numbers)
            min_num = min(numbers)
            sum_nums = sum(numbers)
            avg_per_line = total_nums / len(lines) if lines else 0
        else:
            max_num = min_num = sum_nums = 0
            avg_per_line = 0

        return {
            "lines": len(lines),
            "characters": total_chars,
            "numbers": total_nums,
            "max_num": max_num,
            "min_num": min_num,
            "sum_nums": sum_nums,
            "avg_per_line": avg_per_line
        }


def main():
    """Main function to run the application"""
    root = tk.Tk()
    app = PatternGenerator(root)
    root.mainloop()


if __name__ == "__main__":
    main()