git_repository_manager.py

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import os
import re
import json
import subprocess
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import threading
from datetime import datetime
import hashlib
import time
import functools
import sys
import atexit
import traceback
import uuid

# ----------------------------------------------------------------------------------
# Diagnostic / Logging Utilities (added to investigate rapid restart issue)
# ----------------------------------------------------------------------------------

APP_BASE_DIR = Path(getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__))))
LOG_FILE = APP_BASE_DIR / "manager_debug.log"
LOCK_FILE = APP_BASE_DIR / "git_repository_manager.lock"

def _safe_log(msg: str):
    """Append a timestamped line to the debug log (best-effort)."""
    try:
        LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
        with LOG_FILE.open("a", encoding="utf-8") as f:
            f.write(f"{datetime.utcnow().isoformat()}Z | {msg}\n")
    except Exception:
        pass

def _install_global_exception_hook():
    def _hook(exc_type, exc, tb):
        _safe_log("UNCAUGHT_EXCEPTION: " + ''.join(traceback.format_exception(exc_type, exc, tb)))
        # Show a message box if GUI is up (avoid infinite recursion if Tk not ready)
        try:
            root = tk._default_root  # type: ignore
            if root:
                messagebox.showerror("Fatal Error", f"{exc_type.__name__}: {exc}")
        except Exception:
            pass
    sys.excepthook = _hook

def _acquire_single_instance_lock():
    """Create a lock file to prevent multiple concurrent instances (helps rule out spawn loops)."""
    try:
        if LOCK_FILE.exists():
            # If stale (older than 1 day) remove it
            try:
                if time.time() - LOCK_FILE.stat().st_mtime > 86400:
                    LOCK_FILE.unlink(missing_ok=True)
                else:
                    _safe_log("Another instance detected (lock file present). Exiting early.")
                    # Provide a small delay so a flashing console is observable if run non-windowed
                    time.sleep(0.35)
                    sys.exit(0)
            except Exception:
                # If we cannot access the lock file reliably, continue but log
                _safe_log("Lock file access issue; proceeding anyway.")
        LOCK_FILE.write_text(f"pid={os.getpid()} guid={uuid.uuid4()} time={datetime.utcnow().isoformat()}Z")
        atexit.register(lambda: LOCK_FILE.exists() and LOCK_FILE.unlink())
    except Exception as e:
        _safe_log(f"Failed to establish lock: {e}")

_install_global_exception_hook()
# _acquire_single_instance_lock()
_safe_log(f"PROCESS_START | frozen={getattr(sys,'frozen',False)} | pid={os.getpid()} | cwd={os.getcwd()}")

# ----------------------------------------------------------------------------------
# Silent Git command helper (prevents flashing consoles on Windows)
# ----------------------------------------------------------------------------------

def run_git(cmd, cwd):
    """
    Run a git command silently (no console window) and return CompletedProcess.
    Mirrors prior parameters: capture_output=True, text mode, utf-8, replace errors.
    """
    creationflags = 0
    startupinfo = None
    if os.name == 'nt':
        # Suppress console window for child processes
        creationflags = getattr(subprocess, 'CREATE_NO_WINDOW', 0)
        try:
            startupinfo = subprocess.STARTUPINFO()  # type: ignore[attr-defined]
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW  # type: ignore[attr-defined]
        except Exception:
            startupinfo = None
    try:
        result = subprocess.run(
            cmd,
            cwd=cwd,
            capture_output=True,
            text=True,
            encoding='utf-8',
            errors='replace',
            startupinfo=startupinfo,
            creationflags=creationflags
        )
        return result
    except Exception as e:
        _safe_log(f"GIT_CMD_FAIL | cmd={cmd} | cwd={cwd} | error={e}")
        raise


# Global benchmarking configuration
BENCHMARKING_ENABLED = True  # Set to False to disable all benchmarks


def benchmark(func=None, *, print_args=False):
    """
    Decorator to benchmark method execution time.
    
    Args:
        func: The function being decorated
        print_args: Whether to print function arguments in the benchmark output
    
    Usage:
        @benchmark
        def my_method(self):
            pass
            
        @benchmark(print_args=True)
        def my_method_with_args(self, arg1, arg2):
            pass
    """
    def decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kwargs):
            if not BENCHMARKING_ENABLED:
                return f(*args, **kwargs)
                
            start_time = time.perf_counter()
            try:
                result = f(*args, **kwargs)
                end_time = time.perf_counter()
                execution_time = end_time - start_time
                
                # Format the function name and class name if it's a method
                if args and hasattr(args[0], '__class__'):
                    func_name = f"{args[0].__class__.__name__}.{f.__name__}"
                else:
                    func_name = f.__name__
                
                # Format arguments if requested
                args_str = ""
                if print_args and len(args) > 1:  # Skip 'self' argument
                    args_repr = [repr(arg) for arg in args[1:]]
                    kwargs_repr = [f"{k}={repr(v)}" for k, v in kwargs.items()]
                    all_args = args_repr + kwargs_repr
                    if all_args:
                        args_str = f" with args({', '.join(all_args)})"
                
                print(f"🚀 BENCHMARK: {func_name}{args_str} took {execution_time:.4f} seconds")
                return result
                
            except Exception as e:
                end_time = time.perf_counter()
                execution_time = end_time - start_time
                func_name = f"{args[0].__class__.__name__}.{f.__name__}" if args and hasattr(args[0], '__class__') else f.__name__
                print(f"❌ BENCHMARK: {func_name} failed after {execution_time:.4f} seconds - {str(e)}")
                raise
                
        return wrapper
    
    if func is None:
        return decorator
    else:
        return decorator(func)


def toggle_benchmarking():
    """Toggle benchmarking on/off"""
    global BENCHMARKING_ENABLED
    BENCHMARKING_ENABLED = not BENCHMARKING_ENABLED
    status = "ENABLED" if BENCHMARKING_ENABLED else "DISABLED"
    print(f"📊 Benchmarking {status}")


def time_operation(operation_name: str):
    """Context manager for timing specific operations"""
    class TimerContext:
        def __init__(self, name: str):
            self.name = name
            self.start_time = None
            
        def __enter__(self):
            self.start_time = time.perf_counter()
            return self
            
        def __exit__(self, exc_type, exc_val, exc_tb):
            if BENCHMARKING_ENABLED:
                end_time = time.perf_counter()
                execution_time = end_time - self.start_time
                if exc_type is None:
                    print(f"⏱️  {self.name} took {execution_time:.4f} seconds")
                else:
                    print(f"❌ {self.name} failed after {execution_time:.4f} seconds")
    
    return TimerContext(operation_name)


def benchmark_method(obj, method_name, *args, **kwargs):
    """Benchmark any method call on demand"""
    if not BENCHMARKING_ENABLED:
        return getattr(obj, method_name)(*args, **kwargs)
        
    method = getattr(obj, method_name)
    class_name = obj.__class__.__name__ if hasattr(obj, '__class__') else 'Unknown'
    
    start_time = time.perf_counter()
    try:
        result = method(*args, **kwargs)
        end_time = time.perf_counter()
        execution_time = end_time - start_time
        print(f"🚀 MANUAL BENCHMARK: {class_name}.{method_name} took {execution_time:.4f} seconds")
        return result
    except Exception as e:
        end_time = time.perf_counter()
        execution_time = end_time - start_time
        print(f"❌ MANUAL BENCHMARK: {class_name}.{method_name} failed after {execution_time:.4f} seconds - {str(e)}")
        raise


class GitCommit:
    def __init__(self, commit_sha: str, message: str = "", author: str = "", 
                 date: str = "", repo_path: str = ""):
        self.commit_sha = commit_sha
        self.message = message
        self.author = author
        self.date = date
        self.repo_path = repo_path
        self.branch_names: List[str] = []  # Multiple branch heads can point to same commit

    def add_branch_name(self, name: str):
        """Add a branch name that points to this commit"""
        if name not in self.branch_names:
            self.branch_names.append(name)

    def get_branch_names_display(self) -> str:
        """Get branch names formatted for display"""
        return "; ".join(self.branch_names) if self.branch_names else ""


class GitBranch:
    def __init__(self, name: str, commit_sha: str, commit_message: str = "", author: str = "", 
                 date: str = "", is_remote: bool = False, repo_path: str = ""):
        self.name = name
        self.commit_sha = commit_sha
        self.commit_message = commit_message
        self.author = author
        self.date = date
        self.is_remote = is_remote
        self.repo_path = repo_path
        self._commit_info_loaded = False
    
    def load_commit_info_if_needed(self):
        """Load commit information only when needed"""
        if not self._commit_info_loaded and self.repo_path:
            commit_info = self._get_commit_info()
            self.commit_message = commit_info.get('message', '')
            self.author = commit_info.get('author', '')
            self.date = commit_info.get('date', '')
            self._commit_info_loaded = True
    
    def _get_commit_info(self) -> Dict[str, str]:
        """Get detailed commit information"""
        try:
            cmd = ["git", "show", "--format=%an|%ad|%s", "--date=short", "--no-patch", self.commit_sha]
            result = subprocess.run(cmd, cwd=self.repo_path, capture_output=True, text=True)
            
            if result.returncode == 0:
                output_lines = result.stdout.strip().split('\n')
                if output_lines and output_lines[0]:
                    parts = output_lines[0].split('|', 2)
                    if len(parts) >= 3:
                        return {
                            'author': parts[0].strip(),
                            'date': parts[1].strip(),
                            'message': parts[2].strip()
                        }
                    elif len(parts) == 2:
                        return {
                            'author': parts[0].strip(),
                            'date': parts[1].strip(),
                            'message': ''
                        }
        except Exception as e:
            print(f"Error getting commit info for {self.commit_sha}: {e}")
        
        return {'author': '', 'date': '', 'message': ''}
    
    def to_dict(self) -> dict:
        """Serialize branch to dictionary"""
        return {
            "name": self.name,
            "commit_sha": self.commit_sha,
            "commit_message": self.commit_message,
            "author": self.author,
            "date": self.date,
            "is_remote": self.is_remote,
            "repo_path": self.repo_path,
            "_commit_info_loaded": self._commit_info_loaded
        }
    
    @classmethod
    def from_dict(cls, data: dict) -> 'GitBranch':
        """Deserialize branch from dictionary"""
        branch = cls(
            name=data.get("name", ""),
            commit_sha=data.get("commit_sha", ""),
            commit_message=data.get("commit_message", ""),
            author=data.get("author", ""),
            date=data.get("date", ""),
            is_remote=data.get("is_remote", False),
            repo_path=data.get("repo_path", "")
        )
        branch._commit_info_loaded = data.get("_commit_info_loaded", False)
        return branch


