# gui.py
import tkinter as tk
from tkinter import ttk  # Import themed widgets, including Notebook
from tkinter import scrolledtext, filedialog, messagebox, simpledialog
import logging
import os
import re  # Needed for validation in dialogs

# Import constant from the central location
from config_manager import DEFAULT_BACKUP_DIR


# --- Tooltip Class Definition ---
class Tooltip:
    """Simple tooltip implementation for Tkinter widgets."""

    def __init__(self, widget, text):
        """Initialize tooltip."""
        self.widget = widget
        self.text = text
        self.tooltip_window = None
        self.id = None
        self.x = 0.0  # Use float for position calculation if needed
        self.y = 0.0

    def showtip(self):
        """Display text in a tooltip window."""
        # Hide any existing tooltip first
        self.hidetip()
        # Avoid error if the parent widget has been destroyed
        if not self.widget.winfo_exists():
            return
        try:
            # Get widget position relative to screen
            # bbox("insert") gets coordinates relative to widget's top-left
            x_rel, y_rel, _, _ = self.widget.bbox("insert")
            x_root = self.widget.winfo_rootx()  # Widget's top-left corner X on screen
            y_root = self.widget.winfo_rooty()  # Widget's top-left corner Y on screen
            # Calculate tooltip position (below and right of cursor/widget)
            x_pos = x_root + x_rel + 25
            y_pos = y_root + y_rel + 25
        except tk.TclError:
            # Fallback if bbox fails (e.g., widget not visible)
            # Position below the center of the widget
            x_root = self.widget.winfo_rootx()
            y_root = self.widget.winfo_rooty()
            widget_width = self.widget.winfo_width()
            widget_height = self.widget.winfo_height()
            x_pos = x_root + widget_width // 2
            y_pos = y_root + widget_height + 5

        # Create the tooltip as a Toplevel window
        self.tooltip_window = tw = tk.Toplevel(self.widget)
        # Remove window decorations (border, title bar)
        tw.wm_overrideredirect(True)
        # Position the window on screen (ensure integer coordinates)
        tw.wm_geometry(f"+{int(x_pos)}+{int(y_pos)}")

        # Create the label inside the tooltip window
        label = tk.Label(
            tw,
            text=self.text,
            justify=tk.LEFT,
            background="#ffffe0",  # Light yellow background
            relief=tk.SOLID,  # Give it a border
            borderwidth=1,
            font=("tahoma", "8", "normal"),  # Small standard font
        )
        label.pack(ipadx=1)  # Small internal padding

    def hidetip(self):
        """Hide the tooltip window."""
        tw = self.tooltip_window
        # Reset the reference
        self.tooltip_window = None
        # Destroy the window if it exists
        if tw:
            try:
                # Check if window still exists before trying to destroy
                if tw.winfo_exists():
                    tw.destroy()
            except tk.TclError:
                # Handle race condition where window might be destroyed already
                pass


# --- End Tooltip Class ---


