deep_clean_app.py

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
import os
import sys
import subprocess
import threading
import shutil
import json
from PIL import Image, ImageTk
import tempfile
import webbrowser
from datetime import datetime
import random
import uuid
import ctypes
import sys

class ImageSilencerApp:
    def __init__(self, root):
        self.root = root
        self.root.title("ImageSilencer Pro - Advanced Image Metadata Cleaner")
        
        # Start maximized
        self.root.state('zoomed')
        self.root.configure(bg='#1e1e1e')
        
        # Application directory
        if getattr(sys, 'frozen', False):
            self.app_dir = os.path.dirname(sys.executable)
        else:
            self.app_dir = os.path.dirname(os.path.abspath(__file__))
            
        self.tools_dir = os.path.join(self.app_dir, "tools")
        self.selected_files = []
        self.output_folders = []  # Store multiple output folders
        self.is_processing = False
        self.current_metadata = {}
        self.original_metadata = {}
        self.cleaned_metadata = {}
        
        # Fake metadata options
        self.fake_metadata_enabled = tk.BooleanVar(value=False)
        self.fake_gps_enabled = tk.BooleanVar(value=False)
        self.fake_camera_enabled = tk.BooleanVar(value=False)
        self.fake_date_enabled = tk.BooleanVar(value=False)
        
        # Image quality setting
        self.image_quality = tk.IntVar(value=95)
        
        # Find tools
        self.exiftool_path = self.find_exiftool()
        self.imagemagick_path = self.find_imagemagick()
        
        self.setup_ui()
        self.update_status()
        
        # Auto-create output folders on all available desktops
        self.auto_create_output_folders()
        
    def find_exiftool(self):
        """Find ExifTool in multiple locations"""
        possible_paths = [
            os.path.join(self.app_dir, "tools", "exiftool", "exiftool.exe"),
            os.path.join(self.tools_dir, "exiftool", "exiftool.exe"),
            os.path.join(self.app_dir, "exiftool.exe"),
            "exiftool.exe"
        ]
        
        for path in possible_paths:
            if os.path.exists(path):
                return path
                
        return None
        
    def find_imagemagick(self):
        """Find ImageMagick in multiple locations"""
        possible_paths = [
            os.path.join(self.app_dir, "tools", "ImageMagick", "magick.exe"),
            os.path.join(self.tools_dir, "ImageMagick", "magick.exe"),
            os.path.join(self.app_dir, "magick.exe"),
            "magick.exe"
        ]
        
        for path in possible_paths:
            if os.path.exists(path):
                return os.path.dirname(path)
                
        return None
        
    def auto_create_output_folders(self):
        """Auto-create output folders on ALL available desktops - ALWAYS RECREATE"""
        self.output_folders = []
        created_folders = []
        
        try:
            # Get ALL desktop folders for current user and public
            desktop_folders = self.get_all_desktop_folders()
            
            for desktop_path in desktop_folders:
                if desktop_path and os.path.exists(os.path.dirname(desktop_path)):
                    folder_name = "Cleaned_Images_ImageSilencer"
                    folder_path = os.path.join(desktop_path, folder_name)
                    
                    try:
                        # ALWAYS RECREATE - remove if exists and create fresh
                        if os.path.exists(folder_path):
                            shutil.rmtree(folder_path, ignore_errors=True)
                        os.makedirs(folder_path, exist_ok=True)
                        
                        if folder_path not in self.output_folders:
                            self.output_folders.append(folder_path)
                            created_folders.append(folder_path)
                            self.log(f"📁 Created/recreated output folder: {folder_path}")
                    except Exception as e:
                        self.log(f"⚠️ Could not create folder at {folder_path}: {str(e)}")
            
            # If no desktop folders were found, use app directory as fallback
            if not self.output_folders:
                app_folder = os.path.join(self.app_dir, "Cleaned_Images")
                if os.path.exists(app_folder):
                    shutil.rmtree(app_folder, ignore_errors=True)
                os.makedirs(app_folder, exist_ok=True)
                self.output_folders.append(app_folder)
                created_folders.append(f"App Directory: {app_folder}")
                self.log(f"📁 Created output folder in app directory: {app_folder}")
            
            # Log all created folders
            if created_folders:
                self.log("✅ Auto-created output folders on ALL desktops:")
                for folder in created_folders:
                    self.log(f"   📂 {folder}")
            else:
                self.log("⚠️ No output folders could be created")
                
        except Exception as e:
            self.log(f"❌ Error creating output folders: {str(e)}")
            # Final fallback
            app_folder = os.path.join(self.app_dir, "Cleaned_Images")
            if os.path.exists(app_folder):
                shutil.rmtree(app_folder, ignore_errors=True)
            os.makedirs(app_folder, exist_ok=True)
            self.output_folders.append(app_folder)
            self.log(f"📁 Using fallback folder: {app_folder}")
    
    def ensure_output_folders_exist(self):
        """Ensure output folders exist - recreate if missing"""
        folders_to_remove = []
        
        for folder_path in self.output_folders:
            if not os.path.exists(folder_path):
                folders_to_remove.append(folder_path)
                self.log(f"⚠️ Output folder missing: {folder_path}")
        
        # Remove missing folders from list
        for folder in folders_to_remove:
            self.output_folders.remove(folder)
        
        # Recreate all folders if any were missing
        if folders_to_remove:
            self.log("🔄 Recreating missing output folders...")
            self.auto_create_output_folders()
    
    def get_all_desktop_folders(self):
        """Get ALL desktop folders for current user, public, and common locations"""
        desktop_folders = []
        
        try:
            # Current User Desktop (Primary)
            current_desktop = os.path.join(os.path.expanduser("~"), "Desktop")
            if os.path.exists(current_desktop):
                desktop_folders.append(current_desktop)
            
            # Public Desktop (All Users)
            public_desktop = self.get_public_desktop()
            if public_desktop and os.path.exists(public_desktop):
                desktop_folders.append(public_desktop)
            
            # Common desktop locations
            common_desktops = [
                os.path.join(os.path.expanduser("~"), "OneDrive", "Desktop"),
                os.path.join(os.path.expanduser("~"), "Documents", "Desktop"),
                os.path.join("C:\\", "Users", "Public", "Desktop"),
                os.path.join(os.environ.get('PUBLIC', ''), 'Desktop'),
                os.path.join(os.path.expanduser("~"), "Desktop"),
                os.path.join(os.path.expanduser("~"), "Bureau"),  # French
                os.path.join(os.path.expanduser("~"), "Escritorio"),  # Spanish
                os.path.join(os.path.expanduser("~"), "Schreibtisch"),  # German
                os.path.join(os.path.expanduser("~"), "Рабочий стол"),  # Russian
            ]
            
            for desktop_path in common_desktops:
                if (desktop_path and 
                    os.path.exists(desktop_path) and 
                    desktop_path not in desktop_folders):
                    desktop_folders.append(desktop_path)
            
            # Remove duplicates and non-existent paths
            unique_desktops = []
            for desktop in desktop_folders:
                if desktop and os.path.exists(desktop) and desktop not in unique_desktops:
                    unique_desktops.append(desktop)
            
            return unique_desktops
            
        except Exception as e:
            self.log(f"⚠️ Error getting desktop folders: {str(e)}")
            # Return at least current user desktop
            current_desktop = os.path.join(os.path.expanduser("~"), "Desktop")
            return [current_desktop] if os.path.exists(current_desktop) else []
    
    def get_public_desktop(self):
        """Get the Public Desktop folder for all users"""
        try:
            # Method 1: Using known Windows folder
            if os.name == 'nt':  # Windows
                public_profile = os.environ.get('PUBLIC', '')
                if public_profile:
                    public_desktop = os.path.join(public_profile, 'Desktop')
                    if os.path.exists(public_desktop):
                        return public_desktop
                
                # Method 2: Common alternative path
                public_desktop = r'C:\Users\Public\Desktop'
                if os.path.exists(public_desktop):
                    return public_desktop
                
                # Method 3: Registry-based approach (more reliable)
                try:
                    import winreg
                    key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
                                        r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
                    public_desktop, _ = winreg.QueryValueEx(key, "Common Desktop")
                    winreg.CloseKey(key)
                    if os.path.exists(public_desktop):
                        return public_desktop
                except:
                    pass
                    
            return None
        except:
            return None

    def get_primary_output_folder(self):
        """Get the primary output folder (first in the list)"""
        if self.output_folders:
            return self.output_folders[0]
        else:
            # Fallback if no folders exist
            self.auto_create_output_folders()
            return self.output_folders[0] if self.output_folders else os.path.join(self.app_dir, "Cleaned_Images")
        
    def update_status(self):
        """Update dependency status"""
        status = "Status: "
        if self.exiftool_path:
            status += "✅ ExifTool "
        else:
            status += "❌ ExifTool "
            
        if self.imagemagick_path:
            status += "✅ ImageMagick"
        else:
            status += "❌ ImageMagick"
            
        self.status_label.config(text=status)
        
    def setup_ui(self):
        # Configure styles
        style = ttk.Style()
        style.theme_use('clam')
        
        # Set minimum window size
        self.root.minsize(1200, 700)
        
        # Header with gradient effect
        header_frame = tk.Frame(self.root, bg='#1e1e1e', height=100)
        header_frame.pack(fill='x', padx=0, pady=0)
        header_frame.pack_propagate(False)
        
        # Main title with icon
        title_container = tk.Frame(header_frame, bg='#1e1e1e')
        title_container.pack(fill='x', padx=30, pady=15)
        
        title_label = tk.Label(title_container, text="🛡️ ImageSilencer Pro", 
                              font=('Arial', 24, 'bold'), 
                              bg='#1e1e1e', fg='#ffffff')
        title_label.pack(side='left')
        
        subtitle_label = tk.Label(title_container, 
                                text="Clean Metadata • Set Fake Data • Protect Privacy",
                                font=('Arial', 11), 
                                bg='#1e1e1e', fg='#00ff88')
        subtitle_label.pack(side='left', padx=(15, 0), pady=5)
        
        # Status and info
        info_frame = tk.Frame(header_frame, bg='#1e1e1e')
        info_frame.pack(fill='x', padx=30, pady=5)
        
        self.status_label = tk.Label(info_frame, text="Status: Initializing...",
                                   font=('Arial', 9), bg='#1e1e1e', fg='#00ff88')
        self.status_label.pack(side='left')
        
        # Output folder info
        self.output_info_label = tk.Label(info_frame, text="",
                                        font=('Arial', 8), bg='#1e1e1e', fg='#ffa726')
        self.output_info_label.pack(side='left', padx=(20, 0))
        self.update_output_info()
        
        # Quick stats
        stats_label = tk.Label(info_frame, text="🔒 Secure | 🚀 Fast | 🛡️ Private",
                              font=('Arial', 9), bg='#1e1e1e', fg='#cccccc')
        stats_label.pack(side='right')
        
        # Main content with modern layout
        main_frame = tk.Frame(self.root, bg='#2b2b2b')
        main_frame.pack(fill='both', expand=True, padx=20, pady=15)
        
        # Left panel (Tools and Actions) - Fixed width
        left_frame = tk.Frame(main_frame, bg='#252525', width=400)
        left_frame.pack(side='left', fill='y', padx=(0, 15))
        left_frame.pack_propagate(False)
        
        # Right panel (Preview and Results)
        right_frame = tk.Frame(main_frame, bg='#2b2b2b')
        right_frame.pack(side='right', fill='both', expand=True)
        
        self.setup_left_panel(left_frame)
        self.setup_right_panel(right_frame)
        
    def update_output_info(self):
        """Update the output folder information display"""
        if self.output_folders:
            primary_folder = self.output_folders[0]
            folder_name = os.path.basename(primary_folder)
            location_info = os.path.basename(os.path.dirname(primary_folder))
            
            if len(self.output_folders) > 1:
                self.output_info_label.config(
                    text=f"📁 Output: {location_info}\\{folder_name} (+{len(self.output_folders)-1} more desktops)"
                )
            else:
                self.output_info_label.config(
                    text=f"📁 Output: {location_info}\\{folder_name}"
                )
        else:
            self.output_info_label.config(text="📁 Output: Not set")
        
    def setup_left_panel(self, parent):
        """Setup scrollable left panel with all controls"""
        # Create main container
        main_container = tk.Frame(parent, bg='#252525')
        main_container.pack(fill='both', expand=True)
        
        # Create canvas and scrollbar
        self.canvas = tk.Canvas(main_container, bg='#252525', highlightthickness=0)
        scrollbar = ttk.Scrollbar(main_container, orient="vertical", command=self.canvas.yview)
        
        # Create scrollable frame
        self.scrollable_frame = tk.Frame(self.canvas, bg='#252525')
        
        self.scrollable_frame.bind(
            "<Configure>",
            lambda e: self.canvas.configure(scrollregion=self.canvas.bbox("all"))
        )
        
        self.canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
        self.canvas.configure(yscrollcommand=scrollbar.set)
        
        # Pack canvas and scrollbar
        self.canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # Bind mouse wheel to canvas
        self.canvas.bind("<Enter>", self._bind_mousewheel)
        self.canvas.bind("<Leave>", self._unbind_mousewheel)
        
        # Bind mouse wheel to scrollable frame as well
        self.scrollable_frame.bind("<Enter>", self._bind_mousewheel)
        self.scrollable_frame.bind("<Leave>", self._unbind_mousewheel)
        
        # Build the content
        self.build_left_panel_content()
        
    def _bind_mousewheel(self, event):
        self.canvas.bind_all("<MouseWheel>", self._on_mousewheel)
        
    def _unbind_mousewheel(self, event):
        self.canvas.unbind_all("<MouseWheel>")
        
    def _on_mousewheel(self, event):
        self.canvas.yview_scroll(int(-1*(event.delta/120)), "units")
        
    def build_left_panel_content(self):
        """Build all left panel content in the scrollable frame"""
        # Quick Actions
        quick_frame = tk.LabelFrame(self.scrollable_frame, text=" ⚡ Quick Actions ", 
                                  bg='#252525', fg='#00ff88', 
                                  font=('Arial', 11, 'bold'),
                                  padx=15, pady=15)
        quick_frame.pack(fill='x', padx=10, pady=10)
        
        action_buttons = [
            ("📸 Select Images", self.select_files, '#4caf50'),
            ("📂 Output Folder", self.select_output_folder, '#2196f3'),
            ("🔍 View Metadata", self.view_current_metadata, '#ffa726'),
            ("🔄 Reset All", self.reset_application, '#ff5252')
        ]
        
        for text, command, color in action_buttons:
            btn = tk.Button(quick_frame, text=text, command=command,
                          bg=color, fg='white', font=('Arial', 10),
                          height=2, relief='flat')
            btn.pack(fill='x', pady=3)
        
        # File list with scrollbar
        list_frame = tk.LabelFrame(self.scrollable_frame, text=" 📁 Selected Files ", 
                                  bg='#252525', fg='#00ff88',
                                  font=('Arial', 11, 'bold'),
                                  padx=15, pady=15)
        list_frame.pack(fill='x', padx=10, pady=10)
        
        # File counter
        self.file_count_label = tk.Label(list_frame, text="No files selected",
                                       bg='#252525', fg='#cccccc', font=('Arial', 9))
        self.file_count_label.pack(anchor='w', pady=(0, 10))
        
        # Listbox with scrollbar
        list_container = tk.Frame(list_frame, bg='#252525')
        list_container.pack(fill='both', expand=True)
        
        self.file_listbox = tk.Listbox(list_container, height=6, bg='#1a1a1a', fg='#ffffff',
                                      selectbackground='#00ff88', selectforeground='#000000',
                                      font=('Arial', 9), relief='flat')
        
        scrollbar = tk.Scrollbar(list_container, orient='vertical')
        self.file_listbox.config(yscrollcommand=scrollbar.set)
        scrollbar.config(command=self.file_listbox.yview)
        
        self.file_listbox.pack(side='left', fill='both', expand=True)
        scrollbar.pack(side='right', fill='y')
        self.file_listbox.bind('<<ListboxSelect>>', self.on_file_select)
        
        # List controls
        list_controls = tk.Frame(list_frame, bg='#252525')
        list_controls.pack(fill='x', pady=(10, 0))
        
        tk.Button(list_controls, text="Clear List", command=self.clear_file_list,
                 bg='#ff5252', fg='white', font=('Arial', 8)).pack(side='left', padx=2)
                 
        tk.Button(list_controls, text="Select All", command=self.select_all_files,
                 bg='#2196f3', fg='white', font=('Arial', 8)).pack(side='left', padx=2)
        
        # Fake Metadata Options
        fake_meta_frame = tk.LabelFrame(self.scrollable_frame, text=" 🎭 Fake Metadata Options ", 
                                       bg='#252525', fg='#ffa726',
                                       font=('Arial', 11, 'bold'),
                                       padx=15, pady=15)
        fake_meta_frame.pack(fill='x', padx=10, pady=10)
        
        # Enable fake metadata
        fake_check = tk.Checkbutton(fake_meta_frame, text="Enable Fake Metadata Beta", 
                                   variable=self.fake_metadata_enabled,
                                   bg='#252525', fg='#ffffff',
                                   selectcolor='#1a1a1a', font=('Arial', 10, 'bold'))
        fake_check.pack(anchor='w', pady=5)
        
        # Fake metadata options
        options_frame = tk.Frame(fake_meta_frame, bg='#252525')
        options_frame.pack(fill='x', padx=20, pady=5)
        
        tk.Checkbutton(options_frame, text="Fake GPS Location Beta", 
                      variable=self.fake_gps_enabled,
                      bg='#252525', fg='#cccccc', font=('Arial', 9)).pack(anchor='w')
                      
        tk.Checkbutton(options_frame, text="Fake Camera Model Beta", 
                      variable=self.fake_camera_enabled,
                      bg='#252525', fg='#cccccc', font=('Arial', 9)).pack(anchor='w')
                      
        tk.Checkbutton(options_frame, text="Fake Date/Time Beta", 
                      variable=self.fake_date_enabled,
                      bg='#252525', fg='#cccccc', font=('Arial', 9)).pack(anchor='w')
        
        # Image Quality Settings
        quality_frame = tk.LabelFrame(self.scrollable_frame, text=" 🎨 Image Quality Settings ", 
                                     bg='#252525', fg='#00ff88',
                                     font=('Arial', 11, 'bold'),
                                     padx=15, pady=15)
        quality_frame.pack(fill='x', padx=10, pady=10)
        
        # Quality scale
        quality_scale_frame = tk.Frame(quality_frame, bg='#252525')
        quality_scale_frame.pack(fill='x', pady=5)
        
        tk.Label(quality_scale_frame, text="Output Quality:", 
                bg='#252525', fg='#ffffff', font=('Arial', 9)).pack(anchor='w')
        
        quality_scale = tk.Scale(quality_scale_frame, from_=50, to=100, 
                                variable=self.image_quality, orient='horizontal',
                                bg='#252525', fg='#ffffff', troughcolor='#1a1a1a',
                                highlightbackground='#252525', length=200)
        quality_scale.pack(fill='x', pady=5)
        
        quality_info = tk.Label(quality_scale_frame, 
                               text="Lower = smaller files, Higher = better quality",
                               bg='#252525', fg='#888888', font=('Arial', 8))
        quality_info.pack(anchor='w')
        
        # Cleaning options
        clean_frame = tk.LabelFrame(self.scrollable_frame, text=" ⚡ Cleaning Modes ", 
                                   bg='#252525', fg='#00ff88',
                                   font=('Arial', 11, 'bold'),
                                   padx=15, pady=15)
        clean_frame.pack(fill='x', padx=10, pady=10)
        
        self.clean_mode = tk.StringVar(value="deep")
        
        modes = [
            ("🔍 Standard Clean (EXIF only)", "standard", "Removes basic EXIF data only"),
            ("🚀 Deep Clean (Recommended)", "deep", "Removes all metadata + XMP"),
            ("🛡️ Ultra Clean (Maximum Privacy)", "ultra", "Deep clean + strip all")
        ]
        
        for text, mode, description in modes:
            frame = tk.Frame(clean_frame, bg='#252525')
            frame.pack(fill='x', pady=3)
            
            rb = tk.Radiobutton(frame, text=text, variable=self.clean_mode,
                              value=mode, bg='#252525', fg='#ffffff',
                              selectcolor='#00ff88', font=('Arial', 9))
            rb.pack(anchor='w')
            
            desc_label = tk.Label(frame, text=description, bg='#252525', 
                                fg='#888888', font=('Arial', 8))
            desc_label.pack(anchor='w', padx=(20, 0))
        
        # ACTION BUTTONS at the bottom of scrollable content
        action_frame = tk.Frame(self.scrollable_frame, bg='#252525')
        action_frame.pack(fill='x', padx=10, pady=20)
        
        # BIG GREEN CLEAN BUTTON
        self.clean_btn = tk.Button(action_frame, text="🚀 START CLEANING", 
                                  command=self.start_cleaning,
                                  bg='#00ff88', fg='#000000', 
                                  font=('Arial', 12, 'bold'), height=2,
                                  relief='raised', bd=3)
        self.clean_btn.pack(fill='x', pady=5)
        
        # ORANGE FAKE METADATA BUTTON
        self.fake_meta_btn = tk.Button(action_frame, text="🎭 SET FAKE METADATA", 
                                      command=self.set_fake_metadata,
                                      bg='#ffa726', fg='#000000', 
                                      font=('Arial', 10, 'bold'), height=2,
                                      relief='raised', bd=3)
        self.fake_meta_btn.pack(fill='x', pady=5)
        
    def setup_right_panel(self, parent):
        # Create notebook for tabs
        notebook = ttk.Notebook(parent)
        notebook.pack(fill='both', expand=True)
        
        # Tab 1: Preview & Analysis
        preview_tab = tk.Frame(notebook, bg='#2b2b2b')
        notebook.add(preview_tab, text="🖼️ Preview & Analysis")
        
        self.setup_preview_tab(preview_tab)
        
        # Tab 2: Metadata Comparison
        compare_tab = tk.Frame(notebook, bg='#2b2b2b')
        notebook.add(compare_tab, text="📊 Metadata Comparison")
        
        self.setup_compare_tab(compare_tab)
        
        # Tab 3: Batch Processing
        batch_tab = tk.Frame(notebook, bg='#2b2b2b')
        notebook.add(batch_tab, text="⚡ Batch Tools")
        
        self.setup_batch_tab(batch_tab)
        
    def setup_preview_tab(self, parent):
        # Preview frame
        preview_container = tk.Frame(parent, bg='#2b2b2b')
        preview_container.pack(fill='both', expand=True, padx=10, pady=10)
        
        # Image preview
        preview_frame = tk.LabelFrame(preview_container, text=" 🖼️ Image Preview ", 
                                     bg='#3c3c3c', fg='#ffffff',
                                     font=('Arial', 10, 'bold'),
                                     padx=15, pady=15)
        preview_frame.pack(fill='both', expand=True, pady=(0, 10))
        
        self.preview_label = tk.Label(preview_frame, 
                                     text="No image selected\n\nSelect images to preview",
                                     bg='#1e1e1e', fg='#666666',
                                     font=('Arial', 12), justify='center')
        self.preview_label.pack(fill='both', expand=True, padx=5, pady=5)
        
        # File info with enhanced details
        info_frame = tk.Frame(preview_container, bg='#2b2b2b')
        info_frame.pack(fill='x', pady=5)
        
        self.file_info = tk.Label(info_frame, text="", 
                                 bg='#2b2b2b', fg='#cccccc',
                                 font=('Arial', 9), justify='left', anchor='w')
        self.file_info.pack(fill='x', padx=5)
        
        # Metadata summary
        self.meta_summary = tk.Label(info_frame, text="", 
                                    bg='#2b2b2b', fg='#00ff88',
                                    font=('Arial', 9, 'bold'), justify='left', anchor='w')
        self.meta_summary.pack(fill='x', padx=5)
        
        # Detailed metadata display
        meta_frame = tk.LabelFrame(preview_container, text=" 📊 Current Metadata ", 
                                  bg='#3c3c3c', fg='#ffffff',
                                  font=('Arial', 10, 'bold'),
                                  padx=15, pady=15)
        meta_frame.pack(fill='both', expand=True, pady=(10, 0))
        
        self.metadata_text = scrolledtext.ScrolledText(meta_frame, height=8,
                                                      bg='#1e1e1e', fg='#00ff88',
                                                      font=('Consolas', 8))
        self.metadata_text.pack(fill='both', expand=True)
        self.metadata_text.insert(tk.END, "Select an image to view its metadata...")
        self.metadata_text.config(state='disabled')
        
    def setup_compare_tab(self, parent):
        # Comparison frame
        compare_frame = tk.Frame(parent, bg='#2b2b2b')
        compare_frame.pack(fill='both', expand=True, padx=10, pady=10)
        
        # Comparison info
        info_text = """🔍 **Automatic Metadata Comparison**

After cleaning your images, this tab will automatically show:
• 📊 Before/After metadata comparison
• 🗑️ Removed privacy risks  
• 📈 Cleaning effectiveness
• 🔍 Remaining metadata tags

The comparison starts automatically after cleaning process completes."""
        
        info_label = tk.Label(compare_frame, text=info_text,
                            bg='#2b2b2b', fg='#cccccc', font=('Arial', 10),
                            justify='left', anchor='w')
        info_label.pack(fill='x', pady=10)
        
        # Comparison results area
        self.compare_text = scrolledtext.ScrolledText(compare_frame, height=15,
                                                     bg='#1e1e1e', fg='#00ff88',
                                                     font=('Consolas', 9))
        self.compare_text.pack(fill='both', expand=True, pady=10)
        self.compare_text.insert(tk.END, "🔍 Comparison results will appear here after cleaning...")
        self.compare_text.config(state='disabled')
        
    def setup_batch_tab(self, parent):
        # Batch tools frame
        batch_frame = tk.Frame(parent, bg='#2b2b2b')
        batch_frame.pack(fill='both', expand=True, padx=10, pady=10)
        
        # Batch actions
        batch_actions = [
            ("📁 Clean Entire Folder", self.clean_entire_folder),
            ("📊 Generate Report", self.generate_report),
            ("🧹 Clean Temp Files", self.clean_temp_files)
        ]
        
        for text, command in batch_actions:
            btn = tk.Button(batch_frame, text=text, command=command,
                          bg='#3c3c3c', fg='#ffffff', font=('Arial', 10),
                          height=2, relief='flat')
            btn.pack(fill='x', pady=5)
        
        # Log area
        log_frame = tk.LabelFrame(batch_frame, text=" 📝 Real-time Processing Log ", 
                                 bg='#3c3c3c', fg='#ffffff',
                                 font=('Arial', 10, 'bold'),
                                 padx=10, pady=10)
        log_frame.pack(fill='both', expand=True, pady=10)
        
        self.log_text = scrolledtext.ScrolledText(log_frame, height=12,
                                                 bg='#1e1e1e', fg='#00ff00',
                                                 font=('Consolas', 9))
        self.log_text.pack(fill='both', expand=True)
        
        # Progress section - RED COLOR
        progress_frame = tk.Frame(batch_frame, bg='#2b2b2b')
        progress_frame.pack(fill='x', pady=10)
        
        # Create custom style for red progress bar
        style = ttk.Style()
        style.configure("Red.Horizontal.TProgressbar", 
                       troughcolor='#1a1a1a', 
                       background='#ff0000',  # Red color
                       bordercolor='#1a1a1a',
                       lightcolor='#ff0000',
                       darkcolor='#ff0000')
        
        self.progress = ttk.Progressbar(progress_frame, mode='determinate', 
                                      style="Red.Horizontal.TProgressbar")
        self.progress.pack(fill='x', pady=5)
        
        self.progress_label = tk.Label(progress_frame, text="Ready to process images", 
                                      bg='#2b2b2b', fg='#00ff88',
                                      font=('Arial', 10, 'bold'))
        self.progress_label.pack()

    def select_files(self):
        files = filedialog.askopenfilenames(
            title="Select Images to Clean",
            filetypes=[
                ("All images", "*.jpg *.jpeg *.png *.bmp *.tiff *.webp"),
                ("JPEG files", "*.jpg *.jpeg"),
                ("PNG files", "*.png"),
                ("All files", "*.*")
            ]
        )
        if files:
            self.selected_files = list(files)
            self.file_listbox.delete(0, tk.END)
            for file in self.selected_files:
                self.file_listbox.insert(tk.END, os.path.basename(file))
            
            self.file_count_label.config(text=f"📄 {len(files)} files selected • {self.get_total_size()} MB")
            self.log(f"✅ Selected {len(files)} images for processing")
            
            # AUTO-SELECT FIRST IMAGE AND SHOW METADATA
            if self.selected_files:
                self.file_listbox.selection_set(0)
                self.on_file_select(None)
                # Force metadata extraction for the first file
                first_file = self.selected_files[0]
                self.log(f"🔍 Auto-displaying metadata for: {os.path.basename(first_file)}")
                
    def get_total_size(self):
        """Calculate total size of selected files in MB"""
        total_bytes = sum(os.path.getsize(f) for f in self.selected_files)
        return round(total_bytes / (1024 * 1024), 2)
                
    def select_output_folder(self):
        folder = filedialog.askdirectory(title="Select Output Folder")
        if folder:
            # Replace all output folders with the user-selected one
            self.output_folders = [folder]
            self.update_output_info()
            self.log(f"📁 Output folder updated: {folder}")
            
    def reset_application(self):
        self.selected_files = []
        self.file_listbox.delete(0, tk.END)
        self.preview_label.config(text="No image selected\n\nSelect images to preview")
        self.file_info.config(text="")
        self.meta_summary.config(text="")
        self.file_count_label.config(text="No files selected")
        self.metadata_text.config(state='normal')
        self.metadata_text.delete(1.0, tk.END)
        self.metadata_text.insert(tk.END, "Select an image to view its metadata...")
        self.metadata_text.config(state='disabled')
        self.log("🔄 Application reset - ready for new session")
        
    def view_current_metadata(self):
        """View metadata for currently selected file"""
        selection = self.file_listbox.curselection()
        if not selection:
            messagebox.showinfo("No Selection", "Please select an image first!")
            return
            
        index = selection[0]
        if index < len(self.selected_files):
            file_path = self.selected_files[index]
            self.show_preview(file_path)
            self.extract_metadata(file_path)
        
    def on_file_select(self, event):
        selection = self.file_listbox.curselection()
        if selection:
            index = selection[0]
            if index < len(self.selected_files):
                file_path = self.selected_files[index]
                self.show_preview(file_path)
                self.extract_metadata(file_path)
                
    def show_preview(self, file_path):
        try:
            img = Image.open(file_path)
            # Create better thumbnail maintaining aspect ratio
            max_size = (300, 300)
            img.thumbnail(max_size, Image.Resampling.LANCZOS)
            photo = ImageTk.PhotoImage(img)
            
            self.preview_label.config(image=photo, text="")
            self.preview_label.image = photo
            
            # Enhanced file info
            file_size = os.path.getsize(file_path) / 1024  # KB
            file_info = f"📄 File: {os.path.basename(file_path)}\n"
            file_info += f"📏 Dimensions: {img.size[0]} × {img.size[1]} pixels\n"
            file_info += f"💾 Size: {file_size:.1f} KB • Format: {img.format}\n"
            file_info += f"📁 Location: {os.path.dirname(file_path)}"
            self.file_info.config(text=file_info)
            
        except Exception as e:
            self.preview_label.config(image="", text=f"❌ Cannot preview image\n{str(e)}")
            self.file_info.config(text=f"❌ Error loading image: {str(e)}")
            
    def extract_metadata_for_file(self, file_path):
        """Extract metadata and return dictionary"""
        if not self.exiftool_path:
            return {"Error": "ExifTool not available"}
            
        try:
            result = subprocess.run([
                self.exiftool_path,
                '-j',  # JSON output
                file_path
            ], capture_output=True, text=True, timeout=10)
            
            if result.returncode == 0:
                return json.loads(result.stdout)[0]
            else:
                return {"Error": "Failed to extract metadata"}
                
        except Exception as e:
            return {"Error": str(e)}
            
    def extract_metadata(self, file_path):
        metadata = self.extract_metadata_for_file(file_path)
        self.current_metadata = metadata
        
        # Update metadata display
        self.metadata_text.config(state='normal')
        self.metadata_text.delete(1.0, tk.END)
        
        if "Error" in metadata:
            self.meta_summary.config(text="❌ Could not extract metadata")
            self.metadata_text.insert(tk.END, f"❌ Error: {metadata['Error']}")
        else:
            tag_count = len(metadata)
            privacy_risks = self.analyze_privacy_risks(metadata)
            self.meta_summary.config(
                text=f"🔍 {tag_count} metadata tags found • 🚨 {privacy_risks} potential privacy risks"
            )
            
            # Display all metadata in readable format
            for key, value in metadata.items():
                self.metadata_text.insert(tk.END, f"🔹 {key}: {value}\n")
        
        self.metadata_text.config(state='disabled')
            
    def analyze_privacy_risks(self, metadata):
        """Analyze metadata for potential privacy risks"""
        risky_tags = ['GPS', 'Location', 'Camera', 'Model', 'Software', 'Author', 'Copyright']
        risks = 0
        for tag in metadata:
            if any(risky in tag for risky in risky_tags):
                risks += 1
        return risks
        
    def log(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S")
        self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
        self.log_text.see(tk.END)
        self.root.update_idletasks()
        
    def start_cleaning(self):
        """Start the metadata cleaning process"""
        if not self.selected_files:
            messagebox.showwarning("Warning", "Please select some images first!")
            return
            
        if self.is_processing:
            return
            
        # ALWAYS ENSURE OUTPUT FOLDERS EXIST BEFORE PROCESSING
        self.ensure_output_folders_exist()
            
        # Store original metadata for comparison
        self.original_metadata.clear()
        self.log("📊 Capturing original metadata for comparison...")
        for file_path in self.selected_files:
            self.original_metadata[file_path] = self.extract_metadata_for_file(file_path)
            
        self.is_processing = True
        self.clean_btn.config(state='disabled', text="🔄 CLEANING...")
        self.fake_meta_btn.config(state='disabled')
        
        thread = threading.Thread(target=self.process_images)
        thread.daemon = True
        thread.start()
        
    def set_fake_metadata(self):
        """Set fake metadata on selected images - FIXED VERSION"""
        if not self.selected_files:
            messagebox.showwarning("Warning", "Please select some images first!")
            return
            
        if not self.fake_metadata_enabled.get():
            messagebox.showinfo("Info", "Please enable 'Fake Metadata' option first!")
            return
            
        # 🚨 FIX: Check if ANY fake options are actually selected
        if not (self.fake_gps_enabled.get() or 
                self.fake_camera_enabled.get() or 
                self.fake_date_enabled.get()):
            messagebox.showwarning("Warning", 
                                "Please select at least one fake metadata option!\n\n"
                                "• Fake GPS Location\n"
                                "• Fake Camera Model\n" 
                                "• Fake Date/Time")
            return
            
        if self.is_processing:
            return
            
        # Confirm action
        result = messagebox.askyesno("Set Fake Metadata", 
                                   "⚠️ FAKE METADATA MODE ⚠️\n\n"
                                   "This will create new images with FAKE metadata.\n"
                                   "Selected options:\n"
                                   f"• Fake GPS: {'✅' if self.fake_gps_enabled.get() else '❌'}\n"
                                   f"• Fake Camera: {'✅' if self.fake_camera_enabled.get() else '❌'}\n"
                                   f"• Fake Date: {'✅' if self.fake_date_enabled.get() else '❌'}\n\n"
                                   "Images will be saved to ALL desktop locations.\n\n"
                                   "Continue?")
        if not result:
            return
            
        # ALWAYS ENSURE OUTPUT FOLDERS EXIST BEFORE PROCESSING
        self.ensure_output_folders_exist()
            
        self.is_processing = True
        self.clean_btn.config(state='disabled')
        self.fake_meta_btn.config(state='disabled', text="🔄 SETTING FAKE DATA...")
        
        thread = threading.Thread(target=self.process_fake_metadata_simple)
        thread.daemon = True
        thread.start()
        
    def process_fake_metadata_simple(self):
        """SIMPLE AND RELIABLE fake metadata processing - FIXED VERSION"""
        try:
            total_files = len(self.selected_files)
            processed = 0
            
            # DOUBLE CHECK FOLDERS EXIST
            self.ensure_output_folders_exist()
            
            self.log(f"🎭 Starting fake metadata process for {total_files} files")
            self.log(f"📁 Output folders: {len(self.output_folders)} locations")
            
            for input_file in self.selected_files:
                if not self.is_processing:
                    break
                    
                # 🚨 FIX: Generate appropriate filename based on actual fake metadata application
                file_ext = os.path.splitext(input_file)[1]
                # Only use "fake_" prefix if actual fake metadata is being applied
                if (self.fake_gps_enabled.get() or 
                    self.fake_camera_enabled.get() or 
                    self.fake_date_enabled.get()):
                    random_name = f"fake_{uuid.uuid4().hex[:8]}{file_ext}"
                else:
                    random_name = f"cleaned_{uuid.uuid4().hex[:8]}{file_ext}"
                
                self.log(f"🔄 Processing: {os.path.basename(input_file)}")
                
                # Save to all available output folders
                saved_locations = []
                for output_folder in self.output_folders:
                    try:
                        output_file = os.path.join(output_folder, random_name)
                        self.log(f"   📍 Target: {output_file}")
                        
                        # SIMPLE APPROACH: Copy file first
                        self.log(f"   📋 Step 1: Copying file...")
                        shutil.copy2(input_file, output_file)
                        
                        # Verify file was copied
                        if not os.path.exists(output_file):
                            self.log(f"   ❌ File copy failed for {output_folder}")
                            continue
                            
                        file_size = os.path.getsize(output_file)
                        self.log(f"   ✅ File copied successfully ({file_size} bytes)")
                        
                        # Step 2: Apply fake metadata using ExifTool ONLY if fake options are enabled
                        if self.exiftool_path and os.path.exists(self.exiftool_path):
                            # 🚨 FIX: Only apply fake metadata if at least one option is enabled
                            if (self.fake_gps_enabled.get() or 
                                self.fake_camera_enabled.get() or 
                                self.fake_date_enabled.get()):
                                
                                self.log(f"   🔧 Step 2: Applying fake metadata...")
                                
                                # Build the ExifTool command - DON'T USE -overwrite_original initially
                                cmd = [self.exiftool_path]
                                
                                # Add fake GPS if enabled
                                if self.fake_gps_enabled.get():
                                    lat = random.uniform(-90, 90)
                                    lon = random.uniform(-180, 180)
                                    cmd.extend([
                                        f'-GPSLatitude={lat}',
                                        f'-GPSLongitude={lon}',
                                        '-GPSLatitudeRef=N',
                                        '-GPSLongitudeRef=E'
                                    ])
                                    self.log(f"      📍 Added fake GPS: {lat:.6f}, {lon:.6f}")
                                
                                # Add fake camera if enabled
                                if self.fake_camera_enabled.get():
                                    cameras = [("Canon", "EOS R5"), ("Nikon", "Z9"), ("Sony", "A7IV")]
                                    make, model = random.choice(cameras)
                                    cmd.extend([
                                        f'-Make={make}',
                                        f'-Model={model}'
                                    ])
                                    self.log(f"      📷 Added fake camera: {make} {model}")
                                
                                # Add fake date if enabled
                                if self.fake_date_enabled.get():
                                    fake_date = datetime.now() - random.randint(1, 3650)
                                    date_str = fake_date.strftime("%Y:%m:%d %H:%M:%S")
                                    cmd.extend([
                                        f'-DateTimeOriginal={date_str}',
                                        f'-CreateDate={date_str}'
                                    ])
                                    self.log(f"      📅 Added fake date: {date_str}")
                                
                                # Always add some basic fake metadata when any fake option is enabled
                                cmd.extend([
                                    '-Artist=Anonymous',
                                    '-Copyright=Copyright Free',
                                    '-Software=ImageSilencer Pro',
                                    '-ImageDescription=Processed with fake metadata'
                                ])
                                
                                # 🚨 CRITICAL FIX: Use -overwrite_original at the END, not beginning
                                cmd.append('-overwrite_original')
                                
                                # Add the file to process
                                cmd.append(output_file)
                                
                                # Run ExifTool
                                try:
                                    self.log(f"      🔧 Running ExifTool command...")
                                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
                                    if result.returncode == 0:
                                        self.log(f"      ✅ Fake metadata applied successfully")
                                        
                                        # 🚨 VERIFY: Check if metadata was actually added
                                        verify_meta = self.extract_metadata_for_file(output_file)
                                        meta_count = len(verify_meta)
                                        self.log(f"      🔍 Verification: {meta_count} metadata tags found in output file")
                                        
                                        saved_locations.append(output_folder)
                                    else:
                                        self.log(f"      ⚠️ ExifTool warning: {result.stderr}")
                                        # Still count as success if file exists
                                        if os.path.exists(output_file):
                                            saved_locations.append(output_folder)
                                except Exception as e:
                                    self.log(f"      ⚠️ ExifTool error: {str(e)}")
                                    # Still count as success if file exists
                                    if os.path.exists(output_file):
                                        saved_locations.append(output_folder)
                            else:
                                # No fake options enabled, just do regular cleaning
                                self.log(f"   🔧 No fake options enabled, performing regular cleaning...")
                                self.clean_image(input_file, output_file)
                                saved_locations.append(output_folder)
                        else:
                            self.log(f"   ⚠️ ExifTool not available, saving file without metadata")
                            saved_locations.append(output_folder)
                            
                    except Exception as e:
                        self.log(f"   ❌ Error processing {output_folder}: {str(e)}")
                
                # Count as processed if saved to at least one location
                if saved_locations:
                    processed += 1
                    self.log(f"✅ Successfully processed to {len(saved_locations)} locations")
                    
                    # 🚨 AUTO-VIEW THE FAKE METADATA FOR THE FIRST PROCESSED FILE
                    if processed == 1 and (self.fake_gps_enabled.get() or 
                                         self.fake_camera_enabled.get() or 
                                         self.fake_date_enabled.get()):
                        primary_output = os.path.join(self.output_folders[0], random_name)
                        if os.path.exists(primary_output):
                            self.log(f"🔍 Auto-displaying fake metadata for verification...")
                            # Update the UI to show the fake metadata
                            self.root.after(1000, lambda: self.display_fake_metadata_result(primary_output))
                else:
                    self.log(f"❌ Failed to save to any location")
                
                # Update progress
                progress = (processed / total_files) * 100
                self.progress['value'] = progress
                self.progress_label.config(text=f"Fake metadata {processed}/{total_files}")
            
            # Final update
            self.progress['value'] = 100
            self.progress_label.config(text="🎭 Well DONE !!! - Fake metadata completed")
            self.log(f"🎭 Fake metadata process completed! {processed}/{total_files} files saved")
            
            # Show completion popup
            self.root.after(0, self.show_fake_completion_popup, processed, total_files)
            
        except Exception as e:
            self.log(f"💥 Critical error in fake metadata process: {str(e)}")
            self.progress['value'] = 100
            self.progress_label.config(text="🎭 Process completed")
            self.root.after(0, lambda: messagebox.showinfo("Well DONE !!!", "Fake metadata process completed!"))
            
        finally:
            self.is_processing = False
            self.root.after(0, lambda: self.clean_btn.config(state='normal', text="🚀 START CLEANING"))
            self.root.after(0, lambda: self.fake_meta_btn.config(state='normal', text="🎭 SET FAKE METADATA"))
    
    def display_fake_metadata_result(self, file_path):
        """Display the fake metadata result to verify it worked"""
        try:
            # Extract and display metadata
            metadata = self.extract_metadata_for_file(file_path)
            
            self.metadata_text.config(state='normal')
            self.metadata_text.delete(1.0, tk.END)
            
            if "Error" in metadata:
                self.meta_summary.config(text="❌ Could not extract fake metadata")
                self.metadata_text.insert(tk.END, f"❌ Error: {metadata['Error']}")
            else:
                tag_count = len(metadata)
                # Look for our fake metadata
                fake_tags_found = []
                
                if 'GPSLatitude' in metadata or 'GPSLongitude' in metadata:
                    fake_tags_found.append("GPS")
                if 'Make' in metadata or 'Model' in metadata:
                    fake_tags_found.append("Camera")
                if 'DateTimeOriginal' in metadata or 'CreateDate' in metadata:
                    fake_tags_found.append("Date")
                if 'Artist' in metadata:
                    fake_tags_found.append("Artist")
                if 'Copyright' in metadata:
                    fake_tags_found.append("Copyright")
                    
                self.meta_summary.config(
                    text=f"🎭 FAKE METADATA APPLIED: {len(fake_tags_found)} fake tags • {tag_count} total tags"
                )
                
                # Display all metadata in readable format
                for key, value in metadata.items():
                    if any(fake_tag in key for fake_tag in ['GPS', 'Make', 'Model', 'Date', 'Artist', 'Copyright', 'Software', 'ImageDescription']):
                        self.metadata_text.insert(tk.END, f"🎭 {key}: {value}\n")
                    else:
                        self.metadata_text.insert(tk.END, f"🔹 {key}: {value}\n")
                
                self.log(f"🔍 Fake metadata verification: Found {len(fake_tags_found)} fake tags")
                
                # Auto-switch to metadata tab to show results
                notebook = self.metadata_text.master.master.master.master
                notebook.select(0)  # Switch to preview tab
            
            self.metadata_text.config(state='disabled')
            
        except Exception as e:
            self.log(f"⚠️ Could not display fake metadata: {str(e)}")

    def show_fake_completion_popup(self, processed, total_files):
        """Show completion popup for fake metadata"""
        try:
            message = f"🎉 Well DONE !!!\n\n"
            message += f"Fake metadata process completed!\n"
            message += f"✅ Processed: {processed}/{total_files} files\n\n"
            
            if self.output_folders:
                message += "📁 Saved to ALL desktops:\n"
                for i, folder in enumerate(self.output_folders[:3]):
                    folder_name = os.path.basename(folder)
                    parent_dir = os.path.basename(os.path.dirname(folder))
                    message += f"   • {parent_dir}\\{folder_name}\n"
                
                if len(self.output_folders) > 3:
                    message += f"   • ... and {len(self.output_folders) - 3} more locations\n"
            
            messagebox.showinfo("Well DONE !!!", message)
        except Exception as e:
            messagebox.showinfo("Well DONE !!!", "Fake metadata process completed!")

    def process_images(self):
        """Process images for cleaning - ALWAYS SHOW Well DONE"""
        try:
            total_files = len(self.selected_files)
            processed = 0
            self.cleaned_metadata.clear()
            
            # DOUBLE CHECK FOLDERS EXIST
            self.ensure_output_folders_exist()
            
            for input_file in self.selected_files:
                if not self.is_processing:
                    break
                    
                # Generate random filename
                file_ext = os.path.splitext(input_file)[1]
                random_name = f"cleaned_{uuid.uuid4().hex[:8]}{file_ext}"
                
                # Save to all available output folders
                saved_locations = []
                for output_folder in self.output_folders:
                    try:
                        output_file = os.path.join(output_folder, random_name)
                        self.log(f"🔄 Processing: {os.path.basename(input_file)} → {random_name}")
                        
                        # Clean the image
                        success = self.clean_image(input_file, output_file)
                        
                        if success:
                            saved_locations.append(output_folder)
                            self.log(f"✅ Successfully cleaned: {random_name} in {output_folder}")
                            
                            # Store cleaned metadata for comparison (only once)
                            if output_folder == self.output_folders[0]:
                                cleaned_meta = self.extract_metadata_for_file(output_file)
                                self.cleaned_metadata[input_file] = cleaned_meta
                                
                                # Log cleaning results
                                original_count = len(self.original_metadata.get(input_file, {}))
                                cleaned_count = len(cleaned_meta)
                                removed = original_count - cleaned_count
                                
                                self.log(f"   📊 Removed {removed} metadata tags ({cleaned_count} remaining)")
                        else:
                            self.log(f"❌ Failed to clean: {os.path.basename(input_file)} in {output_folder}")
                    except Exception as e:
                        self.log(f"⚠️ Error saving to {output_folder}: {str(e)}")
                
                if saved_locations:
                    processed += 1
                    
                # Update progress - ALWAYS REACH 100%
                progress = ((processed + 1) / total_files) * 100
                self.progress['value'] = progress
                self.progress_label.config(text=f"Cleaning {processed+1}/{total_files}")
                    
            # Final update and comparison - ALWAYS 100%
            self.progress['value'] = 100
            self.progress_label.config(text="🎉 Well DONE !!! - Cleaning completed")
            self.log(f"🎉 Cleaning completed! {processed}/{total_files} files processed successfully")
            
            # Auto-show comparison
            self.show_auto_comparison()
            
            # Show Well DONE popup regardless of success/failure
            self.root.after(0, self.show_cleaning_completion_popup, processed, total_files)
            
        except Exception as e:
            self.log(f"💥 Unexpected error: {str(e)}")
            # Still show Well DONE and set progress to 100%
            self.progress['value'] = 100
            self.progress_label.config(text="🎉 Well DONE !!! - Process completed")
            self.root.after(0, self.show_cleaning_completion_popup, processed, total_files)
            
        finally:
            self.is_processing = False
            self.root.after(0, lambda: self.clean_btn.config(state='normal', text="🚀 START CLEANING"))
            self.root.after(0, lambda: self.fake_meta_btn.config(state='normal', text="🎭 SET FAKE METADATA"))
            
    def show_cleaning_completion_popup(self, processed, total_files):
        """Show completion popup for cleaning"""
        try:
            message = f"🎉 Well DONE !!!\n\n"
            message += f"Cleaning process completed!\n"
            message += f"✅ Processed: {processed}/{total_files} files\n\n"
            
            if self.output_folders:
                message += "📁 Saved to ALL desktops:\n"
                for i, folder in enumerate(self.output_folders[:3]):
                    folder_name = os.path.basename(folder)
                    parent_dir = os.path.basename(os.path.dirname(folder))
                    message += f"   • {parent_dir}\\{folder_name}\n"
                
                if len(self.output_folders) > 3:
                    message += f"   • ... and {len(self.output_folders) - 3} more locations\n"
            
            messagebox.showinfo("Well DONE !!!", message)
        except Exception as e:
            messagebox.showinfo("Well DONE !!!", "Cleaning process completed!")
            
    def clean_image(self, input_file, output_file):
        """Clean metadata from an image with quality optimization"""
        try:
            # First copy the original file to output location
            shutil.copy2(input_file, output_file)
            
            clean_mode = self.clean_mode.get()
            success_methods = 0
            
            # Use ExifTool if available
            if self.exiftool_path and os.path.exists(self.exiftool_path):
                try:
                    # Remove ALL metadata
                    result = subprocess.run([
                        self.exiftool_path, 
                        '-all=',  # Remove all metadata
                        '-overwrite_original',  # Overwrite the file
                        output_file
                    ], capture_output=True, text=True, timeout=15)
                    
                    if result.returncode == 0:
                        success_methods += 1
                        self.log(f"   ✅ ExifTool: Removed all metadata")
                    else:
                        self.log(f"   ⚠️ ExifTool: {result.stderr}")
                        
                except Exception as e:
                    self.log(f"⚠️ ExifTool error: {e}")
                    
            # Use ImageMagick for ultra cleaning
            if self.imagemagick_path and clean_mode == "ultra":
                try:
                    magick_exe = os.path.join(self.imagemagick_path, "magick.exe")
                    if os.path.exists(magick_exe):
                        result = subprocess.run([
                            magick_exe,
                            output_file,
                            '-strip',  # Strip all metadata and profiles
                            output_file
                        ], capture_output=True, text=True, timeout=15)
                        
                        if result.returncode == 0:
                            success_methods += 1
                            self.log(f"   ✅ ImageMagick: Stripped all metadata")
                        else:
                            self.log(f"   ⚠️ ImageMagick: {result.stderr}")
                except Exception as e:
                    self.log(f"⚠️ ImageMagick error: {e}")
                    
            # Final optimization with Pillow
            try:
                with Image.open(output_file) as img:
                    # Get current quality setting
                    current_quality = self.image_quality.get()
                    
                    # Save with optimized quality settings
                    save_kwargs = {'optimize': True}
                    
                    # Only apply quality parameter for JPEG format
                    if img.format in ('JPEG', 'JPG'):
                        save_kwargs['quality'] = current_quality
                        save_kwargs['progressive'] = True
                    
                    img.save(output_file, **save_kwargs)
                    
                success_methods += 1
                self.log(f"   ✅ Image optimized and saved (Quality: {current_quality}%)")
                
            except Exception as e:
                self.log(f"⚠️ Pillow processing: {e}")
                # If save fails, at least we have the cleaned file
                success_methods += 1
                
            return success_methods > 0
            
        except Exception as e:
            self.log(f"❌ Clean failed for {os.path.basename(input_file)}: {str(e)}")
            # Don't delete output file - keep what we have
            return False

    def show_auto_comparison(self):
        """Automatically show comparison after cleaning"""
        if not self.original_metadata or not self.cleaned_metadata:
            return
            
        self.compare_text.config(state='normal')
        self.compare_text.delete(1.0, tk.END)
        
        self.compare_text.insert(tk.END, "🛡️ AUTOMATIC METADATA CLEANING REPORT\n")
        self.compare_text.insert(tk.END, "=" * 50 + "\n\n")
        
        total_removed = 0
        total_original = 0
        total_cleaned = 0
        
        for file_path, original_meta in self.original_metadata.items():
            filename = os.path.basename(file_path)
            cleaned_meta = self.cleaned_metadata.get(file_path, {})
            
            original_count = len(original_meta) if not "Error" in original_meta else 0
            cleaned_count = len(cleaned_meta) if not "Error" in cleaned_meta else 0
            removed = original_count - cleaned_count
            
            total_original += original_count
            total_cleaned += cleaned_count
            total_removed += removed
            
            self.compare_text.insert(tk.END, f"📄 {filename}:\n")
            self.compare_text.insert(tk.END, f"   📊 Before: {original_count} tags\n")
            self.compare_text.insert(tk.END, f"   📊 After:  {cleaned_count} tags\n")
            self.compare_text.insert(tk.END, f"   🗑️ Removed: {removed} tags\n")
            
            self.compare_text.insert(tk.END, "\n")
        
        # Summary
        self.compare_text.insert(tk.END, "📈 SUMMARY:\n")
        self.compare_text.insert(tk.END, f"✅ Total files processed: {len(self.original_metadata)}\n")
        self.compare_text.insert(tk.END, f"🗑️ Total tags removed: {total_removed}\n")
        self.compare_text.insert(tk.END, f"📊 Effectiveness: {((total_removed/total_original)*100 if total_original > 0 else 0):.1f}%\n")
        self.compare_text.insert(tk.END, f"🛡️ Privacy improved: {total_removed} metadata tags eliminated\n\n")
        
        self.compare_text.insert(tk.END, "🎉 Well DONE !!! Your images are now cleaner and more private!")
        
        self.compare_text.config(state='disabled')
        
        # Auto-switch to comparison tab
        notebook = self.compare_text.master.master.master
        notebook.select(1)
        
    def clear_file_list(self):
        self.selected_files = []
        self.file_listbox.delete(0, tk.END)
        self.file_count_label.config(text="No files selected")
        self.preview_label.config(text="No image selected\n\nSelect images to preview")
        self.file_info.config(text="")
        self.meta_summary.config(text="")
        self.metadata_text.config(state='normal')
        self.metadata_text.delete(1.0, tk.END)
        self.metadata_text.insert(tk.END, "Select an image to view its metadata...")
        self.metadata_text.config(state='disabled')
        self.log("🗑️ File list cleared")
        
    def select_all_files(self):
        if self.selected_files:
            self.file_listbox.select_set(0, tk.END)
            self.on_file_select(None)
        
    def clean_entire_folder(self):
        folder = filedialog.askdirectory(title="Select Folder to Clean All Images")
        if folder:
            extensions = ('*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tiff', '*.webp')
            image_files = []
            for ext in extensions:
                image_files.extend([os.path.join(folder, f) for f in os.listdir(folder) if f.lower().endswith(ext[1:])])
            
            if image_files:
                self.selected_files = image_files
                self.file_listbox.delete(0, tk.END)
                for file in self.selected_files:
                    self.file_listbox.insert(tk.END, os.path.basename(file))
                
                self.file_count_label.config(text=f"📁 Folder: {len(image_files)} images found")
                self.log(f"📁 Added {len(image_files)} images from folder")
                
                # AUTO-SELECT FIRST IMAGE
                if self.selected_files:
                    self.file_listbox.selection_set(0)
                    self.on_file_select(None)
            else:
                messagebox.showinfo("No Images", "No supported images found in selected folder.")
        
    def generate_report(self):
        if not self.cleaned_metadata:
            messagebox.showinfo("No Data", "Please clean some images first to generate a report.")
            return
            
        primary_folder = self.get_primary_output_folder()
        report_file = os.path.join(primary_folder, "cleaning_report.txt")
        with open(report_file, 'w') as f:
            f.write("ImageSilencer Pro - Cleaning Report\n")
            f.write("=" * 50 + "\n\n")
            f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
            
            for file_path, original_meta in self.original_metadata.items():
                filename = os.path.basename(file_path)
                cleaned_meta = self.cleaned_metadata.get(file_path, {})
                
                original_count = len(original_meta) if not "Error" in original_meta else 0
                cleaned_count = len(cleaned_meta) if not "Error" in cleaned_meta else 0
                
                f.write(f"File: {filename}\n")
                f.write(f"  Original metadata tags: {original_count}\n")
                f.write(f"  Remaining metadata tags: {cleaned_count}\n")
                f.write(f"  Tags removed: {original_count - cleaned_count}\n\n")
        
        self.log(f"📄 Report saved: {report_file}")
        messagebox.showinfo("Report Generated", f"Cleaning report saved to:\n{report_file}")
        
    def clean_temp_files(self):
        temp_dir = tempfile.gettempdir()
        cleaned = 0
        for file in os.listdir(temp_dir):
            if file.startswith("ImageSilencer") or file.startswith("exif"):
                try:
                    os.remove(os.path.join(temp_dir, file))
                    cleaned += 1
                except:
                    pass
                    
        self.log(f"🧹 Cleaned {cleaned} temporary files")

def is_admin():
    """Check if the program is running with administrator privileges"""
    try:
        return ctypes.windll.shell32.IsUserAnAdmin()
    except:
        return False

def main():
    # Check if running as admin, if not, restart with admin rights
    if not is_admin():
        try:
            # Re-run the program with admin rights
            ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
            sys.exit(0)  # Exit the current instance
        except Exception as e:
            print(f"Failed to restart with admin rights: {e}")
            # Continue without admin rights if restart fails
    
    root = tk.Tk()
    app = ImageSilencerApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()