class GitRepository:
    def __init__(self, path: str, is_submodule: bool = False):
        self.path = path
        self.name = os.path.basename(path)
        self.is_submodule = is_submodule
        self.local_branches: List[GitBranch] = []
        self.remote_branches: List[GitBranch] = []
        self.submodules: List['GitRepository'] = []
        self._branches_loaded = False
        self._submodules_loaded = False
        self._last_hash = None  # For change detection
        
    def get_repo_hash(self) -> str:
        """Get hash representing current state of repository"""
        try:
            # Get the latest commit hash and refs info for change detection
            result = run_git(["git", "rev-parse", "HEAD"], self.path)
            head_hash = result.stdout.strip() if result.returncode == 0 else ""
            
            # Get all refs for comprehensive change detection
            result = run_git(["git", "show-ref"], self.path)
            refs_hash = hashlib.md5(result.stdout.encode()).hexdigest() if result.returncode == 0 else ""
            
            return hashlib.md5(f"{head_hash}:{refs_hash}".encode()).hexdigest()
        except Exception:
            return ""
    
    def has_changes(self) -> bool:
        """Check if repository has changes since last scan"""
        current_hash = self.get_repo_hash()
        if self._last_hash is None or self._last_hash != current_hash:
            self._last_hash = current_hash
            return True
        return False
        
    # @benchmark
    def load_branches_if_needed(self):
        """Load branches, but check for changes first"""
        if not self._branches_loaded or self.has_changes():
            self.load_branches()
    
    @benchmark
    def load_branches(self):
        """Load local and remote branches from the git repository"""
        try:
            # Get local branches with full info
            self.local_branches = self._get_branches(local=True)
            # Get remote branches with full info
            self.remote_branches = self._get_branches(local=False)
            # Load submodules if this is not a submodule itself
            if not self.is_submodule and not self._submodules_loaded:
                self.load_submodules()
            self._branches_loaded = True
            # Update hash after successful load
            self._last_hash = self.get_repo_hash()
        except Exception as e:
            print(f"Error loading branches for {self.path}: {e}")
        except Exception as e:
            print(f"Error loading branches for {self.path}: {e}")
    
    def load_submodules(self):
        """Load submodules from the git repository"""
        if self._submodules_loaded:
            return
            
        try:
            # Get submodule list using git command
            result = run_git(["git", "submodule", "status"], self.path)
            
            if result.returncode == 0 and result.stdout:
                for line in result.stdout.split('\n'):
                    line = line.strip()
                    if line:
                        # Parse submodule status line
                        # Format: " 160000 commit_sha path (tag)"
                        parts = line.split()
                        if len(parts) >= 2:
                            submodule_path = parts[1] if not parts[0].startswith('-') else parts[1]
                            full_submodule_path = os.path.join(self.path, submodule_path)
                            
                            if os.path.exists(full_submodule_path):
                                submodule = GitRepository(full_submodule_path, is_submodule=True)
                                # Don't load branches immediately for submodules
                                self.submodules.append(submodule)
            self._submodules_loaded = True
        except Exception as e:
            print(f"Error loading submodules for {self.path}: {e}")
    
    def get_current_branch_commits(self, limit: int = 20) -> Tuple[str, List[GitCommit]]:
        """Get current branch name and its last N commits with branch information"""
        try:
            # Get current branch name
            result = run_git(["git", "symbolic-ref", "--short", "HEAD"], self.path)
            current_branch = result.stdout.strip() if result.returncode == 0 else "HEAD"
            
            # Get the last N commits from current branch
            result = run_git(["git", "log", f"-{limit}", "--format=%H|%an|%ad|%s", "--date=short"], self.path)
            
            commits = []
            if result.returncode == 0 and result.stdout:
                # Parse commits
                for line in result.stdout.split('\n'):
                    line = line.strip()
                    if not line:
                        continue
                    
                    parts = line.split('|', 3)
                    if len(parts) >= 4:
                        commit_sha = parts[0]
                        author = parts[1]
                        date = parts[2] 
                        message = parts[3]
                        commit = GitCommit(
                            commit_sha=commit_sha,
                            message=message,
                            author=author,
                            date=date,
                            repo_path=self.path
                        )
                        commits.append(commit)
                
                # Now get branch information for each commit
                self._add_branch_info_to_commits(commits)
            
            return current_branch, commits
            
        except Exception as e:
            print(f"Error getting current branch commits for {self.path}: {e}")
            return "unknown", []

    def _add_branch_info_to_commits(self, commits: List[GitCommit]):
        """Add branch name information to commits"""
        try:
            # Get all branch heads (local and remote) that point to commits
            result = run_git(["git", "for-each-ref", "--format=%(refname:short)|%(objectname)", "refs/heads/", "refs/remotes/"], self.path)
            
            if result.returncode == 0 and result.stdout:
                # Create a mapping of commit SHA to branch names
                commit_to_branches = {}
                for line in result.stdout.split('\n'):
                    line = line.strip()
                    if not line:
                        continue
                    
                    parts = line.split('|', 1)
                    if len(parts) >= 2:
                        branch_name = parts[0]
                        commit_sha = parts[1]
                        
                        # Keep remote branch names with origin path, but skip origin/HEAD
                        if branch_name == 'origin/HEAD':
                            continue  # Skip origin/HEAD
                        
                        if commit_sha not in commit_to_branches:
                            commit_to_branches[commit_sha] = []
                        commit_to_branches[commit_sha].append(branch_name)
                
                # Add branch information to commits
                for commit in commits:
                    if commit.commit_sha in commit_to_branches:
                        for branch_name in commit_to_branches[commit.commit_sha]:
                            commit.add_branch_name(branch_name)
                            
        except Exception as e:
            print(f"Error adding branch info to commits: {e}")

    def _get_branches(self, local: bool = True) -> List[GitBranch]:
        """Get branches from git repository with full commit info"""
        branches = []
        try:
            # Get branch info with commit details in one command
            if local:
                cmd = ["git", "for-each-ref", "--format=%(refname:short)|%(objectname)|%(authorname)|%(authordate:short)|%(subject)", "refs/heads/"]
            else:
                cmd = ["git", "for-each-ref", "--format=%(refname:short)|%(objectname)|%(authorname)|%(authordate:short)|%(subject)", "refs/remotes/"]
            result = run_git(cmd, self.path)
            if result.returncode != 0:
                return branches
            
            if result.stdout:
                for line in result.stdout.split('\n'):
                    line = line.strip()
                    if not line:
                        continue
                    
                    # Parse the formatted output: name|sha|author|date|message
                    parts = line.split('|', 4)
                    if len(parts) >= 5:
                        branch_name = parts[0]
                        commit_sha = parts[1]
                        author = parts[2]
                        date = parts[3]
                        message = parts[4]
                        
                        # For remote branches, clean up the name
                        if not local and '/' in branch_name:
                            # Remove 'origin/' prefix for display
                            display_name = '/'.join(branch_name.split('/')[1:]) if '/' in branch_name else branch_name
                        else:
                            display_name = branch_name
                        
                        # Create branch with full commit info loaded
                        branch = GitBranch(
                            name=display_name,
                            commit_sha=commit_sha,
                            commit_message=message,
                            author=author,
                            date=date,
                            is_remote=not local,
                            repo_path=self.path
                        )
                        branch._commit_info_loaded = True  # Mark as loaded since we have the info
                        branches.append(branch)
        except Exception as e:
            print(f"Error getting branches: {e}")
        
        return branches
    
    def to_dict(self) -> dict:
        """Serialize repository to dictionary"""
        return {
            "path": self.path,
            "name": self.name,
            "is_submodule": self.is_submodule,
            "local_branches": [branch.to_dict() for branch in self.local_branches],
            "remote_branches": [branch.to_dict() for branch in self.remote_branches],
            "submodules": [submodule.to_dict() for submodule in self.submodules],
            "_branches_loaded": self._branches_loaded,
            "_submodules_loaded": self._submodules_loaded,
            "_last_hash": self._last_hash
        }
    
    @classmethod
    def from_dict(cls, data: dict) -> 'GitRepository':
        """Deserialize repository from dictionary"""
        repo = cls(data.get("path", ""), data.get("is_submodule", False))
        repo.name = data.get("name", "")
        repo.local_branches = [GitBranch.from_dict(b) for b in data.get("local_branches", [])]
        repo.remote_branches = [GitBranch.from_dict(b) for b in data.get("remote_branches", [])]
        repo.submodules = [cls.from_dict(s) for s in data.get("submodules", [])]
        repo._branches_loaded = data.get("_branches_loaded", False)
        repo._submodules_loaded = data.get("_submodules_loaded", False)
        repo._last_hash = data.get("_last_hash", None)
        return repo


class FolderNode:
    def __init__(self, path: str, name: str, level: int = 0):
        self.path = path
        self.name = name
        self.level = level
        self.children: List['FolderNode'] = []
        self.repositories: List[GitRepository] = []
        self.has_repositories = False
    
    def add_repository(self, repo: GitRepository):
        self.repositories.append(repo)
        self.has_repositories = True
        # Mark all parent nodes as having repositories
        self._mark_parents_with_repos()
    
    def _mark_parents_with_repos(self):
        # This would be implemented with parent references
        pass