# --- Gitignore Editor Window Class ---
class GitignoreEditorWindow(tk.Toplevel):
    """Toplevel window for editing the .gitignore file."""

    def __init__(self, master, gitignore_path, logger):
        """Initialize the editor window."""
        super().__init__(master)
        self.gitignore_path = gitignore_path
        self.logger = logger
        self.original_content = ""  # Store initial content

        # --- Window Config ---
        self.title(f"Edit {os.path.basename(gitignore_path)}")
        self.geometry("600x450")
        self.minsize(400, 300)
        self.grab_set()  # Make modal
        self.transient(master)  # Stay on top of parent
        self.protocol("WM_DELETE_WINDOW", self._on_close)  # Handle X button

        # --- Widgets ---
        main_frame = ttk.Frame(self, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        main_frame.rowconfigure(0, weight=1)
        main_frame.columnconfigure(0, weight=1)

        self.text_editor = scrolledtext.ScrolledText(
            main_frame, wrap=tk.WORD, font=("Consolas", 10), undo=True
        )
        self.text_editor.grid(row=0, column=0, sticky="nsew", pady=(0, 10))

        button_frame = ttk.Frame(main_frame)
        button_frame.grid(row=1, column=0, sticky="ew")
        button_frame.columnconfigure(0, weight=1)  # Spacer left
        button_frame.columnconfigure(3, weight=1)  # Spacer right

        self.save_button = ttk.Button(
            button_frame, text="Save and Close", command=self._save_and_close
        )
        self.save_button.grid(row=0, column=2, padx=5)

        self.cancel_button = ttk.Button(
            button_frame, text="Cancel", command=self._on_close
        )
        self.cancel_button.grid(row=0, column=1, padx=5)

        # --- Load Content & Position ---
        self._load_file()
        self._center_window(master)
        self.text_editor.focus_set()

    def _center_window(self, parent):
        """Centers the editor window relative to its parent."""
        self.update_idletasks()  # Ensure window size is calculated
        parent_x = parent.winfo_rootx()
        parent_y = parent.winfo_rooty()
        parent_w = parent.winfo_width()
        parent_h = parent.winfo_height()
        win_w = self.winfo_width()
        win_h = self.winfo_height()
        x = parent_x + (parent_w // 2) - (win_w // 2)
        y = parent_y + (parent_h // 2) - (win_h // 2)
        # Basic screen boundary check
        sw = self.winfo_screenwidth()
        sh = self.winfo_screenheight()
        x = max(0, min(x, sw - win_w))
        y = max(0, min(y, sh - win_h))
        self.geometry(f"+{int(x)}+{int(y)}")

    def _load_file(self):
        """Loads the .gitignore content into the editor."""
        self.logger.info(f"Loading gitignore: {self.gitignore_path}")
        content = ""
        try:
            if os.path.exists(self.gitignore_path):
                with open(
                    self.gitignore_path, "r", encoding="utf-8", errors="replace"
                ) as f:
                    content = f.read()
                self.logger.debug(".gitignore loaded.")
            else:
                self.logger.info(".gitignore does not exist.")
            # Store original content and populate editor
            self.original_content = content
            self.text_editor.delete("1.0", tk.END)
            self.text_editor.insert(tk.END, self.original_content)
            self.text_editor.edit_reset()  # Reset undo stack
        except IOError as e:
            self.logger.error(f"Read error: {e}", exc_info=True)
            messagebox.showerror("Error", f"Read error:\n{e}", parent=self)
        except Exception as e:
            self.logger.exception(f"Load error: {e}")
            messagebox.showerror("Error", f"Load error:\n{e}", parent=self)

    def _save_file(self):
        """Saves the editor content back to the .gitignore file."""
        # Get content, normalize trailing newline
        current = self.text_editor.get("1.0", tk.END).rstrip()
        current += "\n" if current else ""
        # Normalize original for comparison
        original = self.original_content.rstrip()
        original += "\n" if original else ""

        if current == original:
            self.logger.info("No changes to save in .gitignore.")
            return True  # Indicate success (no action needed)

        self.logger.info(f"Saving changes to: {self.gitignore_path}")
        try:
            with open(self.gitignore_path, "w", encoding="utf-8", newline="\n") as f:
                f.write(current)
            self.logger.info(".gitignore saved successfully.")
            self.original_content = current  # Update baseline for change tracking
            self.text_editor.edit_reset()  # Reset undo stack after save
            return True  # Indicate success
        except IOError as e:
            self.logger.error(f"Write error: {e}", exc_info=True)
            messagebox.showerror("Error", f"Save error:\n{e}", parent=self)
            return False  # Indicate failure
        except Exception as e:
            self.logger.exception(f"Save error: {e}")
            messagebox.showerror("Error", f"Save error:\n{e}", parent=self)
            return False

    def _save_and_close(self):
        """Saves the file then closes the window if save succeeds."""
        if self._save_file():
            self.destroy()

    def _on_close(self):
        """Handles window close: checks for unsaved changes."""
        current = self.text_editor.get("1.0", tk.END).rstrip()
        current += "\n" if current else ""
        original = self.original_content.rstrip()
        original += "\n" if original else ""

        if current != original:
            # Ask user: Yes (Save), No (Discard), Cancel
            response = messagebox.askyesnocancel(
                "Unsaved Changes", "Save changes?", parent=self
            )
            if response is True:  # Yes -> Save and Close
                self._save_and_close()
            elif response is False:  # No -> Discard and Close
                self.logger.warning("Discarding .gitignore changes.")
                self.destroy()
            # Else (Cancel): Do nothing, window stays open
        else:
            # No changes, simply close
            self.destroy()


# --- End Gitignore Editor Window ---


# --- Create Tag Dialog ---
class CreateTagDialog(simpledialog.Dialog):
    """Dialog to get new tag name and message."""

    def __init__(self, parent, title="Create New Tag"):
        """Initialize the dialog."""
        self.tag_name_var = tk.StringVar()
        self.tag_message_var = tk.StringVar()
        self.result = None
        super().__init__(parent, title=title)

    def body(self, master):
        """Create dialog body with input fields."""
        name_label = ttk.Label(master, text="Tag Name:")
        name_label.grid(row=0, column=0, padx=5, pady=5, sticky="w")
        self.name_entry = ttk.Entry(master, textvariable=self.tag_name_var, width=40)
        self.name_entry.grid(row=0, column=1, padx=5, pady=5, sticky="ew")

        msg_label = ttk.Label(master, text="Tag Message:")
        msg_label.grid(row=1, column=0, padx=5, pady=5, sticky="w")
        self.message_entry = ttk.Entry(
            master, textvariable=self.tag_message_var, width=40
        )
        self.message_entry.grid(row=1, column=1, padx=5, pady=5, sticky="ew")

        master.columnconfigure(1, weight=1)  # Allow entries to expand
        return self.name_entry  # Initial focus

    def validate(self):
        """Validate the input fields."""
        name = self.tag_name_var.get().strip()
        message = self.tag_message_var.get().strip()
        if not name:
            messagebox.showwarning(
                "Input Error", "Tag name cannot be empty.", parent=self
            )
            return 0  # Validation failed
        if not message:
            messagebox.showwarning(
                "Input Error", "Tag message cannot be empty.", parent=self
            )
            return 0  # Validation failed

        # Validate tag name format using regex
        # Ensure 're' module is imported at the top of gui.py
        pattern = r"^(?![./]|.*([./]{2,}|[.]$|\.lock$))[^ \t\n\r\f\v~^:?*[\\]+(?<!\.)$"
        if not re.match(pattern, name):
            messagebox.showwarning(
                "Input Error", "Invalid tag name format.", parent=self
            )
            return 0  # Validation failed

        return 1  # Validation successful

    def apply(self):
        """Process the data if validation succeeded."""
        name = self.tag_name_var.get().strip()
        message = self.tag_message_var.get().strip()
        self.result = (name, message)


# --- End Create Tag Dialog ---


# --- Create Branch Dialog ---
class CreateBranchDialog(simpledialog.Dialog):
    """Dialog to get new branch name."""

    def __init__(self, parent, title="Create New Branch"):
        """Initialize the dialog."""
        self.branch_name_var = tk.StringVar()
        self.result = None
        super().__init__(parent, title=title)

    def body(self, master):
        """Create dialog body."""
        lbl = ttk.Label(master, text="New Branch Name:")
        lbl.grid(row=0, column=0, padx=5, pady=10, sticky="w")
        self.name_entry = ttk.Entry(master, textvariable=self.branch_name_var, width=40)
        self.name_entry.grid(row=0, column=1, padx=5, pady=10, sticky="ew")
        master.columnconfigure(1, weight=1)  # Allow entry to expand
        return self.name_entry  # Initial focus

    def validate(self):
        """Validate the branch name input."""
        name = self.branch_name_var.get().strip()
        if not name:
            messagebox.showwarning(
                "Input Error", "Branch name cannot be empty.", parent=self
            )
            return 0  # Validation failed

        # Git branch name validation (simplified but catches common issues)
        pattern = (
            r"^(?!\.| |.*[/.]\.|\.|.*\\|.*@\{|.*[/]$|.*\.\.)[^ \t\n\r\f\v~^:?*[\\]+$"
        )
        if not re.match(pattern, name) or name.lower() == "head":
            messagebox.showwarning(
                "Input Error", "Invalid branch name format.", parent=self
            )
            return 0  # Validation failed
        return 1  # Validation successful

    def apply(self):
        """Process the data if validation succeeded."""
        self.result = self.branch_name_var.get().strip()


# --- End Create Branch Dialog ---


class MainFrame(ttk.Frame):
    """The main frame using a ttk.Notebook for tabbed interface."""

    GREEN = "#90EE90"  # Light green color constant
    RED = "#F08080"  # Light coral color constant

    def __init__(
        self,
        master,
        load_profile_settings_cb,
        browse_folder_cb,
        update_svn_status_cb,
        prepare_svn_for_git_cb,
        create_git_bundle_cb,
        fetch_from_git_bundle_cb,
        config_manager_instance,
        profile_sections_list,
        add_profile_cb,
        remove_profile_cb,
        manual_backup_cb,
        open_gitignore_editor_cb,
        save_profile_cb,
        commit_changes_cb,  # Added commit
        refresh_tags_cb,
        create_tag_cb,
        checkout_tag_cb,
        refresh_history_cb,
        refresh_branches_cb,
        checkout_branch_cb,
        create_branch_cb,
    ):
        """Initializes the MainFrame with tabs."""
        super().__init__(master)
        self.master = master
        # Store callbacks from the controller
        self.load_profile_settings_callback = load_profile_settings_cb
        self.browse_folder_callback = browse_folder_cb
        self.update_svn_status_callback = update_svn_status_cb
        self.prepare_svn_for_git_callback = prepare_svn_for_git_cb
        self.create_git_bundle_callback = create_git_bundle_cb
        self.fetch_from_git_bundle_callback = fetch_from_git_bundle_cb
        self.manual_backup_callback = manual_backup_cb
        self.add_profile_callback = add_profile_cb
        self.remove_profile_callback = remove_profile_cb
        self.save_profile_callback = save_profile_cb
        self.open_gitignore_editor_callback = open_gitignore_editor_cb
        self.commit_changes_callback = commit_changes_cb  # Store commit callback
        self.refresh_tags_callback = refresh_tags_cb
        self.create_tag_callback = create_tag_cb
        self.checkout_tag_callback = checkout_tag_cb
        self.refresh_history_callback = refresh_history_cb
        self.refresh_branches_callback = refresh_branches_cb
        self.checkout_branch_callback = checkout_branch_cb
        self.create_branch_callback = create_branch_cb

        # Store instances and initial data
        self.config_manager = config_manager_instance
        self.initial_profile_sections = profile_sections_list

        # Configure style
        self.style = ttk.Style()
        self.style.theme_use("clam")  # Or 'alt', 'default', 'classic'

        # Configure main frame packing
        self.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=5, pady=5)

        # --- Tkinter Variables ---
        self.profile_var = tk.StringVar()
        self.autobackup_var = tk.BooleanVar()
        self.backup_dir_var = tk.StringVar()
        self.backup_exclude_extensions_var = tk.StringVar()
        self.autocommit_var = tk.BooleanVar()  # For autocommit before bundle
        # Commit message uses ScrolledText widget directly now

        # --- Create UI Elements ---
        # Profile selection frame (always visible)
        self._create_profile_frame()

        # Notebook for tabs
        self.notebook = ttk.Notebook(self, padding=(0, 5, 0, 0))
        self.notebook.pack(pady=(5, 0), padx=0, fill="both", expand=True)

        # Create frames for each tab (methods return the frame)
        self.repo_tab_frame = self._create_repo_tab()
        self.backup_tab_frame = self._create_backup_tab()
        self.commit_tab_frame = self._create_commit_tab()
        self.tags_tab_frame = self._create_tags_tab()
        self.branch_tab_frame = self._create_branch_tab()
        self.history_tab_frame = self._create_history_tab()

        # Add frames as tabs to the notebook
        self.notebook.add(self.repo_tab_frame, text=" Repository / Bundle ")
        self.notebook.add(self.backup_tab_frame, text=" Backup ")
        self.notebook.add(self.commit_tab_frame, text=" Commit ")
        self.notebook.add(self.tags_tab_frame, text=" Tags ")
        self.notebook.add(self.branch_tab_frame, text=" Branches ")
        self.notebook.add(self.history_tab_frame, text=" History ")

        # Log area (always visible below tabs)
        self._create_log_area()

        # --- Initial State Configuration ---
        self._initialize_profile_selection()
        self.toggle_backup_dir()  # Set initial state of backup dir widgets
        # Status updates are triggered by initial profile load

    def _create_profile_frame(self):
        """Creates the frame for profile configuration (above tabs)."""
        profile_outer_frame = ttk.Frame(self, padding=(0, 0, 0, 5))
        profile_outer_frame.pack(fill="x")
        frame = ttk.LabelFrame(profile_outer_frame, text="Profile", padding=(10, 5))
        frame.pack(fill="x")
        frame.columnconfigure(1, weight=1)  # Dropdown expands

        # Label
        lbl = ttk.Label(frame, text="Profile:")
        lbl.grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
        # Combobox
        self.profile_dropdown = ttk.Combobox(
            frame,
            textvariable=self.profile_var,
            state="readonly",
            width=35,
            values=self.initial_profile_sections,
        )
        self.profile_dropdown.grid(row=0, column=1, sticky=tk.EW, padx=5, pady=5)
        self.profile_dropdown.bind(
            "<<ComboboxSelected>>",
            lambda e: self.load_profile_settings_callback(self.profile_var.get()),
        )
        self.profile_var.trace_add(
            "write",
            lambda *a: self.load_profile_settings_callback(self.profile_var.get()),
        )
        # Buttons
        self.save_settings_button = ttk.Button(
            frame, text="Save Settings", command=self.save_profile_callback
        )
        self.save_settings_button.grid(
            row=0, column=2, sticky=tk.W, padx=(5, 2), pady=5
        )
        self.create_tooltip(self.save_settings_button, "Save settings.")
        self.add_profile_button = ttk.Button(
            frame, text="Add", width=5, command=self.add_profile_callback
        )
        self.add_profile_button.grid(row=0, column=3, sticky=tk.W, padx=(2, 0), pady=5)
        self.remove_profile_button = ttk.Button(
            frame, text="Remove", width=8, command=self.remove_profile_callback
        )
        self.remove_profile_button.grid(
            row=0, column=4, sticky=tk.W, padx=(2, 5), pady=5
        )

    def _create_repo_tab(self):
        """Creates the frame for the 'Repository / Bundle' tab."""
        frame = ttk.Frame(self.notebook, padding=(10, 10))
        frame.columnconfigure(1, weight=1)  # Allow entries to expand

        # --- Paths and Bundle Names ---
        paths_frame = ttk.LabelFrame(
            frame, text="Paths & Bundle Names", padding=(10, 5)
        )
        paths_frame.pack(pady=5, fill="x")
        paths_frame.columnconfigure(1, weight=1)  # Entry column expands
        col_label = 0
        col_entry = 1
        col_button = 2
        col_indicator = 3

        # SVN Path
        lbl_svn = ttk.Label(paths_frame, text="SVN Working Copy:")
        lbl_svn.grid(row=0, column=col_label, sticky=tk.W, padx=5, pady=3)
        self.svn_path_entry = ttk.Entry(paths_frame, width=60)
        self.svn_path_entry.grid(row=0, column=col_entry, sticky=tk.EW, padx=5, pady=3)
        self.svn_path_entry.bind(
            "<FocusOut>",
            lambda e: self.update_svn_status_callback(self.svn_path_entry.get()),
        )
        self.svn_path_entry.bind(
            "<Return>",
            lambda e: self.update_svn_status_callback(self.svn_path_entry.get()),
        )
        self.svn_path_browse_button = ttk.Button(
            paths_frame,
            text="Browse...",
            width=9,
            command=lambda: self.browse_folder_callback(self.svn_path_entry),
        )
        self.svn_path_browse_button.grid(
            row=0, column=col_button, sticky=tk.W, padx=(0, 5), pady=3
        )
        self.svn_status_indicator = tk.Label(
            paths_frame,
            text="",
            width=2,
            height=1,
            relief=tk.SUNKEN,
            background=self.RED,
            anchor=tk.CENTER,
        )
        self.svn_status_indicator.grid(
            row=0, column=col_indicator, sticky=tk.E, padx=(0, 5), pady=3
        )
        self.create_tooltip(self.svn_status_indicator, "Git repo status (Green=Ready)")

        # Bundle Target Dir
        lbl_usb = ttk.Label(paths_frame, text="Bundle Target Dir:")
        lbl_usb.grid(row=1, column=col_label, sticky=tk.W, padx=5, pady=3)
        self.usb_path_entry = ttk.Entry(paths_frame, width=60)
        self.usb_path_entry.grid(row=1, column=col_entry, sticky=tk.EW, padx=5, pady=3)
        self.usb_path_browse_button = ttk.Button(
            paths_frame,
            text="Browse...",
            width=9,
            command=lambda: self.browse_folder_callback(self.usb_path_entry),
        )
        self.usb_path_browse_button.grid(
            row=1, column=col_button, sticky=tk.W, padx=(0, 5), pady=3
        )

        # Create Bundle Name
        lbl_create_b = ttk.Label(paths_frame, text="Create Bundle Name:")
        lbl_create_b.grid(row=2, column=col_label, sticky=tk.W, padx=5, pady=3)
        self.bundle_name_entry = ttk.Entry(paths_frame, width=60)
        self.bundle_name_entry.grid(
            row=2, column=col_entry, columnspan=2, sticky=tk.EW, padx=5, pady=3
        )

        # Fetch Bundle Name
        lbl_fetch_b = ttk.Label(paths_frame, text="Fetch Bundle Name:")
        lbl_fetch_b.grid(row=3, column=col_label, sticky=tk.W, padx=5, pady=3)
        self.bundle_updated_name_entry = ttk.Entry(paths_frame, width=60)
        self.bundle_updated_name_entry.grid(
            row=3, column=col_entry, columnspan=2, sticky=tk.EW, padx=5, pady=3
        )

        # --- Actions Frame ---
        actions_frame = ttk.LabelFrame(frame, text="Actions", padding=(10, 5))
        actions_frame.pack(pady=10, fill="x")

        # Prepare Button
        self.prepare_svn_button = ttk.Button(
            actions_frame,
            text="Prepare SVN Repo",
            command=self.prepare_svn_for_git_callback,
            state=tk.DISABLED,
        )
        self.prepare_svn_button.pack(side=tk.LEFT, padx=(0, 5), pady=5)
        self.create_tooltip(self.prepare_svn_button, "Initialize Git & .gitignore")

        # Create Bundle Button
        self.create_bundle_button = ttk.Button(
            actions_frame,
            text="Create Bundle",
            command=self.create_git_bundle_callback,
            state=tk.DISABLED,
        )
        self.create_bundle_button.pack(side=tk.LEFT, padx=5, pady=5)
        self.create_tooltip(self.create_bundle_button, "Create Git bundle file")

        # Fetch Bundle Button
        self.fetch_bundle_button = ttk.Button(
            actions_frame,
            text="Fetch from Bundle",
            command=self.fetch_from_git_bundle_callback,
            state=tk.DISABLED,
        )
        self.fetch_bundle_button.pack(side=tk.LEFT, padx=5, pady=5)
        self.create_tooltip(self.fetch_bundle_button, "Fetch & merge from bundle")

        # Edit .gitignore Button (Moved here)
        self.edit_gitignore_button = ttk.Button(
            actions_frame,
            text="Edit .gitignore",
            width=12,
            command=self.open_gitignore_editor_callback,
            state=tk.DISABLED,
        )
        self.edit_gitignore_button.pack(side=tk.LEFT, padx=5, pady=5)
        self.create_tooltip(self.edit_gitignore_button, "Edit .gitignore file")

        return frame

    def _create_backup_tab(self):
        """Creates the frame for the 'Backup' tab."""
        frame = ttk.Frame(self.notebook, padding=(10, 10))
        frame.columnconfigure(1, weight=1)  # Entry expands

        # --- Configuration ---
        config_frame = ttk.LabelFrame(frame, text="Configuration", padding=(10, 5))
        config_frame.pack(pady=5, fill="x")
        config_frame.columnconfigure(1, weight=1)
        col_label = 0
        col_entry = 1
        col_button = 2

        self.autobackup_checkbox = ttk.Checkbutton(
            config_frame,
            text="Auto Backup before Create/Fetch",
            variable=self.autobackup_var,
            command=self.toggle_backup_dir,
        )
        self.autobackup_checkbox.grid(
            row=0, column=0, columnspan=3, sticky=tk.W, padx=5, pady=(5, 0)
        )
        backup_dir_label = ttk.Label(config_frame, text="Backup Directory:")
        backup_dir_label.grid(row=1, column=col_label, sticky=tk.W, padx=5, pady=5)
        self.backup_dir_entry = ttk.Entry(
            config_frame, textvariable=self.backup_dir_var, width=60, state=tk.DISABLED
        )
        self.backup_dir_entry.grid(
            row=1, column=col_entry, sticky=tk.EW, padx=5, pady=5
        )
        self.backup_dir_button = ttk.Button(
            config_frame,
            text="Browse...",
            width=9,
            command=self.browse_backup_dir,
            state=tk.DISABLED,
        )
        self.backup_dir_button.grid(
            row=1, column=col_button, sticky=tk.W, padx=(0, 5), pady=5
        )
        exclude_label = ttk.Label(config_frame, text="Exclude Extensions:")
        exclude_label.grid(row=2, column=col_label, sticky=tk.W, padx=5, pady=5)
        self.backup_exclude_entry = ttk.Entry(
            config_frame, textvariable=self.backup_exclude_extensions_var, width=60
        )
        self.backup_exclude_entry.grid(
            row=2, column=col_entry, columnspan=2, sticky=tk.EW, padx=5, pady=5
        )
        self.create_tooltip(
            self.backup_exclude_entry, "Comma-separated (e.g., .log,.tmp)"
        )

        # --- Manual Backup Action ---
        action_frame = ttk.LabelFrame(frame, text="Manual Backup", padding=(10, 5))
        action_frame.pack(pady=10, fill="x")
        self.manual_backup_button = ttk.Button(
            action_frame,
            text="Backup Now (ZIP)",
            command=self.manual_backup_callback,
            state=tk.DISABLED,
        )
        self.manual_backup_button.pack(side=tk.LEFT, padx=5, pady=5)
        self.create_tooltip(self.manual_backup_button, "Create a ZIP backup now.")

        return frame

    def _create_commit_tab(self):
        """Creates the frame for the 'Commit' tab."""
        frame = ttk.Frame(self.notebook, padding=(10, 10))
        frame.rowconfigure(2, weight=1)  # Text area expands
        frame.columnconfigure(0, weight=1)  # Text area expands

        # Row 0: Autocommit Checkbox (for Create Bundle action)
        self.autocommit_checkbox = ttk.Checkbutton(
            frame,
            text="Autocommit changes before 'Create Bundle' action",
            variable=self.autocommit_var,
            state=tk.DISABLED,
        )
        self.autocommit_checkbox.grid(
            row=0, column=0, columnspan=2, sticky="w", padx=5, pady=(0, 5)
        )
        self.create_tooltip(
            self.autocommit_checkbox,
            "If checked, uses message below to commit before Create Bundle.",
        )

        # Row 1: Commit Message Label
        commit_msg_label = ttk.Label(frame, text="Commit Message:")
        commit_msg_label.grid(row=1, column=0, columnspan=2, sticky="w", padx=5)

        # Row 2: Commit Message Text Area
        self.commit_message_text = scrolledtext.ScrolledText(
            frame,
            height=7,
            width=60,
            wrap=tk.WORD,  # Increased height
            font=("Segoe UI", 9),
            state=tk.DISABLED,  # Start disabled
        )
        self.commit_message_text.grid(
            row=2, column=0, columnspan=2, sticky="nsew", padx=5, pady=(0, 5)
        )
        self.create_tooltip(
            self.commit_message_text,
            "Enter commit message here for manual commit or autocommit.",
        )

        # Row 3: Commit Button
        self.commit_button = ttk.Button(
            frame,
            text="Commit Staged Changes",  # Clarified label
            command=self.commit_changes_callback,  # Link to controller method
            state=tk.DISABLED,
        )
        self.commit_button.grid(
            row=3, column=0, columnspan=2, sticky="e", padx=5, pady=5
        )
        self.create_tooltip(
            self.commit_button, "Stage ALL changes and commit with the message above."
        )

        return frame

    def _create_tags_tab(self):
        """Creates the frame for the 'Tags' tab."""
        frame = ttk.Frame(self.notebook, padding=(10, 10))
        frame.columnconfigure(0, weight=1)  # Listbox column expands
        frame.rowconfigure(1, weight=1)  # Listbox row expands

        # Row 0: Label
        lbl = ttk.Label(frame, text="Existing Tags (Newest First):")
        lbl.grid(row=0, column=0, sticky="w", padx=5, pady=(0, 2))

        # Row 1: Listbox + Scrollbar Frame
        list_frame = ttk.Frame(frame)
        list_frame.grid(row=1, column=0, sticky="nsew", padx=(5, 0), pady=(0, 5))
        list_frame.rowconfigure(0, weight=1)
        list_frame.columnconfigure(0, weight=1)

        self.tag_listbox = tk.Listbox(
            list_frame,
            height=10,
            exportselection=False,
            selectmode=tk.SINGLE,
            font=("Consolas", 9),
        )
        self.tag_listbox.grid(row=0, column=0, sticky="nsew")
        scrollbar = ttk.Scrollbar(
            list_frame, orient=tk.VERTICAL, command=self.tag_listbox.yview
        )
        scrollbar.grid(row=0, column=1, sticky="ns")
        self.tag_listbox.config(yscrollcommand=scrollbar.set)
        self.create_tooltip(self.tag_listbox, "Select tag to checkout.")

        # Row 1, Column 1: Vertical Button Frame
        button_frame = ttk.Frame(frame)
        button_frame.grid(row=1, column=1, sticky="ns", padx=(10, 5), pady=(0, 5))

        button_width = 18  # Uniform width

        self.refresh_tags_button = ttk.Button(
            button_frame,
            text="Refresh Tags",
            width=button_width,
            command=self.refresh_tags_callback,
            state=tk.DISABLED,
        )
        self.refresh_tags_button.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
        self.create_tooltip(self.refresh_tags_button, "Reload tag list.")

        self.create_tag_button = ttk.Button(
            button_frame,
            text="Create Tag...",
            width=button_width,
            command=self.create_tag_callback,
            state=tk.DISABLED,
        )
        self.create_tag_button.pack(side=tk.TOP, fill=tk.X, pady=5)
        self.create_tooltip(
            self.create_tag_button, "Commit (if needed with msg) & create tag."
        )

        self.checkout_tag_button = ttk.Button(
            button_frame,
            text="Checkout Selected Tag",
            width=button_width,
            command=self.checkout_tag_callback,
            state=tk.DISABLED,
        )
        self.checkout_tag_button.pack(side=tk.TOP, fill=tk.X, pady=(5, 0))
        self.create_tooltip(self.checkout_tag_button, "Switch to selected tag.")

        return frame

    def _create_branch_tab(self):
        """Creates the frame for the 'Branches' tab."""
        frame = ttk.Frame(self.notebook, padding=(10, 10))
        frame.columnconfigure(0, weight=1)  # Listbox expands
        frame.rowconfigure(1, weight=1)  # Listbox expands

        # Row 0: Label
        lbl = ttk.Label(frame, text="Local Branches (* Current):")
        lbl.grid(row=0, column=0, sticky="w", padx=5, pady=(0, 2))

        # Row 1: Listbox + Scrollbar Frame
        list_frame = ttk.Frame(frame)
        list_frame.grid(row=1, column=0, sticky="nsew", padx=(5, 0), pady=(0, 5))
        list_frame.rowconfigure(0, weight=1)
        list_frame.columnconfigure(0, weight=1)

        self.branch_listbox = tk.Listbox(
            list_frame, height=10, exportselection=False, selectmode=tk.SINGLE
        )
        self.branch_listbox.grid(row=0, column=0, sticky="nsew")
        scrollbar = ttk.Scrollbar(
            list_frame, orient=tk.VERTICAL, command=self.branch_listbox.yview
        )
        scrollbar.grid(row=0, column=1, sticky="ns")
        self.branch_listbox.config(yscrollcommand=scrollbar.set)
        self.create_tooltip(self.branch_listbox, "Select branch to checkout.")

        # Row 1, Column 1: Vertical Button Frame
        button_frame = ttk.Frame(frame)
        button_frame.grid(row=1, column=1, sticky="ns", padx=(10, 5), pady=(0, 5))

        button_width = 18  # Uniform width

        self.refresh_branches_button = ttk.Button(
            button_frame,
            text="Refresh Branches",
            width=button_width,
            command=self.refresh_branches_callback,
            state=tk.DISABLED,
        )
        self.refresh_branches_button.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
        self.create_tooltip(self.refresh_branches_button, "Reload branch list.")

        self.create_branch_button = ttk.Button(
            button_frame,
            text="Create Branch...",
            width=button_width,
            command=self.create_branch_callback,
            state=tk.DISABLED,
        )
        self.create_branch_button.pack(side=tk.TOP, fill=tk.X, pady=5)
        self.create_tooltip(self.create_branch_button, "Create a new local branch.")

        self.checkout_branch_button = ttk.Button(
            button_frame,
            text="Checkout Selected",
            width=button_width,  # Shortened text
            command=self.checkout_branch_callback,
            state=tk.DISABLED,
        )
        self.checkout_branch_button.pack(side=tk.TOP, fill=tk.X, pady=5)
        self.create_tooltip(self.checkout_branch_button, "Switch to selected branch.")

        # Placeholder for Delete Branch if added later
        # self.delete_branch_button = ttk.Button(...)
        # self.delete_branch_button.pack(...)

        return frame

    def _create_history_tab(self):
        """Creates the frame for the 'History' tab."""
        frame = ttk.Frame(self.notebook, padding=(10, 10))
        frame.rowconfigure(2, weight=1)  # Text area expands
        frame.columnconfigure(0, weight=1)  # Text area expands

        # --- Filters --- (Row 0)
        filter_frame = ttk.Frame(frame)
        filter_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
        filter_frame.columnconfigure(1, weight=1)  # Allow combobox to expand

        filter_label = ttk.Label(filter_frame, text="Filter by Branch:")
        filter_label.pack(side=tk.LEFT, padx=(0, 5))

        self.history_branch_filter_var = tk.StringVar()
        self.history_branch_filter_combo = ttk.Combobox(
            filter_frame,
            textvariable=self.history_branch_filter_var,
            state="readonly",
            width=30,
        )
        self.history_branch_filter_combo.pack(
            side=tk.LEFT, expand=True, fill=tk.X, padx=5
        )
        # Apply filter when selection changes
        self.history_branch_filter_combo.bind(
            "<<ComboboxSelected>>", lambda e: self.refresh_history_callback()
        )
        self.create_tooltip(
            self.history_branch_filter_combo,
            "Show history for selected branch (or all).",
        )

        self.refresh_history_button = ttk.Button(
            filter_frame,
            text="Refresh History",
            command=self.refresh_history_callback,
            state=tk.DISABLED,
        )
        self.refresh_history_button.pack(side=tk.LEFT, padx=5)
        self.create_tooltip(self.refresh_history_button, "Load commit history.")

        # --- History Display --- (Row 1, 2, 3)
        history_label = ttk.Label(frame, text="Recent Commits:")
        history_label.grid(row=1, column=0, sticky="w", padx=5, pady=(5, 0))

        self.history_text = scrolledtext.ScrolledText(
            frame,
            height=15,
            width=100,
            font=("Consolas", 9),
            wrap=tk.NONE,
            state=tk.DISABLED,
        )
        self.history_text.grid(row=2, column=0, sticky="nsew", padx=5, pady=(0, 5))

        history_xscroll = ttk.Scrollbar(
            frame, orient=tk.HORIZONTAL, command=self.history_text.xview
        )
        history_xscroll.grid(row=3, column=0, sticky="ew", padx=5)
        self.history_text.config(xscrollcommand=history_xscroll.set)

        return frame

    def _create_function_frame(self):
        """REMOVED - This frame is no longer used in the tabbed layout."""
        pass  # Return None or simply don't call this method

    def _create_log_area(self):
        """Creates the application log area at the bottom."""
        log_frame = ttk.Frame(self, padding=(0, 5, 0, 0))  # Parent is MainFrame
        log_frame.pack(
            side=tk.BOTTOM, fill=tk.BOTH, expand=True, padx=0, pady=(5, 0)
        )  # Pack below notebook

        log_label = ttk.Label(log_frame, text="Application Log:")
        log_label.pack(side=tk.TOP, anchor=tk.W, padx=5)

        self.log_text = scrolledtext.ScrolledText(
            log_frame,
            height=8,
            width=100,
            font=("Consolas", 9),
            wrap=tk.WORD,
            state=tk.DISABLED,
        )
        self.log_text.pack(
            side=tk.BOTTOM, fill=tk.BOTH, expand=True, padx=5, pady=(0, 5)
        )

    def _initialize_profile_selection(self):
        """Sets the initial value of the profile dropdown."""
        try:
            from config_manager import DEFAULT_PROFILE
        except ImportError:
            DEFAULT_PROFILE = "default"
        if DEFAULT_PROFILE in self.initial_profile_sections:
            self.profile_var.set(DEFAULT_PROFILE)
        elif self.initial_profile_sections:
            self.profile_var.set(self.initial_profile_sections[0])

    # --- GUI Update Methods ---
    def toggle_backup_dir(self):
        """Toggles state of backup directory widgets."""
        state = tk.NORMAL if self.autobackup_var.get() else tk.DISABLED
        if hasattr(self, "backup_dir_entry"):
            self.backup_dir_entry.config(state=state)
        if hasattr(self, "backup_dir_button"):
            self.backup_dir_button.config(state=state)

    def browse_backup_dir(self):
        """Opens directory dialog for backup path."""
        initial = self.backup_dir_var.get() or DEFAULT_BACKUP_DIR
        dirname = filedialog.askdirectory(
            initialdir=initial, title="Select Backup Dir", parent=self.master
        )
        if dirname:
            self.backup_dir_var.set(dirname)

    def update_svn_indicator(self, is_prepared):
        """Updates repo indicator color and Prepare button state."""
        color = self.GREEN if is_prepared else self.RED
        state = tk.DISABLED if is_prepared else tk.NORMAL
        tooltip = "Prepared" if is_prepared else "Not prepared"
        if hasattr(self, "svn_status_indicator"):
            self.svn_status_indicator.config(background=color)
            self.update_tooltip(self.svn_status_indicator, tooltip)
        if hasattr(self, "prepare_svn_button"):  # Prepare button is in Repo tab
            self.prepare_svn_button.config(state=state)

    def update_profile_dropdown(self, sections):
        """Updates profile dropdown list and selection."""
        if hasattr(self, "profile_dropdown"):
            current = self.profile_var.get()
            self.profile_dropdown["values"] = sections
            if sections:
                if current in sections:
                    self.profile_var.set(current)
                elif "default" in sections:
                    self.profile_var.set("default")
                else:
                    self.profile_var.set(sections[0])
            else:
                self.profile_var.set("")

    def update_tag_list(self, tags_data):
        """Updates tag listbox with (name, subject) tuples."""
        if not hasattr(self, "tag_listbox"):
            return
        try:
            self.tag_listbox.delete(0, tk.END)
            if tags_data:
                try:  # Reset color
                    if self.tag_listbox.cget("fg") == "grey":
                        self.tag_listbox.config(fg="SystemWindowText")
                except tk.TclError:
                    pass
                for name, subject in tags_data:
                    self.tag_listbox.insert(tk.END, f"{name}\t({subject})")
            else:
                self.tag_listbox.insert(tk.END, "(No tags found)")
                try:
                    self.tag_listbox.config(fg="grey")
                except tk.TclError:
                    pass
        except Exception as e:
            logging.error(f"Error tags: {e}", exc_info=True)

    def get_selected_tag(self):
        """Returns the name only of the selected tag."""
        if hasattr(self, "tag_listbox"):
            indices = self.tag_listbox.curselection()
            if indices:
                item = self.tag_listbox.get(indices[0])
                if item != "(No tags found)":
                    return item.split("\t", 1)[0].strip()
        return None

    def update_branch_list(self, branches, current_branch):
        """Updates branch listbox, highlighting current."""
        if not hasattr(self, "branch_listbox"):
            return
        try:
            self.branch_listbox.delete(0, tk.END)
            sel_index = -1
            if branches:
                for i, branch in enumerate(branches):
                    prefix = "* " if branch == current_branch else "  "
                    self.branch_listbox.insert(tk.END, f"{prefix}{branch}")
                    if branch == current_branch:
                        sel_index = i
            else:
                self.branch_listbox.insert(tk.END, "(No local branches)")
            # Select current branch if found
            if sel_index >= 0:
                self.branch_listbox.selection_set(sel_index)
                self.branch_listbox.see(sel_index)
        except Exception as e:
            logging.error(f"Error branches: {e}", exc_info=True)

    def get_selected_branch(self):
        """Returns the name only of the selected branch."""
        if hasattr(self, "branch_listbox"):
            indices = self.branch_listbox.curselection()
            if indices:
                item = self.branch_listbox.get(indices[0])
                if item != "(No local branches)":
                    return item.lstrip("* ").strip()
        return None

    def get_commit_message(self):
        """Gets commit message from ScrolledText widget."""
        if hasattr(self, "commit_message_text"):
            return self.commit_message_text.get("1.0", tk.END).strip()
        return ""

    def clear_commit_message(self):
        """Clears the commit message ScrolledText widget."""
        if hasattr(self, "commit_message_text"):
            # Check state before modifying - avoid error if disabled
            if self.commit_message_text.cget("state") == tk.NORMAL:
                self.commit_message_text.delete("1.0", tk.END)
            else:  # If disabled, enable, clear, disable
                self.commit_message_text.config(state=tk.NORMAL)
                self.commit_message_text.delete("1.0", tk.END)
                self.commit_message_text.config(state=tk.DISABLED)

    def update_history_display(self, log_lines):
        """Updates the commit history text area."""
        if not hasattr(self, "history_text"):
            return
        try:
            self.history_text.config(state=tk.NORMAL)
            self.history_text.delete("1.0", tk.END)
            if log_lines:
                self.history_text.insert(tk.END, "\n".join(log_lines))
            else:
                self.history_text.insert(tk.END, "(No history found)")
            self.history_text.config(state=tk.DISABLED)
            self.history_text.yview_moveto(0.0)  # Scroll top
        except Exception as e:
            logging.error(f"Error history: {e}", exc_info=True)

    def update_history_branch_filter(self, branches, current_branch=None):
        """Populates branch filter combobox in History tab."""
        if not hasattr(self, "history_branch_filter_combo"):
            return
        filter_options = ["-- All History --"] + branches
        self.history_branch_filter_combo["values"] = filter_options
        # Set default selection
        if current_branch and current_branch in branches:
            self.history_branch_filter_var.set(current_branch)
        else:
            self.history_branch_filter_var.set(filter_options[0])

    # --- Dialog Wrappers (Unchanged) ---
    def ask_new_profile_name(self):
        return simpledialog.askstring("Add Profile", "Enter name:", parent=self.master)

    def show_error(self, title, message):
        messagebox.showerror(title, message, parent=self.master)

    def show_info(self, title, message):
        messagebox.showinfo(title, message, parent=self.master)

    def show_warning(self, title, message):
        messagebox.showwarning(title, message, parent=self.master)

    def ask_yes_no(self, title, message):
        return messagebox.askyesno(title, message, parent=self.master)

    # --- Tooltip Helpers (Unchanged) ---
    def create_tooltip(self, widget, text):
        tt = Tooltip(widget, text)
        widget.bind("<Enter>", lambda e, t=tt: t.showtip(), add="+")
        widget.bind("<Leave>", lambda e, t=tt: t.hidetip(), add="+")
        widget.bind("<ButtonPress>", lambda e, t=tt: t.hidetip(), add="+")

    def update_tooltip(self, widget, text):
        widget.unbind("<Enter>")
        widget.unbind("<Leave>")
        widget.unbind("<ButtonPress>")
        self.create_tooltip(widget, text)