class GitRepositoryManager:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("Git Repository Manager")
        self.root.geometry("1200x800")
        
        # Data
        self.selected_folder = ""
        self.repositories: Dict[str, GitRepository] = {}
        self.folder_tree: Dict[str, FolderNode] = {}
        self.current_commits: List[GitCommit] = []
        self.filtered_commits: List[GitCommit] = []
        self.current_branches: List[GitBranch] = []
        self.filtered_branches: List[GitBranch] = []
        self.current_branch_name = ""
        
        # Settings
        self.repo_filter_regex = ""
        self.branch_filter_user = ""
        self.branch_filter_message = ""
        self.show_commit_sha = tk.BooleanVar(value=True)
        self.show_commit_message = tk.BooleanVar(value=True)
        self.show_author = tk.BooleanVar(value=True)
        self.show_date = tk.BooleanVar(value=True)
        self.sort_column = "date"  # Initially sort by date
        self.sort_reverse = True   # Most recent first

        # Performance / filtering
        self._filter_pending_id = None  # for debounce of branch filter operations
        self._filter_debounce_ms = 220  # delay after last keystroke before heavy filtering
        self._during_filter = False     # flag to suppress branch reloads while filtering
        
        # New filter options
        self.match_case = tk.BooleanVar(value=False)
        self.match_whole_word = tk.BooleanVar(value=False)
        self.use_regex = tk.BooleanVar(value=False)
        self.search_scope = tk.StringVar(value="remote and local")
        
        # Colors for different levels (base palette)
        self.level_colors = ["#8B0000", "#0000CD", "#008B8B", "#8B008B", "#FF8C00", "#228B22"]

        # If system is using dark mode, slightly lighten the palette for better contrast
        try:
            if self._is_system_dark_mode():
                # Lighten by ~28% towards white
                self.level_colors = [self._lighten_hex(c, 0.28) for c in self.level_colors]
        except Exception:
            # Non-fatal: if detection fails, keep base colors
            pass

        self.setup_ui()
        self.load_settings()

    def _lighten_hex(self, hex_color: str, amount: float) -> str:
        """Return a lighter hex color moved `amount` (0..1) towards white.

        Examples: amount=0.2 -> 20% closer to white.
        """
        try:
            if not hex_color:
                return hex_color
            s = hex_color.lstrip('#')
            if len(s) != 6:
                return hex_color
            r = int(s[0:2], 16)
            g = int(s[2:4], 16)
            b = int(s[4:6], 16)

            def lighten(c):
                return int(c + (255 - c) * float(amount))

            nr = max(0, min(255, lighten(r)))
            ng = max(0, min(255, lighten(g)))
            nb = max(0, min(255, lighten(b)))
            return f"#{nr:02X}{ng:02X}{nb:02X}"
        except Exception:
            return hex_color

    def _is_system_dark_mode(self) -> bool:
        """Attempt to detect whether the OS is currently using a dark theme.

        Supports macOS (via `defaults`), Windows (registry), and a best-effort for some Linux desktops.
        Returns True if dark mode is detected, otherwise False.
        """
        try:
            import platform
            system = platform.system()
            if system == 'Darwin':
                # macOS: `defaults read -g AppleInterfaceStyle` returns 'Dark' when in dark mode
                try:
                    p = subprocess.run(['defaults', 'read', '-g', 'AppleInterfaceStyle'], capture_output=True, text=True)
                    out = (p.stdout or p.stderr or '').strip()
                    return 'Dark' in out
                except Exception:
                    return False
            elif system == 'Windows':
                try:
                    import winreg
                    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize') as key:
                        # AppsUseLightTheme == 0 means dark mode for apps
                        val, _ = winreg.QueryValueEx(key, 'AppsUseLightTheme')
                        return int(val) == 0
                except Exception:
                    return False
            else:
                # Linux / other: best-effort using gsettings (GNOME) or environment variables
                try:
                    p = subprocess.run(['gsettings', 'get', 'org.gnome.desktop.interface', 'color-scheme'], capture_output=True, text=True)
                    out = (p.stdout or p.stderr or '').strip().lower()
                    if 'dark' in out:
                        return True
                except Exception:
                    pass
                # Fallback: check GTK_THEME env for '-dark' suffix
                try:
                    gtk_theme = os.environ.get('GTK_THEME', '')
                    if gtk_theme and 'dark' in gtk_theme.lower():
                        return True
                except Exception:
                    pass
                return False
        except Exception:
            return False
    
    def setup_ui(self):
        """Setup the user interface"""
        # Main frame
        main_frame = ttk.Frame(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Top frame for folder selection and filters
        top_frame = ttk.Frame(main_frame)
        top_frame.pack(fill=tk.X, pady=(0, 10))
        
        # Folder selection
        folder_frame = ttk.Frame(top_frame)
        folder_frame.pack(fill=tk.X, pady=(0, 5))
        
        ttk.Label(folder_frame, text="Selected Folder:").pack(side=tk.LEFT)
        self.folder_label = ttk.Label(folder_frame, text="No folder selected")
        self.folder_label.pack(side=tk.LEFT, padx=(5, 0))
        
        ttk.Button(folder_frame, text="Select Folder", command=self.select_folder).pack(side=tk.RIGHT)
        ttk.Button(folder_frame, text="Rescan", command=self.rescan_folder).pack(side=tk.RIGHT, padx=(0, 5))
        
        # Repository filter
        filter_frame = ttk.Frame(top_frame)
        filter_frame.pack(fill=tk.X, pady=(0, 5))
        
        ttk.Label(filter_frame, text="Repository Filter (Regex):").pack(side=tk.LEFT)
        self.repo_filter_entry = ttk.Entry(filter_frame, width=30)
        self.repo_filter_entry.pack(side=tk.LEFT, padx=(5, 0))
        self.repo_filter_entry.bind('<KeyRelease>', self.on_repo_filter_change)
        
        # Branch filters
        commit_filter_frame = ttk.Frame(top_frame)
        commit_filter_frame.pack(fill=tk.X)
        
        ttk.Label(commit_filter_frame, text="Commit Filter - User:").pack(side=tk.LEFT)
        self.branch_user_entry = ttk.Entry(commit_filter_frame, width=20)
        self.branch_user_entry.pack(side=tk.LEFT, padx=(5, 10))
        self.branch_user_entry.bind('<KeyRelease>', self.on_branch_filter_change)
        
        ttk.Label(commit_filter_frame, text="Message:").pack(side=tk.LEFT)
        self.branch_message_entry = ttk.Entry(commit_filter_frame, width=20)
        self.branch_message_entry.pack(side=tk.LEFT, padx=(5, 0))
        self.branch_message_entry.bind('<KeyRelease>', self.on_branch_filter_change)
        
        # New filter options frame
        filter_options_frame = ttk.Frame(top_frame)
        filter_options_frame.pack(fill=tk.X, pady=(5, 0))
        
        # Checkboxes for filter options
        self.match_case_cb = ttk.Checkbutton(filter_options_frame, text="Match case", 
                                           variable=self.match_case, command=self.on_filter_option_change)
        self.match_case_cb.pack(side=tk.LEFT, padx=(0, 10))
        
        self.match_whole_word_cb = ttk.Checkbutton(filter_options_frame, text="Match whole word only", 
                                                 variable=self.match_whole_word, command=self.on_filter_option_change)
        self.match_whole_word_cb.pack(side=tk.LEFT, padx=(0, 10))
        
        self.use_regex_cb = ttk.Checkbutton(filter_options_frame, text="Regular expression", 
                                          variable=self.use_regex, command=self.on_filter_option_change)
        self.use_regex_cb.pack(side=tk.LEFT, padx=(0, 20))
        
        # Search scope combo box
        ttk.Label(filter_options_frame, text="Only search in:").pack(side=tk.LEFT, padx=(0, 5))
        self.search_scope_combo = ttk.Combobox(filter_options_frame, textvariable=self.search_scope, 
                                             values=["remote and local", "remote", "local"], 
                                             state="readonly", width=15)
        self.search_scope_combo.pack(side=tk.LEFT)
        self.search_scope_combo.bind('<<ComboboxSelected>>', self.on_search_scope_change)
        
        # Main content frame with paned window for resizable separator
        content_frame = ttk.Frame(main_frame)
        content_frame.pack(fill=tk.BOTH, expand=True)
        
        # Create PanedWindow for vertical separator
        self.paned_window = ttk.PanedWindow(content_frame, orient=tk.HORIZONTAL)
        self.paned_window.pack(fill=tk.BOTH, expand=True)
        
        # Left pane - Repository tree
        left_frame = ttk.Frame(self.paned_window)
        self.paned_window.add(left_frame, weight=1)
        
        ttk.Label(left_frame, text="Repositories").pack(anchor=tk.W)
        
        # Tree view for repositories
        tree_frame = ttk.Frame(left_frame)
        tree_frame.pack(fill=tk.BOTH, expand=True)
        
        self.repo_tree = ttk.Treeview(tree_frame)
        self.repo_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # Configure color tags for different levels
        self.repo_tree.tag_configure("folder", foreground="#696969")
        self.repo_tree.tag_configure("submodule", foreground="#FF6347")  # Tomato color for submodules
        for i, color in enumerate(self.level_colors):
            self.repo_tree.tag_configure(f"repo_level_{i}", foreground=color)
        
        repo_scrollbar = ttk.Scrollbar(tree_frame, orient=tk.VERTICAL, command=self.repo_tree.yview)
        repo_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.repo_tree.configure(yscrollcommand=repo_scrollbar.set)
        
        # Bind events
        self.repo_tree.bind('<Button-3>', self.on_tree_right_click)
        self.repo_tree.bind('<<TreeviewSelect>>', self.on_tree_select)
        
        # Right pane - Commit details
        right_frame = ttk.Frame(self.paned_window)
        self.paned_window.add(right_frame, weight=2)
        
        # Current branch label
        self.current_branch_label = ttk.Label(right_frame, text="No repository selected", font=("TkDefaultFont", 10, "bold"))
        self.current_branch_label.pack(anchor=tk.W, pady=(0, 5))
        
        # Remove the old branch display options since we'll use header context menu
        # Commit list
        ttk.Label(right_frame, text="Recent Commits").pack(anchor=tk.W)
        
        commit_frame = ttk.Frame(right_frame)
        commit_frame.pack(fill=tk.BOTH, expand=True)
        
        # Create treeview with columns (SHA moved to front, Name now shows branch heads)
        columns = ("sha", "name", "message", "author", "date")
        self.branch_tree = ttk.Treeview(commit_frame, columns=columns, show="headings")
        
        # Configure columns with SHA first, Name now shows branch heads
        self.branch_tree.heading("sha", text="SHA", command=lambda: self.sort_commits("sha"))
        self.branch_tree.heading("name", text="Branch Heads", command=lambda: self.sort_commits("name"))
        self.branch_tree.heading("message", text="Message", command=lambda: self.sort_commits("message"))
        self.branch_tree.heading("author", text="Author", command=lambda: self.sort_commits("author"))
        self.branch_tree.heading("date", text="Date", command=lambda: self.sort_commits("date"))
        
        # Set column widths (SHA first)
        self.branch_tree.column("sha", width=80)
        self.branch_tree.column("name", width=150)
        self.branch_tree.column("message", width=300)
        self.branch_tree.column("author", width=120)
        self.branch_tree.column("date", width=100)
        
        self.branch_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # Bind right-click to branch tree headers for column visibility
        self.branch_tree.bind('<Button-3>', self.on_branch_header_right_click)
        
        commit_scrollbar = ttk.Scrollbar(commit_frame, orient=tk.VERTICAL, command=self.branch_tree.yview)
        commit_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.branch_tree.configure(yscrollcommand=commit_scrollbar.set)
        
        # Context menu for repository tree
        self.context_menu = tk.Menu(self.root, tearoff=0)
        self.context_menu.add_command(label="Open in File Explorer", command=self.open_in_explorer)
        
        # Context menu for commit headers
        self.branch_header_menu = tk.Menu(self.root, tearoff=0)
        self.branch_header_menu.add_checkbutton(label="SHA", variable=self.show_commit_sha, 
                                               command=self.on_column_visibility_change)
        self.branch_header_menu.add_checkbutton(label="Branch Heads", state="disabled")  # Branch Heads always visible
        self.branch_header_menu.add_checkbutton(label="Message", variable=self.show_commit_message,
                                               command=self.on_column_visibility_change)
        self.branch_header_menu.add_checkbutton(label="Author", variable=self.show_author,
                                               command=self.on_column_visibility_change)
        self.branch_header_menu.add_checkbutton(label="Date", variable=self.show_date,
                                               command=self.on_column_visibility_change)
        
        # Add menu bar for debugging/benchmarking
        self.setup_menu_bar()
    
    def setup_menu_bar(self):
        """Setup the menu bar with debugging options"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)
        
        # Debug menu
        debug_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Debug", menu=debug_menu)
        
        debug_menu.add_command(label="Toggle Benchmarking", command=self.toggle_benchmarking)
        debug_menu.add_separator()
        debug_menu.add_command(label="Profile Repository Loading", command=self.profile_repo_loading)
        debug_menu.add_command(label="Profile Branch Filtering", command=self.profile_branch_filtering)
    
    def toggle_benchmarking(self):
        """Toggle benchmarking on/off"""
        toggle_benchmarking()
    
    def profile_repo_loading(self):
        """Profile repository loading performance"""
        if not self.repositories:
            messagebox.showwarning("No Data", "Please scan repositories first")
            return
            
        print(f"\n📊 PROFILING REPOSITORY LOADING ({len(self.repositories)} repositories)")
        print("=" * 60)
        
        slow_repos = []
        total_time = 0
        
        for repo_path, repo in self.repositories.items():
            with time_operation(f"Loading branches for {os.path.basename(repo_path)}"):
                start = time.perf_counter()
                repo.load_branches_if_needed()
                end = time.perf_counter()
                duration = end - start
                total_time += duration
                
                if duration > 0.1:  # More than 100ms
                    slow_repos.append((repo_path, duration))
        
        print(f"\n📈 SUMMARY:")
        print(f"Total time: {total_time:.3f}s")
        print(f"Average per repo: {total_time/len(self.repositories):.3f}s")
        
        if slow_repos:
            print(f"\n⚠️  SLOW REPOSITORIES (>100ms):")
            for repo_path, duration in sorted(slow_repos, key=lambda x: x[1], reverse=True):
                print(f"  {os.path.basename(repo_path)}: {duration:.3f}s")
        else:
            print("\n✅ All repositories loaded quickly (<100ms)")
            
    def profile_branch_filtering(self):
        """Profile branch filtering performance"""
        if not self.branch_filter_user and not self.branch_filter_message:
            messagebox.showwarning("No Filters", "Please set branch filters first")
            return
            
        print(f"\n📊 PROFILING BRANCH FILTERING")
        print("=" * 60)
        
        # Test the current filtering operation
        self.update_repository_tree_with_branch_filter()
    
    def select_folder(self):
        """Open folder selection dialog"""
        folder = filedialog.askdirectory(title="Select folder to scan for Git repositories")
        if folder:
            self.selected_folder = folder
            self.folder_label.config(text=folder)
            self.scan_repositories()
    
    def rescan_folder(self):
        """Rescan the selected folder"""
        if self.selected_folder:
            self.scan_repositories()
        else:
            messagebox.showwarning("Warning", "Please select a folder first")
    
    def scan_repositories(self):
        """Scan the selected folder for Git repositories"""
        if not self.selected_folder:
            return
        
        self.root.config(cursor="wait")
        self.root.update()
        
        # Run scanning in a separate thread to prevent UI freezing
        threading.Thread(target=self._scan_repositories_thread, daemon=True).start()
    
    def _scan_repositories_thread(self):
        """Thread function for scanning repositories"""
        try:
            self.repositories.clear()
            self.folder_tree.clear()
            
            repo_count = 0
            skipped_dirs = {'.svn', '.hg', 'node_modules', '__pycache__', '.venv', 'venv'}
            
            # Walk through directory tree with optimizations
            for root, dirs, files in os.walk(self.selected_folder, topdown=True):
                # Skip common non-repository directories for performance (but keep .git)
                dirs[:] = [d for d in dirs if d not in skipped_dirs]
                
                # Check for regular git repository
                if '.git' in dirs:
                    # This is a regular git repository
                    repo = GitRepository(root, is_submodule=False)
                    # Load all branches immediately during scan
                    repo.load_branches()
                    self.repositories[root] = repo
                    repo_count += 1
                    
                    # Continue scanning subdirectories to find submodules
                    # but exclude .git directory itself
                    dirs[:] = [d for d in dirs if d != '.git']
                    
                    # Update UI every 5 repositories for progress feedback
                    if repo_count % 5 == 0:
                        self.root.after(0, lambda c=repo_count: self._update_scan_progress(c))
                    
                # Check for git submodule (has .git file instead of .git folder)
                elif '.git' in files:
                    git_file_path = os.path.join(root, '.git')
                    if os.path.isfile(git_file_path):
                        # This is a git submodule
                        repo = GitRepository(root, is_submodule=True)
                        # Load all branches immediately during scan
                        repo.load_branches()
                        self.repositories[root] = repo
                        repo_count += 1
                        
                        # Continue scanning subdirectories in case there are nested submodules
                        
                        # Update UI every 5 repositories for progress feedback
                        if repo_count % 5 == 0:
                            self.root.after(0, lambda c=repo_count: self._update_scan_progress(c))
            
            # Update UI in main thread
            self.root.after(0, self._update_ui_after_scan)
        except Exception as e:
            self.root.after(0, lambda: messagebox.showerror("Error", f"Error scanning repositories: {e}"))
            
            # Update UI in main thread
            self.root.after(0, self._update_ui_after_scan)
        except Exception as e:
            self.root.after(0, lambda: messagebox.showerror("Error", f"Error scanning repositories: {e}"))
    
    def _update_scan_progress(self, count: int):
        """Update scan progress in the UI"""
        # Update the folder label to show progress
        if hasattr(self, 'folder_label'):
            self.folder_label.config(text=f"Scanning... Found {count} repositories (loading branches...)")
    
    def _update_ui_after_scan(self):
        """Update UI after scanning is complete"""
        self.root.config(cursor="")
        if hasattr(self, 'folder_label'):
            self.folder_label.config(text=f"{self.selected_folder} ({len(self.repositories)} repositories)")
        self.update_repository_tree()
        self.save_settings()
    
    def update_repository_tree(self):
        """Update the repository tree view"""
        self.repo_tree.delete(*self.repo_tree.get_children())
        
        if not self.repositories:
            return
        
        # Build folder hierarchy
        folder_structure = self._build_folder_structure()
        
        # Add items to tree
        self._add_tree_items("", folder_structure, 0)
    
    @benchmark
    def _build_folder_structure(self) -> Dict:
        """Build a unified hierarchical structure of folders and repositories"""
        structure = {"folders": {}, "repositories": [], "is_repository": False, "repo_obj": None}
        
        # First, collect all repositories and their paths, including submodules
        valid_repos = {}
        for repo_path, repo in self.repositories.items():
            # Load submodules for this repository if not already loaded
            if not repo.is_submodule and not repo._submodules_loaded:
                repo.load_submodules()
            
            # Apply repository filter
            if self.repo_filter_regex:
                try:
                    if not re.search(self.repo_filter_regex, repo.name, re.IGNORECASE):
                        # Also check submodules for filtering
                        has_matching_submodule = False
                        if hasattr(repo, 'submodules'):
                            for submodule in repo.submodules:
                                if re.search(self.repo_filter_regex, submodule.name, re.IGNORECASE):
                                    has_matching_submodule = True
                                    break
                        
                        if not has_matching_submodule:
                            continue
                except re.error:
                    continue
            
            valid_repos[repo_path] = repo
            
            # Also add submodules to valid_repos if they exist
            if hasattr(repo, 'submodules'):
                for submodule in repo.submodules:
                    # Apply filter to submodule if needed
                    if self.repo_filter_regex:
                        try:
                            if not re.search(self.repo_filter_regex, submodule.name, re.IGNORECASE):
                                continue
                        except re.error:
                            continue
                    valid_repos[submodule.path] = submodule
        
        # Sort repositories by path length to handle parents before children
        sorted_repos = sorted(valid_repos.items(), key=lambda x: len(x[0].split(os.sep)))
        
        # Build the unified structure
        for repo_path, repo in sorted_repos:
            rel_path = os.path.relpath(repo_path, self.selected_folder)
            
            # Check if this repository is a direct child of the selected folder
            if os.path.dirname(repo_path) == self.selected_folder:
                # This repository is directly in the selected folder
                # Create it as a folder that is also a repository
                folder_name = os.path.basename(repo_path)
                if folder_name not in structure["folders"]:
                    structure["folders"][folder_name] = {
                        "folders": {}, 
                        "repositories": [], 
                        "is_repository": True, 
                        "repo_obj": repo
                    }
                else:
                    # Update existing folder to be a repository
                    structure["folders"][folder_name]["is_repository"] = True
                    structure["folders"][folder_name]["repo_obj"] = repo
                
                structure["folders"][folder_name]["repositories"].append(repo)
            else:
                # This repository is nested deeper
                path_parts = rel_path.split(os.sep)
                
                # Navigate through the folder structure, creating folders as needed
                current = structure
                for i, part in enumerate(path_parts):
                    if part not in current["folders"]:
                        current["folders"][part] = {
                            "folders": {}, 
                            "repositories": [], 
                            "is_repository": False, 
                            "repo_obj": None
                        }
                    
                    # If this is the last part, this folder represents the repository
                    if i == len(path_parts) - 1:
                        current["folders"][part]["repositories"].append(repo)
                        current["folders"][part]["is_repository"] = True
                        current["folders"][part]["repo_obj"] = repo
                    
                    current = current["folders"][part]
        
        # Filter out empty folders and return the root structure
        filtered = self._filter_empty_folders(structure)
        return filtered
    
    def _filter_empty_folders(self, structure: Dict) -> Dict:
        """Remove folders that don't contain repositories (directly or indirectly)"""
        filtered = {
            "folders": {}, 
            "repositories": [], 
            "is_repository": structure.get("is_repository", False),
            "repo_obj": structure.get("repo_obj", None)
        }
        
        # Keep repositories at this level
        if "repositories" in structure and structure["repositories"]:
            filtered["repositories"] = structure["repositories"]
        
        # Process folders
        if "folders" in structure:
            for name, content in structure["folders"].items():
                # Recursively filter the folder content
                filtered_content = self._filter_empty_folders(content)
                
                # Keep this folder if it has repositories, is a repository itself, or has non-empty subfolders
                if (filtered_content["repositories"] or 
                    filtered_content["is_repository"] or
                    filtered_content["folders"]):
                    filtered["folders"][name] = filtered_content
        
        return filtered
    
    def _add_tree_items(self, parent: str, structure: Dict, level: int):
        """Add items to the unified tree view"""
        # Collect all items (repositories and folders) and sort them by name
        all_items = []
        
        # Collect repositories at this level (root level repositories)
        if "repositories" in structure and structure["repositories"]:
            for repo in structure["repositories"]:
                if not structure.get("is_repository"):  # Only add if not handled as folder below
                    all_items.append(("repo", repo.name, repo))
        
        # Collect folders at this level (which may also be repositories)
        if "folders" in structure:
            for name, content in structure["folders"].items():
                all_items.append(("folder", name, content))
        
        # Sort all items by name (case-insensitive)
        all_items.sort(key=lambda x: x[1].lower())
        
        # Process sorted items
        for item_type, name, item_data in all_items:
            if item_type == "repo":
                # Handle repository
                self._add_repository_node(parent, item_data, level)
            else:
                # Handle folder (which may also be a repository)
                content = item_data
                if content.get("is_repository"):
                    # This folder is also a repository
                    repo = content.get("repo_obj")
                    if repo:
                        tag = f"repo_level_{level % len(self.level_colors)}"
                        if repo.is_submodule:
                            tag = "submodule"
                        
                        node_id = self.repo_tree.insert(parent, tk.END, text=name, 
                                                       values=(repo.path, "repository" if not repo.is_submodule else "submodule"),
                                                       tags=(tag,))
                        
                        # Add local and remote branch categories
                        local_id = self.repo_tree.insert(node_id, tk.END, text="local", 
                                                        values=(repo.path, "local"))
                        remote_id = self.repo_tree.insert(node_id, tk.END, text="remote", 
                                                         values=(repo.path, "remote"))
                        
                        # Recursively add subfolders/submodules
                        self._add_tree_items(node_id, content, level + 1)
                else:
                    # This is just a folder
                    folder_id = self.repo_tree.insert(parent, tk.END, text=name, 
                                                     values=("", "folder"),
                                                     tags=("folder",))
                    
                    # Recursively add folder contents
                    self._add_tree_items(folder_id, content, level + 1)
    
    def _add_repository_node(self, parent: str, repo, level: int):
        """Add a repository node to the tree"""
        tag = f"repo_level_{level % len(self.level_colors)}"
        if repo.is_submodule:
            tag = "submodule"
        
        repo_id = self.repo_tree.insert(parent, tk.END, text=repo.name, 
                                       values=(repo.path, "repository" if not repo.is_submodule else "submodule"),
                                       tags=(tag,))
        
        # Add local and remote branch categories
        local_id = self.repo_tree.insert(repo_id, tk.END, text="local", 
                                        values=(repo.path, "local"))
        remote_id = self.repo_tree.insert(repo_id, tk.END, text="remote", 
                                         values=(repo.path, "remote"))
    
    def on_tree_select(self, event):
        """Handle tree selection"""
        selection = self.repo_tree.selection()
        if not selection:
            self.current_commits = []
            self.current_branches = []
            self.current_branch_name = ""
            self.current_branch_label.config(text="No repository selected")
            self.update_branch_display()
            return
        
        item = selection[0]
        values = self.repo_tree.item(item, "values")
        
        if len(values) >= 2:
            repo_path = values[0]
            item_type = values[1]
            
            # Find the repository (could be main repo or submodule)
            repo = self.repositories.get(repo_path)
            # if not repo:
            #     # Might be a submodule - search in all repositories
            #     for main_repo in self.repositories.values():
            #         if not main_repo._submodules_loaded:
            #             main_repo.load_submodules()
                        
            #         if hasattr(main_repo, 'submodules'):
            #             for submodule in main_repo.submodules:
            #                 if submodule.path == repo_path:
            #                     repo = submodule
            #                     break
            #             if repo:
            #                 break
            
            if repo:
                repo_display_name = os.path.basename(repo_path)
                if repo.is_submodule:
                    repo_display_name += " (submodule)"
                
                if item_type == "repository" or item_type == "submodule":
                    # Repository root selected - show current branch commits
                    self.current_branch_name, self.current_commits = repo.get_current_branch_commits(20)
                    self.current_branches = []  # Clear branches when showing commits
                    
                    self.current_branch_label.config(text=f"Repository: {repo_display_name} | Current Branch: {self.current_branch_name}")
                    
                elif item_type == "local":
                    # Local branches selected - show branches
                    repo.load_branches_if_needed()
                    self.current_branches = repo.local_branches
                    self.current_commits = []  # Clear commits when showing branches
                    self.current_branch_name = ""
                    
                    self.current_branch_label.config(text=f"Repository: {repo_display_name} | Local Branches")
                    
                elif item_type == "remote":
                    # Remote branches selected - show branches  
                    repo.load_branches_if_needed()
                    self.current_branches = repo.remote_branches
                    self.current_commits = []  # Clear commits when showing branches
                    self.current_branch_name = ""
                    
                    self.current_branch_label.config(text=f"Repository: {repo_display_name} | Remote Branches")
                
                # Remember what we selected for change detection
                self._last_selected_repo = repo_path
                self._last_selected_type = item_type
                
                # Don't apply search filters when initially loading a repository
                # Just show all branches/commits unfiltered
                if self.current_commits:
                    self.filtered_commits = self.current_commits[:]
                    self._sort_filtered_commits()
                else:
                    self.apply_branch_filters()
                
                self.update_branch_display()
            else:
                # Repository not found, clear display
                self.current_commits = []
                self.current_branches = []
                self.current_branch_name = ""
                self.current_branch_label.config(text="Repository not found")
                self.update_branch_display()
        else:
            # Non-repository item selected, clear display
            self.current_commits = []
            self.current_branches = []
            self.current_branch_name = ""
            self.current_branch_label.config(text="No repository selected")
            self.update_branch_display()
    
    def on_tree_right_click(self, event):
        """Handle right-click on tree"""
        item = self.repo_tree.identify_row(event.y)
        if item:
            self.repo_tree.selection_set(item)
            values = self.repo_tree.item(item, "values")
            
            # Try to get the path for the selected item
            path = None
            if len(values) >= 1 and values[0]:
                path = values[0]
            elif len(values) >= 2 and values[1] == "folder":
                # For folder items without direct path, construct it from tree hierarchy
                path = self._construct_folder_path(item)
            
            if path and os.path.exists(path):
                item_type = values[1] if len(values) >= 2 else ""
                
                # For folders, show Windows explorer
                if item_type == "folder" or os.path.isdir(path):
                    self.show_windows_context_menu(path, event.x_root, event.y_root)
                else:
                    # For repositories, show our custom menu
                    self.context_menu.post(event.x_root, event.y_root)
            else:
                # Fallback to our simple menu
                self.context_menu.post(event.x_root, event.y_root)
    
    def _construct_folder_path(self, item):
        """Construct full folder path from tree hierarchy"""
        try:
            path_parts = []
            current_item = item
            
            while current_item:
                text = self.repo_tree.item(current_item, "text")
                if text:
                    path_parts.insert(0, text)
                current_item = self.repo_tree.parent(current_item)
            
            if path_parts:
                full_path = os.path.join(self.selected_folder, *path_parts)
                return full_path
        except Exception:
            pass
        
        return None
    
    def show_windows_context_menu(self, path, x, y):
        """Show native Windows context menu for a folder using Windows API"""
        try:
            import platform
            if platform.system() == "Windows":
                # Use Windows API to show the native context menu
                self._show_native_context_menu(path, x, y)
            else:
                # For non-Windows systems, fall back to our simple menu
                self.context_menu.post(x, y)
        except Exception as e:
            print(f"Error showing context menu: {e}")
            # Fallback to our simple menu
            self.context_menu.post(x, y)
    
    def _show_native_context_menu(self, path, x, y):
        """Show native Windows context menu using win32com.shell"""
        try:
            
            from win32com.shell import shell, shellcon
            import win32gui
            import win32con
            
            # Normalize and validate the path
            path = os.path.abspath(path)
            if not os.path.exists(path):
                raise Exception(f"Path does not exist: {path}")
            
            # Convert path to Windows format with proper separators
            path = path.replace('/', '\\')
            parent_folder = os.path.dirname(path)
            item_name = os.path.basename(path)
            
            # Get desktop folder interface
            desktop = shell.SHGetDesktopFolder()
            
            # Parse the parent folder path to get PIDL
            # Use proper Windows path format
            try:
                pidl = desktop.ParseDisplayName(0, None, parent_folder)[1]
            except Exception as e:
                # If parsing fails, try with different path formats
                try:
                    # Try with UNC format if it's a network path
                    if parent_folder.startswith('\\\\'):
                        pidl = desktop.ParseDisplayName(0, None, parent_folder)[1]
                    else:
                        # Try with drive letter format
                        if not parent_folder.endswith('\\') and len(parent_folder) == 2 and parent_folder[1] == ':':
                            parent_folder += '\\'
                        pidl = desktop.ParseDisplayName(0, None, parent_folder)[1]
                except Exception as e2:
                    raise Exception(f"Failed to parse parent folder '{parent_folder}': {e2}")
            
            folder = desktop.BindToObject(pidl, None, shell.IID_IShellFolder)
            
            # Parse the item name to get item PIDL
            try:
                item_pidl = folder.ParseDisplayName(0, None, item_name)[1]
            except Exception as e:
                raise Exception(f"Failed to parse item name '{item_name}': {e}")
            
            # Get the context menu interface
            try:
                cm = folder.GetUIObjectOf(0, [item_pidl], shell.IID_IContextMenu, 0)[1]
            except Exception as e:
                raise Exception(f"Failed to get context menu interface: {e}")
            
            # Create the popup menu
            hmenu = win32gui.CreatePopupMenu()
            
            # Populate the menu
            cm.QueryContextMenu(hmenu, 0, 1, 0x7fff, shellcon.CMF_NORMAL)
            
            # Get our window handle
            hwnd = self.root.winfo_id()
            
            # Show the menu
            cmd = win32gui.TrackPopupMenu(
                hmenu,
                win32con.TPM_LEFTALIGN | win32con.TPM_RETURNCMD,
                x, y, 0, hwnd, None
            )
            win32gui.PostMessage(hwnd, win32con.WM_NULL, 0, 0)
            
            # Execute the command if one was selected
            if cmd:
                try:
                    # Use the correct tuple format for PyCMINVOKECOMMANDINFO (see pywin32 docs)
                    cm.InvokeCommand((
                        0,          # Mask (shellcon.CMIC_MASK_*, or 0)
                        hwnd,       # hwnd (window handle)
                        cmd - 1,    # Verb (integer menu item id)
                        None,       # Parameters
                        None,       # Directory
                        win32con.SW_SHOWNORMAL,  # Show
                        0,          # HotKey
                        None        # Icon
                    ))
                except Exception as e:
                    print(f"InvokeCommand with tuple failed: {e}")
                    try:
                        # Fallback: try with just the command as string
                        cm.InvokeCommand(str(cmd - 1))
                    except Exception as e2:
                        print(f"Final fallback failed: {e2}")
            
            # Clean up
            win32gui.DestroyMenu(hmenu)
            
        except ImportError:
            print("win32com not available, using fallback menu")
            self._show_fallback_context_menu(path, x, y)
        except Exception as e:
            print(f"Native context menu failed: {e}")
            self._show_fallback_context_menu(path, x, y)
    
    def _show_fallback_context_menu(self, path, x, y):
        """Fallback context menu using shell commands"""
        try:
            # Use Windows shell commands to trigger context menu actions
            import tkinter as tk
            
            # Create a native-looking context menu with Windows shell commands
            context_menu = tk.Menu(self.root, tearoff=0)
            
            # Add Windows Explorer actions that use native shell commands
            context_menu.add_command(label="Open", 
                                   command=lambda: self._shell_open(path))
            context_menu.add_command(label="Open in new window", 
                                   command=lambda: self._shell_open_new_window(path))
            context_menu.add_separator()
            
            context_menu.add_command(label="Copy", 
                                   command=lambda: self._shell_copy(path))
            context_menu.add_command(label="Cut", 
                                   command=lambda: self._shell_cut(path))
            context_menu.add_separator()
            
            context_menu.add_command(label="Properties", 
                                   command=lambda: self._shell_properties(path))
            context_menu.add_separator()
            
            context_menu.add_command(label="Copy path", 
                                   command=lambda: self._copy_path_to_clipboard(path))
            
            # Show the menu at the specified coordinates
            context_menu.post(x, y)
            
        except Exception as e:
            print(f"Fallback context menu failed: {e}")
            self._show_simple_context_menu(path, x, y)
        """Open folder using Windows shell"""
        try:
            import os
            os.startfile(path)
        except Exception as e:
            print(f"Failed to open: {e}")
    
    def _shell_open_new_window(self, path):
        """Open folder in new window"""
        try:
            import subprocess
            subprocess.Popen(['explorer', '/separate', path])
        except Exception as e:
            print(f"Failed to open new window: {e}")
    
    def _shell_copy(self, path):
        """Copy folder to clipboard"""
        try:
            import subprocess
            # Use PowerShell to copy folder to clipboard
            ps_command = f'Set-Clipboard -Path "{path}"'
            subprocess.run(['powershell', '-Command', ps_command], check=True)
            messagebox.showinfo("Copied", "Folder copied to clipboard")
        except Exception as e:
            print(f"Failed to copy folder: {e}")
    
    def _shell_cut(self, path):
        """Cut folder to clipboard"""
        try:
            import subprocess
            # Use PowerShell to cut folder to clipboard (copy with cut flag)
            ps_command = f'''
            Add-Type -AssemblyName System.Windows.Forms
            [System.Windows.Forms.Clipboard]::SetFileDropList([string[]]@("{path}"))
            '''
            subprocess.run(['powershell', '-Command', ps_command], check=True)
            messagebox.showinfo("Cut", "Folder cut to clipboard")
        except Exception as e:
            print(f"Failed to cut folder: {e}")
    
    def _shell_properties(self, path):
        """Show folder properties"""
        try:
            import ctypes
            result = ctypes.windll.shell32.ShellExecuteW(None, "properties", path, None, None, 1)
            if result <= 32:
                raise Exception(f"Properties failed with code {result}")
        except Exception as e:
            print(f"Failed to show properties: {e}")
            messagebox.showinfo("Properties", f"Path: {path}\nType: Folder")
    
    def _copy_path_to_clipboard(self, path):
        """Copy folder path to clipboard"""
        try:
            self.root.clipboard_clear()
            self.root.clipboard_append(path)
            self.root.update()
            messagebox.showinfo("Copied", f"Path copied to clipboard:\n{path}")
        except Exception as e:
            print(f"Failed to copy path: {e}")
    
    def _show_simple_context_menu(self, path, x, y):
        """Fallback simple context menu"""
        try:
            # Try Windows shell execute with properties verb first
            import ctypes
            from ctypes import wintypes
            
            # Use proper Windows API call
            result = ctypes.windll.shell32.ShellExecuteW(
                None,           # hwnd
                "properties",   # lpOperation
                path,          # lpFile
                None,          # lpParameters
                None,          # lpDirectory
                1              # nShowCmd (SW_SHOWNORMAL)
            )
            
            # ShellExecute returns a value > 32 on success
            if result <= 32:
                raise Exception(f"ShellExecute failed with code {result}")
                
        except Exception as e:
            print(f"Properties dialog failed: {e}")
            try:
                # Final fallback - open the folder in explorer
                if os.path.isdir(path):
                    subprocess.Popen(['explorer', path])
                else:
                    # If it's a file, open the containing folder
                    subprocess.Popen(['explorer', '/select,', path])
            except Exception as e2:
                print(f"Explorer fallback failed: {e2}")
                # Last resort - show a simple message
                messagebox.showinfo("Path", f"Path: {path}")
    
    def on_branch_header_right_click(self, event):
        """Handle right-click on branch tree headers"""
        # Check if click is in header area
        region = self.branch_tree.identify_region(event.x, event.y)
        if region == "heading":
            self.branch_header_menu.post(event.x_root, event.y_root)
    
    def on_column_visibility_change(self):
        """Handle column visibility changes from the header context menu"""
        # Force reset of the optimization cache so the display updates
        if hasattr(self, '_last_column_settings'):
            delattr(self, '_last_column_settings')
        
        # Update column visibility immediately
        self._update_column_visibility()
        
        # Also update the branch display to refresh the view
        self.update_branch_display()
    
    def open_in_explorer(self):
        """Open selected folder in file explorer"""
        selection = self.repo_tree.selection()
        if not selection:
            return
        
        item = selection[0]
        values = self.repo_tree.item(item, "values")
        
        if len(values) >= 1 and values[0]:
            path = values[0]
            try:
                os.startfile(path)  # Windows
            except AttributeError:
                subprocess.run(["open", path])  # macOS
            except Exception:
                subprocess.run(["xdg-open", path])  # Linux
    
    def on_repo_filter_change(self, event):
        """Handle repository filter change"""
        self.repo_filter_regex = self.repo_filter_entry.get()
        self.update_repository_tree()
    
    def on_branch_filter_change(self, event):
        """Handle commit filter change"""
        self.branch_filter_user = self.branch_user_entry.get()
        self.branch_filter_message = self.branch_message_entry.get()
        self._schedule_branch_filter_update()
    
    def on_filter_option_change(self):
        """Handle filter option checkbox changes"""
        self._schedule_branch_filter_update()
    
    def on_search_scope_change(self, event):
        """Handle search scope combo box change"""
        self._schedule_branch_filter_update()

    def _schedule_branch_filter_update(self):
        """Debounce expensive repository tree filtering to avoid rapid git operations."""
        # Cancel a pending scheduled run if present
        if self._filter_pending_id is not None:
            try:
                self.root.after_cancel(self._filter_pending_id)
            except Exception:
                pass
            self._filter_pending_id = None

        # Immediate update for in-panel commit/branch list (cheap)
        self.apply_branch_filters()
        self.update_branch_display()

        # Repository tree update only if filters active; otherwise reset tree immediately
        if not (self.branch_filter_user or self.branch_filter_message):
            self.update_repository_tree()
            return

        # Debounce the heavier repository filtering
        def _run():
            self._filter_pending_id = None
            self._during_filter = True
            try:
                self.update_repository_tree_with_branch_filter()
            finally:
                self._during_filter = False

        self._filter_pending_id = self.root.after(self._filter_debounce_ms, _run)
    
    @benchmark
    def update_repository_tree_with_branch_filter(self):
        """Update repository tree to show only repositories with branches matching the filter"""
        self.repo_tree.delete(*self.repo_tree.get_children())
        
        if not self.repositories:
            return
        
        print(f"🔍 Filtering {len(self.repositories)} repositories...")
        
        # Find repositories that have branches matching the current branch filters
        filtered_repos = {}
        repo_check_start = time.perf_counter()
        
        for i, (repo_path, repo) in enumerate(self.repositories.items()):
            repo_start = time.perf_counter()
            has_matching_branches = self._repo_has_matching_branches(repo)
            repo_end = time.perf_counter()
            
            #if (repo_end - repo_start) > 0.1:  # Only log slow repos (>100ms)
            print(f"  ⚠️  Repo {os.path.basename(repo_path)} took {repo_end - repo_start:.3f}s")
            
            if has_matching_branches:
                filtered_repos[repo_path] = repo
            
            # Also check submodules and include them in filtered_repos if they match
            if hasattr(repo, 'submodules'):
                for submodule in repo.submodules:
                    submodule_start = time.perf_counter()
                    submodule_has_matches = self._repo_has_matching_branches(submodule)
                    submodule_end = time.perf_counter()
                    
                    #if (submodule_end - submodule_start) > 0.1:  # Only log slow submodules
                    print(f"    ⚠️  Submodule {os.path.basename(submodule.path)} took {submodule_end - submodule_start:.3f}s")
                    
                    if submodule_has_matches:
                        filtered_repos[submodule.path] = submodule
        
        repo_check_end = time.perf_counter()
        print(f"📊 Repository filtering took {repo_check_end - repo_check_start:.3f}s, found {len(filtered_repos)} matching repos")
        
        # Build folder hierarchy with filtered repositories
        hierarchy_start = time.perf_counter()
        original_repos = self.repositories
        self.repositories = filtered_repos  # Temporarily replace
        folder_structure = self._build_folder_structure()
        self.repositories = original_repos  # Restore
        hierarchy_end = time.perf_counter()
        print(f"🏗️  Folder structure building took {hierarchy_end - hierarchy_start:.3f}s")
        
        # Add items to tree
        tree_start = time.perf_counter()
        self._add_tree_items_with_branch_filter("", folder_structure, 0)
        tree_end = time.perf_counter()
        print(f"🌳 Tree building took {tree_end - tree_start:.3f}s")
    
    #@benchmark
    def _repo_has_matching_branches(self, repo):
        """Check if a repository has branches matching the current filter"""
        # Ensure branches are loaded
        # repo.load_branches_if_needed()
        
        # Filter branches based on search scope
        branches_to_check = []
        scope = self.search_scope.get()
        if scope == "remote and local":
            branches_to_check = repo.local_branches + repo.remote_branches
        elif scope == "remote":
            branches_to_check = repo.remote_branches
        elif scope == "local":
            branches_to_check = repo.local_branches
        
        # Check branches for matches
        for branch in branches_to_check:
            matches_filter = True
            
            # Apply user filter
            if self.branch_filter_user:
                if not self._text_matches(branch.author, self.branch_filter_user):
                    matches_filter = False
            
            # Apply message filter
            if self.branch_filter_message and matches_filter:
                if not self._text_matches(branch.commit_message, self.branch_filter_message):
                    matches_filter = False
            
            if matches_filter:
                return True
        
        return False
    
    def _get_matching_branch_types(self, repo):
        """Get which branch types (local/remote) have matching branches for a repository"""
        # Avoid triggering branch reload while user is actively filtering to prevent expensive git calls
        if not self._during_filter:
            repo.load_branches_if_needed()
        
        # If no branch filters are active, show both categories if they have branches
        if not self.branch_filter_user and not self.branch_filter_message:
            has_local = len(repo.local_branches) > 0
            has_remote = len(repo.remote_branches) > 0
            return has_local, has_remote
        
        has_local_matches = False
        has_remote_matches = False
        
        scope = self.search_scope.get()
        
        # Check local branches if scope includes them
        if scope in ["remote and local", "local"]:
            for branch in repo.local_branches:
                matches_filter = True
                
                # Apply user filter
                if self.branch_filter_user:
                    if not self._text_matches(branch.author, self.branch_filter_user):
                        matches_filter = False
                
                # Apply message filter
                if self.branch_filter_message and matches_filter:
                    if not self._text_matches(branch.commit_message, self.branch_filter_message):
                        matches_filter = False
                
                if matches_filter:
                    has_local_matches = True
                    break
        
        # Check remote branches if scope includes them
        if scope in ["remote and local", "remote"]:
            for branch in repo.remote_branches:
                matches_filter = True
                
                # Apply user filter
                if self.branch_filter_user:
                    if not self._text_matches(branch.author, self.branch_filter_user):
                        matches_filter = False
                
                # Apply message filter
                if self.branch_filter_message and matches_filter:
                    if not self._text_matches(branch.commit_message, self.branch_filter_message):
                        matches_filter = False
                
                if matches_filter:
                    has_remote_matches = True
                    break
        
        return has_local_matches, has_remote_matches
    
    def _add_tree_items_with_branch_filter(self, parent: str, structure: Dict, level: int):
        """Add items to the unified tree view with branch filtering for local/remote categories"""
        # Collect all items (repositories and folders) and sort them by name
        all_items = []
        
        # Collect repositories at this level (root level repositories)
        if "repositories" in structure and structure["repositories"]:
            for repo in structure["repositories"]:
                if not structure.get("is_repository"):  # Only add if not handled as folder below
                    all_items.append(("repo", repo.name, repo))
        
        # Collect folders at this level (which may also be repositories)
        if "folders" in structure:
            for name, content in structure["folders"].items():
                all_items.append(("folder", name, content))
        
        # Sort all items by name (case-insensitive)
        all_items.sort(key=lambda x: x[1].lower())
        
        # Process sorted items
        for item_type, name, item_data in all_items:
            if item_type == "repo":
                # Handle repository
                self._add_repository_node_with_branch_filter(parent, item_data, level)
            else:
                # Handle folder (which may also be a repository)
                content = item_data
                if content.get("is_repository"):
                    # This folder is also a repository
                    repo = content.get("repo_obj")
                    if repo:
                        tag = f"repo_level_{level % len(self.level_colors)}"
                        if repo.is_submodule:
                            tag = "submodule"
                        
                        node_id = self.repo_tree.insert(parent, tk.END, text=name, 
                                                       values=(repo.path, "repository" if not repo.is_submodule else "submodule"),
                                                       tags=(tag,))
                        
                        # Add local and remote branch categories only if they have matching branches
                        has_local_matches, has_remote_matches = self._get_matching_branch_types(repo)
                        
                        if has_local_matches:
                            local_id = self.repo_tree.insert(node_id, tk.END, text="local", 
                                                            values=(repo.path, "local"))
                        
                        if has_remote_matches:
                            remote_id = self.repo_tree.insert(node_id, tk.END, text="remote", 
                                                             values=(repo.path, "remote"))
                        
                        # Recursively add subfolders/submodules
                        self._add_tree_items_with_branch_filter(node_id, content, level + 1)
                else:
                    # This is just a folder
                    folder_id = self.repo_tree.insert(parent, tk.END, text=name, 
                                                     values=("", "folder"),
                                                     tags=("folder",))
                    
                    # Recursively add folder contents
                    self._add_tree_items_with_branch_filter(folder_id, content, level + 1)
    
    def _add_repository_node_with_branch_filter(self, parent: str, repo, level: int):
        """Add a repository node to the tree with branch filtering for local/remote categories"""
        tag = f"repo_level_{level % len(self.level_colors)}"
        if repo.is_submodule:
            tag = "submodule"
        
        repo_id = self.repo_tree.insert(parent, tk.END, text=repo.name, 
                                       values=(repo.path, "repository" if not repo.is_submodule else "submodule"),
                                       tags=(tag,))
        
        # Add local and remote branch categories only if they have matching branches
        has_local_matches, has_remote_matches = self._get_matching_branch_types(repo)
        
        if has_local_matches:
            local_id = self.repo_tree.insert(repo_id, tk.END, text="local", 
                                            values=(repo.path, "local"))
        
        if has_remote_matches:
            remote_id = self.repo_tree.insert(repo_id, tk.END, text="remote", 
                                             values=(repo.path, "remote"))
    
    def apply_branch_filters(self):
        """Apply filters to current commits or branches"""
        if self.current_commits:
            # Filter commits
            self.filtered_commits = []
            
            for commit in self.current_commits:
                # Apply user filter
                if self.branch_filter_user:
                    if not self._text_matches(commit.author, self.branch_filter_user):
                        continue
                
                # Apply message filter
                if self.branch_filter_message:
                    if not self._text_matches(commit.message, self.branch_filter_message):
                        continue
                
                self.filtered_commits.append(commit)
            
            # Apply current sorting
            self._sort_filtered_commits()
            
        elif self.current_branches:
            # Filter branches based on search scope
            branches_to_filter = []
            scope = self.search_scope.get()
            if scope == "remote and local":
                branches_to_filter = self.current_branches
            elif scope == "remote":
                branches_to_filter = [b for b in self.current_branches if b.is_remote]
            elif scope == "local":
                branches_to_filter = [b for b in self.current_branches if not b.is_remote]
            
            # Apply text filters to the scoped branches
            self.filtered_branches = []
            
            for branch in branches_to_filter:
                # Apply user filter
                if self.branch_filter_user:
                    if not self._text_matches(branch.author, self.branch_filter_user):
                        continue
                
                # Apply message filter
                if self.branch_filter_message:
                    if not self._text_matches(branch.commit_message, self.branch_filter_message):
                        continue
                
                self.filtered_branches.append(branch)
            
            # Apply current sorting
            self._sort_filtered_branches()
        else:
            # Clear both if nothing selected
            self.filtered_commits = []
            self.filtered_branches = []
    
    def _text_matches(self, text, pattern):
        """Check if text matches the pattern according to current filter options"""
        if not text or not pattern:
            return not pattern  # If pattern is empty, match everything
        
        try:
            if self.use_regex.get():
                # Use regular expression matching
                flags = 0 if self.match_case.get() else re.IGNORECASE
                
                if self.match_whole_word.get():
                    # Add word boundaries for whole word matching
                    pattern = r'\b' + pattern + r'\b'
                
                return bool(re.search(pattern, text, flags))
            else:
                # Use simple text matching
                search_text = text if self.match_case.get() else text.lower()
                search_pattern = pattern if self.match_case.get() else pattern.lower()
                
                if self.match_whole_word.get():
                    # Split text into words and check for exact matches
                    words = re.findall(r'\b\w+\b', search_text)
                    return search_pattern in words
                else:
                    # Simple substring matching
                    return search_pattern in search_text
        except re.error:
            # If regex is invalid, fall back to simple substring matching
            search_text = text if self.match_case.get() else text.lower()
            search_pattern = pattern if self.match_case.get() else pattern.lower()
            return search_pattern in search_text
    
    def _sort_filtered_commits(self):
        """Sort filtered commits according to current sort settings"""        
        if self.sort_column == "name":
            self.filtered_commits.sort(key=lambda c: c.get_branch_names_display(), reverse=self.sort_reverse)
        elif self.sort_column == "sha":
            self.filtered_commits.sort(key=lambda c: c.commit_sha, reverse=self.sort_reverse)
        elif self.sort_column == "message":
            self.filtered_commits.sort(key=lambda c: c.message, reverse=self.sort_reverse)
        elif self.sort_column == "author":
            self.filtered_commits.sort(key=lambda c: c.author, reverse=self.sort_reverse)
        elif self.sort_column == "date":
            self.filtered_commits.sort(key=lambda c: c.date, reverse=self.sort_reverse)
    
    def _sort_filtered_branches(self):
        """Sort filtered branches according to current sort settings"""
        # Load commit info if needed for sorting
        if self.sort_column in ["message", "author", "date"]:
            for branch in self.filtered_branches:
                branch.load_commit_info_if_needed()
        
        if self.sort_column == "name":
            self.filtered_branches.sort(key=lambda b: b.name, reverse=self.sort_reverse)
        elif self.sort_column == "sha":
            self.filtered_branches.sort(key=lambda b: b.commit_sha, reverse=self.sort_reverse)
        elif self.sort_column == "message":
            self.filtered_branches.sort(key=lambda b: b.commit_message, reverse=self.sort_reverse)
        elif self.sort_column == "author":
            self.filtered_branches.sort(key=lambda b: b.author, reverse=self.sort_reverse)
        elif self.sort_column == "date":
            self.filtered_branches.sort(key=lambda b: b.date, reverse=self.sort_reverse)
    
    def sort_commits(self, column: str):
        """Sort commits or branches by the specified column"""
        if self.sort_column == column:
            self.sort_reverse = not self.sort_reverse
        else:
            self.sort_column = column
            self.sort_reverse = False
        
        if self.current_commits:
            self._sort_filtered_commits()
        elif self.current_branches:
            self._sort_filtered_branches()
            
        self.update_branch_display()
    
    def update_branch_display(self):
        """Update the display with dynamic column visibility - handles both commits and branches"""
        self.branch_tree.delete(*self.branch_tree.get_children())
        
        # Update column display based on visibility settings
        self._update_column_visibility()
        
        if self.current_commits:
            # Update column heading for commits
            self.branch_tree.heading("name", text="Branch Heads")
            
            # Display commits
            # Update optimization hash
            if hasattr(self, '_last_filtered_commits_hash'):
                current_hash = hashlib.md5(str([c.commit_sha for c in self.filtered_commits]).encode()).hexdigest()
                current_settings = (self.show_commit_sha.get(), self.show_commit_message.get(), 
                                  self.show_author.get(), self.show_date.get())
                    
                self._last_filtered_commits_hash = current_hash
                self._last_column_settings = current_settings
            else:
                self._last_filtered_commits_hash = hashlib.md5(str([c.commit_sha for c in self.filtered_commits]).encode()).hexdigest()
                self._last_column_settings = (self.show_commit_sha.get(), self.show_commit_message.get(), 
                                            self.show_author.get(), self.show_date.get())
            
            for commit in self.filtered_commits:
                values = []
                
                # SHA column (first)
                values.append(commit.commit_sha[:8] if commit.commit_sha else "")
                
                # Branch Heads column (shows which branches point to this commit)
                values.append(commit.get_branch_names_display())
                
                # Message column
                values.append(commit.message or "")
                
                # Author column
                values.append(commit.author or "")
                
                # Date column
                values.append(commit.date or "")
                
                # Insert the row
                self.branch_tree.insert("", tk.END, values=values)
                
        elif self.current_branches:
            # Update column heading for branches
            self.branch_tree.heading("name", text="Branch Name")
            
            # Display branches (existing logic)
            # Update optimization hash
            if hasattr(self, '_last_filtered_branches_hash'):
                current_hash = hashlib.md5(str([b.commit_sha for b in self.filtered_branches]).encode()).hexdigest()
                current_settings = (self.show_commit_sha.get(), self.show_commit_message.get(), 
                                  self.show_author.get(), self.show_date.get())
                
                # Only skip update if both hash AND settings are unchanged
                if (current_hash == self._last_filtered_branches_hash and 
                    hasattr(self, '_last_column_settings') and
                    current_settings == self._last_column_settings):
                    return  # No need to update
                    
                self._last_filtered_branches_hash = current_hash
                self._last_column_settings = current_settings
            else:
                self._last_filtered_branches_hash = hashlib.md5(str([b.commit_sha for b in self.filtered_branches]).encode()).hexdigest()
                self._last_column_settings = (self.show_commit_sha.get(), self.show_commit_message.get(), 
                                            self.show_author.get(), self.show_date.get())
            
            for branch in self.filtered_branches:
                values = []
                
                # SHA column (first)
                values.append(branch.commit_sha[:8] if branch.commit_sha else "")
                
                # Name column (branch name)
                values.append(branch.name or "")
                
                # Message column
                values.append(branch.commit_message or "")
                
                # Author column
                values.append(branch.author or "")
                
                # Date column
                values.append(branch.date or "")
                
                # Insert the row
                self.branch_tree.insert("", tk.END, values=values)
        else:
            # Clear display and update heading to default
            self.branch_tree.heading("name", text="Name")
    
    def _update_column_visibility(self):
        """Update column visibility based on settings"""
        # SHA column
        if self.show_commit_sha.get():
            self.branch_tree.column("sha", width=80, minwidth=50)
        else:
            self.branch_tree.column("sha", width=0, minwidth=0)
        
        # Name column (always visible) - now shows branch heads
        self.branch_tree.column("name", width=200, minwidth=100)
        
        # Message column
        if self.show_commit_message.get():
            self.branch_tree.column("message", width=300, minwidth=100)
        else:
            self.branch_tree.column("message", width=0, minwidth=0)
        
        # Author column
        if self.show_author.get():
            self.branch_tree.column("author", width=120, minwidth=80)
        else:
            self.branch_tree.column("author", width=0, minwidth=0)
        
        # Date column
        if self.show_date.get():
            self.branch_tree.column("date", width=100, minwidth=80)
        else:
            self.branch_tree.column("date", width=0, minwidth=0)
    
    def save_settings(self):
        """Save application settings and repository data to file"""
        settings = {
            "selected_folder": self.selected_folder,
            "repo_filter_regex": self.repo_filter_regex,
            "branch_filter_user": self.branch_filter_user,
            "branch_filter_message": self.branch_filter_message,
            "show_commit_sha": self.show_commit_sha.get(),
            "show_commit_message": self.show_commit_message.get(),
            "show_author": self.show_author.get(),
            "show_date": self.show_date.get(),
            "sort_column": self.sort_column,
            "sort_reverse": self.sort_reverse,
            "match_case": self.match_case.get(),
            "match_whole_word": self.match_whole_word.get(),
            "use_regex": self.use_regex.get(),
            "search_scope": self.search_scope.get(),
            "repositories": {path: repo.to_dict() for path, repo in self.repositories.items()}
        }
        
        try:
            # Only write if content actually changed to avoid triggering file watchers / restart loops
            existing = None
            try:
                if os.path.exists("app_data.json"):
                    with open("app_data.json", "r") as f_in:
                        existing = json.load(f_in)
            except Exception:
                existing = None  # Ignore read/parse errors and proceed to write

            if existing != settings:
                with open("app_data.json", "w") as f_out:
                    json.dump(settings, f_out, indent=2)
        except Exception as e:
            print(f"Error saving settings: {e}")
    
    def load_settings(self):
        """Load application settings from file"""
        try:
            if os.path.exists("app_data.json"):
                with open("app_data.json", "r") as f:
                    settings = json.load(f)
                
                self.selected_folder = settings.get("selected_folder", "")
                if self.selected_folder:
                    self.folder_label.config(text=self.selected_folder)
                
                self.repo_filter_regex = settings.get("repo_filter_regex", "")
                self.repo_filter_entry.insert(0, self.repo_filter_regex)
                
                self.branch_filter_user = settings.get("branch_filter_user", "")
                self.branch_user_entry.insert(0, self.branch_filter_user)
                
                self.branch_filter_message = settings.get("branch_filter_message", "")
                self.branch_message_entry.insert(0, self.branch_filter_message)
                
                self.show_commit_sha.set(settings.get("show_commit_sha", True))
                self.show_commit_message.set(settings.get("show_commit_message", True))
                self.show_author.set(settings.get("show_author", True))
                self.show_date.set(settings.get("show_date", True))
                
                self.sort_column = settings.get("sort_column", "date")
                self.sort_reverse = settings.get("sort_reverse", True)
                
                # Load new filter options
                self.match_case.set(settings.get("match_case", False))
                self.match_whole_word.set(settings.get("match_whole_word", False))
                self.use_regex.set(settings.get("use_regex", False))
                self.search_scope.set(settings.get("search_scope", "remote and local"))
                
                # Load repository data if available
                if "repositories" in settings and self.selected_folder and os.path.exists(self.selected_folder):
                    try:
                        repo_data = settings["repositories"]
                        for path, data in repo_data.items():
                            # Only load if the repository still exists
                            if os.path.exists(path):
                                repo = GitRepository.from_dict(data)
                                # Check if repository has changes since last save
                                if repo.has_changes():
                                    # Repository has changes, reload branches
                                    repo.load_branches()
                                self.repositories[path] = repo
                        
                        # Update UI with loaded data
                        self.folder_label.config(text=f"{self.selected_folder} ({len(self.repositories)} repositories)")
                        self.update_repository_tree()
                    except Exception as e:
                        print(f"Error loading repository data: {e}")
                        # Fall back to scanning if serialized data is corrupted
                        self.scan_repositories()
                elif self.selected_folder and os.path.exists(self.selected_folder):
                    # No serialized data available, do full scan
                    self.scan_repositories()
        except Exception as e:
            print(f"Error loading settings: {e}")
    
    def run(self):
        """Start the application"""
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
        self.root.mainloop()
    
    def on_closing(self):
        """Handle application closing"""
        self.save_settings()
        self.root.destroy()


if __name__ == "__main__":
    app = GitRepositoryManager()
    app.run()