gitwig_core/

lib.rs

//! Filesystem + git repository inspection.
//!
//! This module owns both the "is this a git repo?" classification used by
//! the per-card indicator AND the richer detail collection used by the
//! Detail view. They share a single `collect_summary` helper so the same
//! libgit2 work doesn't run twice.
//!
//! The cheap `is_dir()` + `.git`-existence check still gates everything —
//! we only spin up libgit2 when both checks pass.

#![deny(unsafe_code)]
#![deny(unused_imports, unused_must_use, dead_code, unused_assignments)]
#![deny(clippy::all, clippy::perf)]
#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
#![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::panic))]

use std::path::{Path, PathBuf};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

use git2::{Repository, StatusOptions, StatusShow};

mod process;
pub use process::{
    detached_command, git_command, spawn_pipe_reader, ssh_command_val, summarize_stderr,
    tool_command,
};

// ── Card-level status ──────────────────────────────────────────────────────

/// Per-item filesystem classification carried alongside `config.items`.
/// `GitRepo`'s inner `Option` is `None` when `.git` exists but libgit2
/// couldn't open or read the repo — we know it's a repo, we just can't
/// summarize its state.
#[derive(Debug, Clone)]
pub enum ItemStatus {
    Loading,
    Missing,
    Directory,
    GitRepo(Option<RepoSummary>),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum RepoState {
    #[default]
    Clean,
    Merge,
    Revert,
    CherryPick,
    Bisect,
    Rebase,
    ApplyMailbox,
}

/// Compact summary used to draw the per-card indicator. Also embedded in
/// `RepoInfo` so the Detail view doesn't re-collect the same data.
#[derive(Debug, Default, Clone)]
pub struct RepoSummary {
    /// Current branch shorthand (e.g. `"main"`). `None` for detached HEAD
    /// or when the ref cannot be read.
    pub branch: Option<String>,
    pub staged: usize,
    pub modified: usize,
    pub untracked: usize,
    pub conflicted: usize,
    pub ahead: usize,
    pub behind: usize,
    pub state: RepoState,
    pub last_commit_time: Option<i64>,
}

impl RepoSummary {
    pub fn is_clean(&self) -> bool {
        self.staged + self.modified + self.untracked + self.conflicted == 0
    }
    pub fn is_synced(&self) -> bool {
        self.ahead + self.behind == 0
    }
    pub fn unchanged(&self) -> bool {
        self.is_clean() && self.is_synced()
    }
}

// ── Detail view ────────────────────────────────────────────────────────────

#[derive(Debug, Clone)]
pub enum ItemDetail {
    Missing { resolved: PathBuf },
    Directory { resolved: PathBuf },
    Repo { resolved: PathBuf, info: Box<RepoInfo> },
    Error { resolved: PathBuf, message: String },
}

#[derive(Debug, Clone, Default)]
pub struct BranchInfo {
    pub name: String,
    pub is_head: bool,
    pub short_sha: String,
    pub short_message: String,
}

#[derive(Debug, Clone, Default)]
pub struct FileRevision {
    pub commit_oid: String,
    pub author: String,
    pub date: String,
    pub when: String,
    pub summary: String,
}

#[derive(Debug, Clone, Default)]
pub struct StashInfo {
    pub index: usize,
    pub message: String,
    pub commit_id: String,
    pub files: Vec<FileEntry>,
}

#[derive(Debug, Clone, Default)]
pub struct CommitterStat {
    pub name: String,
    pub email: String,
    pub count: usize,
}

#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum TabData<T> {
    #[default]
    NotLoaded,
    Loading,
    Loaded(T),
    Error(String),
}

impl<T> TabData<T> {
    pub fn is_not_loaded(&self) -> bool {
        matches!(self, TabData::NotLoaded)
    }
    pub fn is_loading(&self) -> bool {
        matches!(self, TabData::Loading)
    }
    #[allow(dead_code)]
    pub fn is_loaded(&self) -> bool {
        matches!(self, TabData::Loaded(_))
    }
    pub fn as_ref(&self) -> Option<&T> {
        match self {
            TabData::Loaded(val) => Some(val),
            _ => None,
        }
    }
}

impl<T> TabData<Vec<T>> {
    pub fn len(&self) -> usize {
        self.as_ref().map(|v| v.len()).unwrap_or(0)
    }
    pub fn is_empty(&self) -> bool {
        self.as_ref().map(|v| v.is_empty()).unwrap_or(true)
    }
    pub fn first(&self) -> Option<&T> {
        self.as_ref().and_then(|v| v.first())
    }
    pub fn get(&self, index: usize) -> Option<&T> {
        self.as_ref().and_then(|v| v.get(index))
    }
    pub fn iter(&self) -> std::slice::Iter<'_, T> {
        match self {
            TabData::Loaded(v) => v.iter(),
            _ => [].iter(),
        }
    }
    pub fn as_slice(&self) -> &[T] {
        match self {
            TabData::Loaded(v) => v.as_slice(),
            _ => &[],
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct WorktreeInfo {
    pub name: String,
    pub path: PathBuf,
    pub branch: Option<String>,
    pub is_locked: bool,
    pub lock_reason: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SubmoduleInfo {
    pub name: String,
    pub path: PathBuf,
    pub url: String,
    pub commit_id: Option<String>,
    pub head_id: Option<String>,
    pub is_initialized: bool,
    pub is_dirty: bool,
}

impl SubmoduleInfo {
    /// Deleted from the index but still in HEAD, until the removal is committed.
    pub fn is_removal_staged(&self) -> bool {
        self.commit_id.is_none() && self.head_id.is_some()
    }

    /// Checked out, with a commit or files that differ from what the
    /// superproject records: what the Submodules tab labels `Modified`.
    pub fn is_modified(&self) -> bool {
        !self.is_removal_staged() && self.is_initialized && self.is_dirty
    }
}

#[derive(Debug, Clone)]
pub enum TabPayload {
    Files(Result<Vec<String>, String>),
    Graph(Result<Vec<GraphLine>, String>),
    Branches {
        local: Result<Vec<BranchInfo>, String>,
        remote: Result<Vec<BranchInfo>, String>,
    },
    Tags {
        local: Result<Vec<BranchInfo>, String>,
        remote: Result<Vec<BranchInfo>, String>,
    },
    Remotes(Result<Vec<RemoteInfo>, String>),
    Stashes(Result<Vec<StashInfo>, String>),
    Overview(Result<(Vec<CommitterStat>, bool), String>),
    Worktrees(Result<Vec<WorktreeInfo>, String>),
    Submodules(Result<Vec<SubmoduleInfo>, String>),
    Reflog(Result<Vec<ReflogEntry>, String>),
    /// A non-fatal message for the status bar, sent alongside a tab payload
    /// (for example: git could not run the signature program).
    Notice(String),
    ForgeIssues(Result<Vec<ForgeIssue>, String>),
    ForgePRs(Result<Vec<ForgePR>, String>),
    /// Line comments of PR `pr_number`. Loads can finish out of order, so the
    /// number says which PR a result belongs to.
    PRComments {
        pr_number: u32,
        result: Result<Vec<ForgePRComment>, String>,
    },
}

#[derive(Debug, Default, Clone)]
pub struct RepoInfo {
    pub branch: Option<String>,
    pub head: Option<HeadInfo>,
    pub remotes: TabData<Vec<RemoteInfo>>,
    /// Configured upstream branch (e.g. "origin/main") if HEAD tracks one.
    pub upstream: Option<String>,
    pub summary: RepoSummary,
    /// File-level changes, populated by `collect_info` for the Detail view.
    pub changes: WorktreeChanges,
    /// Recent commits in this repository.
    pub commits: Vec<CommitEntry>,
    /// Graph view lines for the repository.
    pub graph_lines: TabData<Vec<GraphLine>>,
    /// Local branches in the repository.
    pub local_branches: TabData<Vec<BranchInfo>>,
    /// Remote branches in the repository.
    pub remote_branches: TabData<Vec<BranchInfo>>,
    /// Local tags in the repository.
    pub local_tags: TabData<Vec<BranchInfo>>,
    /// Remote tags in the repository.
    pub remote_tags: TabData<Vec<BranchInfo>>,
    /// Whether remote tags have been loaded from the remote repository.
    pub remote_tags_loaded: bool,
    /// Whether a remote tag fetch has been attempted in this session.
    pub remote_tags_attempted: bool,
    /// Tracked files in the repository.
    pub files: TabData<Vec<String>>,
    /// Available stashes in the repository.
    pub stashes: TabData<Vec<StashInfo>>,
    /// Available worktrees in the repository.
    pub worktrees: TabData<Vec<WorktreeInfo>>,
    /// Configured submodules in the repository.
    pub submodules: TabData<Vec<SubmoduleInfo>>,
    /// Available reflog entries.
    pub reflog: TabData<Vec<ReflogEntry>>,
    pub forge_issues: TabData<Vec<ForgeIssue>>,
    pub forge_prs: TabData<Vec<ForgePR>>,
    /// Committer statistics.
    pub committer_stats: TabData<Vec<CommitterStat>>,
    /// Whether the committer statistics walk was capped by the limit.
    pub committer_stats_limit_reached: bool,
    /// Timestamps when each tab was loaded (index matches tab_idx)
    pub tab_loaded_at: [Option<std::time::Instant>; 12],
    /// Whether each tab is currently loading in the background (index matches tab_idx)
    pub tab_loading: [bool; 12],
    /// Files tracked by Git LFS in the index/working copy.
    pub lfs_files: std::collections::HashSet<String>,
    /// Whether git-lfs is installed in the system PATH.
    pub lfs_installed: bool,
    /// Storage size of the local LFS directory if LFS is used.
    pub lfs_storage_size: Option<u64>,
}

impl RepoInfo {
    /// Forgets the background tab loads that were in flight. Their results were
    /// meant for a detail view that has since closed and are dropped on arrival,
    /// so a tab restored still flagged as loading (or showing `Loading`) would
    /// never load again.
    pub fn reset_in_flight_loads(&mut self) {
        fn unstick<T>(data: &mut TabData<T>) {
            if data.is_loading() {
                *data = TabData::NotLoaded;
            }
        }
        self.tab_loading = [false; 12];
        unstick(&mut self.remotes);
        unstick(&mut self.graph_lines);
        unstick(&mut self.local_branches);
        unstick(&mut self.remote_branches);
        unstick(&mut self.local_tags);
        unstick(&mut self.remote_tags);
        unstick(&mut self.files);
        unstick(&mut self.stashes);
        unstick(&mut self.worktrees);
        unstick(&mut self.submodules);
        unstick(&mut self.reflog);
        unstick(&mut self.forge_issues);
        unstick(&mut self.forge_prs);
        unstick(&mut self.committer_stats);
    }
}

#[derive(Debug, Clone)]
pub struct HeadInfo {
    pub short_id: String,
    pub summary: String,
    pub author: String,
    pub when: String,
}

#[derive(Debug, Clone)]
pub struct ReflogEntry {
    pub index: usize,
    pub target_oid: String,
    pub selector: String,
    pub command: String,
    pub message: String,
    pub when: String,
    pub date: String,
}

#[derive(Debug, Clone)]
pub struct RemoteInfo {
    pub name: String,
    pub url: String,
    pub push_url: Option<String>,
    pub refspecs: Vec<String>,
}

#[derive(Debug, Clone)]
pub struct CommitEntry {
    /// Short 7-char display ID.
    pub id: String,
    /// Full 40-char hex OID — used for diff lookup.
    pub oid: String,
    pub author: String,
    pub when: String,
    pub date: String,
    pub summary: String,
    pub message: String,
    /// Local branch names and tags pointing at this commit.
    /// Tags are prefixed with `"tag:"`, remote branches with `"remote:"`.
    pub refs: Vec<String>,
    /// Files changed in this commit (diff against first parent, or empty tree).
    pub files: Vec<FileEntry>,
    /// GPG/SSH signature status.
    pub signature_status: String,
}

#[derive(Debug, Clone)]
pub struct GraphLine {
    pub graph: String,
    pub commit: Option<GraphCommit>,
}

#[derive(Debug, Clone)]
pub struct GraphCommit {
    pub oid: String,
    pub decoration: String,
    pub summary: String,
    pub author: String,
    pub date: String,
    /// GPG/SSH signature status.
    pub signature_status: String,
}

/// One changed file in the working tree or index.
#[derive(Debug, Clone)]
pub struct FileEntry {
    /// Path relative to the repository root.
    pub path: String,
    /// Short human-readable label: "N", "M", "D", "R", "T", "?", or "C".
    pub label: &'static str,
}

/// File-level working-tree state collected for the Detail view.
/// Split into four buckets so the UI can render them as separate sections.
#[derive(Debug, Default, Clone)]
pub struct WorktreeChanges {
    pub staged: Vec<FileEntry>,
    pub unstaged: Vec<FileEntry>,
    pub untracked: Vec<FileEntry>,
    pub conflicted: Vec<FileEntry>,
}

// ── Per-file diff ──────────────────────────────────────────────────────────

/// The type of a single line in a unified diff.
#[derive(Debug, Clone, PartialEq)]
pub enum DiffLineKind {
    /// `@@ ... @@` hunk header.
    Header,
    /// `+` added line.
    Added,
    /// `-` removed line.
    Removed,
    /// Unchanged context line.
    Context,
    /// Line in OURS section of a conflict.
    ConflictOurs,
    /// Line in THEIRS section of a conflict.
    ConflictTheirs,
    /// Conflict marker line (<<<<<<<, =======, >>>>>>>).
    ConflictSeparator,
}

/// One line of a unified diff, as rendered in the Diff panel.
#[derive(Debug, Clone)]
pub struct DiffLine {
    pub kind: DiffLineKind,
    /// Raw content (already includes the leading +/−/space prefix character).
    pub content: String,
    pub old_lineno: Option<u32>,
    pub new_lineno: Option<u32>,
    pub hunk_idx: Option<usize>,
}

/// Return the unified diff of `file_path` as it changed in `commit_oid`
/// (hex string) inside the repository at `repo_path`.
/// Returns an empty Vec on any error.
pub fn get_commit_file_diff(repo_path: &Path, commit_oid: &str, file_path: &str) -> Vec<DiffLine> {
    get_file_diff_inner(repo_path, commit_oid, file_path).unwrap_or_default()
}

/// Return the diff for `file_path` in the working tree.
///
/// - `staged = true`:  diff between HEAD and the index (what would be committed).
/// - `staged = false`: diff between the index and the working directory (unstaged changes).
///
/// Returns an empty Vec on any error.
pub fn get_worktree_file_diff(repo_path: &Path, file_path: &str, staged: bool) -> Vec<DiffLine> {
    get_worktree_diff_inner(repo_path, file_path, staged).unwrap_or_default()
}

/// Add `file_path` to the index (equivalent to `git add <file>`).
/// Returns a human-readable error string on failure.
pub fn stage_file(repo_path: &Path, file_path: &str) -> Result<(), String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut index = repo.index().map_err(|e| e.to_string())?;
    let full_path = repo_path.join(file_path);
    if full_path.exists() {
        index.add_path(Path::new(file_path)).map_err(|e| e.to_string())?;
    } else {
        index.remove_path(Path::new(file_path)).map_err(|e| e.to_string())?;
    }
    index.write().map_err(|e| e.to_string())?;
    Ok(())
}

/// Remove `file_path` from the index (equivalent to `git restore --staged <file>`).
/// When HEAD exists the index entry is reset to the HEAD tree value; for a brand-new
/// repo with no commits the entry is simply removed from the index.
/// Returns a human-readable error string on failure.
pub fn unstage_file(repo_path: &Path, file_path: &str) -> Result<(), String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    // Prefer reset_default (git reset HEAD -- <file>) when a HEAD commit exists.
    if let Some(commit) = repo.head().ok().and_then(|h| h.peel_to_commit().ok()) {
        repo.reset_default(Some(commit.as_object()), std::iter::once(file_path))
            .map_err(|e| e.to_string())?;
    } else {
        // New repo with no commits: just remove the entry from the index.
        let mut index = repo.index().map_err(|e| e.to_string())?;
        index.remove_path(Path::new(file_path)).map_err(|e| e.to_string())?;
        index.write().map_err(|e| e.to_string())?;
    }
    Ok(())
}

pub fn sanitize_text(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut chars = s.chars().peekable();
    while let Some(c) = chars.next() {
        if c == '\x1B' {
            // Escape character: let's skip the sequence
            if let Some(&'[') = chars.peek() {
                chars.next();
                for seq_c in chars.by_ref() {
                    // ANSI escape sequences end with letters (A-Z, a-z)
                    if seq_c.is_ascii_alphabetic() {
                        break;
                    }
                }
            } else {
                // Single ESC character or other VT100: skip it
                for seq_c in chars.by_ref() {
                    if seq_c == ' ' || seq_c.is_ascii_alphabetic() {
                        break;
                    }
                }
            }
        } else if (c < ' ' || c == '\x7F') && c != '\n' && c != '\r' && c != '\t' {
            // Replace non-printable control characters except \n, \r, \t
            result.push(' ');
        } else {
            result.push(c);
        }
    }
    result
}

pub fn safe_sha_slice(sha: &str, len: usize) -> &str {
    let mut end = len.min(sha.len());
    while end > 0 && !sha.is_char_boundary(end) {
        end -= 1;
    }
    &sha[..end]
}

/// How often the supervising thread checks whether the child has exited.
const GIT_TIMEOUT_POLL_INTERVAL: Duration = Duration::from_millis(50);

/// Runs `cmd` to completion, killing it if it exceeds `timeout`.
///
/// A remote that accepts the TCP connection but never replies would otherwise
/// leave the caller blocked forever inside `Command::output()`. Mirrors
/// `crate::git_cmd::run_git_with_timeout` in the `gitwig` binary crate, which
/// this crate cannot depend on. A zero timeout means "no limit".
fn run_git_with_timeout(
    mut cmd: std::process::Command,
    timeout: Duration,
) -> Result<std::process::Output, Box<dyn std::error::Error>> {
    if timeout.is_zero() {
        return Ok(cmd.output()?);
    }

    cmd.stdin(std::process::Stdio::null())
        .stdout(std::process::Stdio::piped())
        .stderr(std::process::Stdio::piped());

    let mut child = cmd.spawn()?;

    let mut out_pipe = child.stdout.take();
    let mut err_pipe = child.stderr.take();
    let out_reader = std::thread::spawn(move || {
        let mut buf = Vec::new();
        if let Some(p) = out_pipe.as_mut() {
            let _ = std::io::Read::read_to_end(p, &mut buf);
        }
        buf
    });
    let err_reader = std::thread::spawn(move || {
        let mut buf = Vec::new();
        if let Some(p) = err_pipe.as_mut() {
            let _ = std::io::Read::read_to_end(p, &mut buf);
        }
        buf
    });

    let started = Instant::now();
    let status = loop {
        match child.try_wait() {
            Ok(Some(status)) => break Some(status),
            Ok(None) => {
                if started.elapsed() >= timeout {
                    let _ = child.kill();
                    let _ = child.wait();
                    break None;
                }
                std::thread::sleep(GIT_TIMEOUT_POLL_INTERVAL);
            }
            Err(e) => {
                let _ = child.kill();
                let _ = child.wait();
                return Err(e.into());
            }
        }
    };

    let stdout = out_reader.join().unwrap_or_default();
    let stderr = err_reader.join().unwrap_or_default();

    match status {
        Some(status) => Ok(std::process::Output { status, stdout, stderr }),
        None => {
            Err(format!("git did not respond within {}s and was cancelled", timeout.as_secs())
                .into())
        }
    }
}

pub fn safe_ref(r: &str) -> Result<&str, String> {
    let trimmed = r.trim();
    if trimmed.starts_with('-') {
        return Err(format!("Invalid ref name: '{}' (ref names cannot start with '-')", r));
    }
    if trimmed.is_empty() {
        return Err("Ref name cannot be empty".to_string());
    }
    Ok(trimmed)
}

/// Stage all unstaged/untracked changes (equivalent to `git add -A`).
pub fn stage_all_changes(repo_path: &Path) -> Result<(), String> {
    let output = git_command()
        .arg("add")
        .arg("-A")
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if output.status.success() {
        Ok(())
    } else {
        Err(String::from_utf8_lossy(&output.stderr).trim().to_string())
    }
}

/// Unstage all staged changes (equivalent to `git reset`).
pub fn unstage_all_changes(repo_path: &Path) -> Result<(), String> {
    let output =
        git_command().arg("reset").current_dir(repo_path).output().map_err(|e| e.to_string())?;

    if output.status.success() {
        Ok(())
    } else {
        Err(String::from_utf8_lossy(&output.stderr).trim().to_string())
    }
}

/// Discard all staged, unstaged, and untracked changes in the repository.
pub fn discard_all_changes(repo_path: &Path) -> Result<(), String> {
    // 1. Unstage all first so everything is in the working tree
    let _ = git_command().arg("reset").current_dir(repo_path).output();

    // 2. Discard all tracked modifications
    let checkout_out = git_command()
        .arg("checkout")
        .arg("--")
        .arg(".")
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if !checkout_out.status.success() {
        return Err(String::from_utf8_lossy(&checkout_out.stderr).trim().to_string());
    }

    // 3. Clean all untracked files/folders
    let clean_out = git_command()
        .arg("clean")
        .arg("-fd")
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if !clean_out.status.success() {
        return Err(String::from_utf8_lossy(&clean_out.stderr).trim().to_string());
    }

    Ok(())
}

/// Stage a single hunk of unstaged changes (equivalent to `git apply --cached -`).
pub fn stage_hunk(repo_path: &Path, file_path: &str, hunk: &[DiffLine]) -> Result<(), String> {
    apply_hunk_patch(repo_path, file_path, hunk, false, true)
}

/// Unstage a single hunk of staged changes (equivalent to `git apply --cached --reverse -`).
pub fn unstage_hunk(repo_path: &Path, file_path: &str, hunk: &[DiffLine]) -> Result<(), String> {
    apply_hunk_patch(repo_path, file_path, hunk, true, true)
}

/// Discard a single hunk of unstaged changes in the working tree (equivalent to `git apply --reverse -`).
pub fn discard_hunk(repo_path: &Path, file_path: &str, hunk: &[DiffLine]) -> Result<(), String> {
    apply_hunk_patch(repo_path, file_path, hunk, true, false)
}

/// Stage a single line from the Unstaged diff.
pub fn stage_line(
    repo_path: &Path,
    file_path: &str,
    hunk: &[DiffLine],
    selected_line_idx: usize,
) -> Result<(), String> {
    apply_line_patch_inner(repo_path, file_path, hunk, selected_line_idx, false, false, true)
}

/// Unstage a single line from the Staged diff.
pub fn unstage_line(
    repo_path: &Path,
    file_path: &str,
    hunk: &[DiffLine],
    selected_line_idx: usize,
) -> Result<(), String> {
    apply_line_patch_inner(repo_path, file_path, hunk, selected_line_idx, true, true, true)
}

/// Discard a single line from the Unstaged diff in the working tree.
pub fn discard_line(
    repo_path: &Path,
    file_path: &str,
    hunk: &[DiffLine],
    selected_line_idx: usize,
) -> Result<(), String> {
    apply_line_patch_inner(repo_path, file_path, hunk, selected_line_idx, true, true, false)
}

fn parse_hunk_header(header: &str) -> Option<(usize, usize, usize, usize)> {
    if !header.starts_with("@@") {
        return None;
    }
    let parts: Vec<&str> = header.split("@@").collect();
    if parts.len() < 3 {
        return None;
    }
    let meta = parts[1].trim();
    let subparts: Vec<&str> = meta.split_whitespace().collect();
    if subparts.len() < 2 {
        return None;
    }

    let parse_part = |p: &str| -> (usize, usize) {
        let s = p.trim_start_matches(['-', '+']);
        let comps: Vec<&str> = s.split(',').collect();
        let start = comps[0].parse::<usize>().unwrap_or(0);
        let count = if comps.len() > 1 { comps[1].parse::<usize>().unwrap_or(1) } else { 1 };
        (start, count)
    };

    let (old_start, old_count) = parse_part(subparts[0]);
    let (new_start, new_count) = parse_part(subparts[1]);
    Some((old_start, old_count, new_start, new_count))
}

fn apply_line_patch_inner(
    repo_path: &Path,
    file_path: &str,
    hunk: &[DiffLine],
    selected_line_idx_in_hunk: usize,
    revert: bool,
    target_has_modification: bool,
    cached: bool,
) -> Result<(), String> {
    use std::io::Write;
    use std::process::Stdio;

    let path_check = std::path::Path::new(file_path);
    if path_check.is_absolute()
        || path_check.components().any(|c| c == std::path::Component::ParentDir)
    {
        return Err("Path escapes repository root".to_string());
    }

    if hunk.is_empty() {
        return Err("Empty hunk".to_string());
    }

    let selected_line = match hunk.get(selected_line_idx_in_hunk) {
        Some(line) => line,
        None => return Err("Invalid line index".to_string()),
    };

    if selected_line.kind != DiffLineKind::Added && selected_line.kind != DiffLineKind::Removed {
        return Err("Selected line is not a modification (must be + or -)".to_string());
    }

    let header_line = &hunk[0];
    let (old_start, _old_count, new_start, _new_count) =
        match parse_hunk_header(&header_line.content) {
            Some(coords) => coords,
            None => return Err(format!("Invalid hunk header: {}", header_line.content)),
        };

    let mut patch_lines = Vec::new();
    let mut new_old_count = 0;
    let mut new_new_count = 0;

    for (i, line) in hunk.iter().enumerate() {
        if i == 0 {
            continue;
        }

        if i == selected_line_idx_in_hunk {
            if revert {
                match line.kind {
                    DiffLineKind::Added => {
                        patch_lines.push(DiffLine {
                            kind: DiffLineKind::Removed,
                            content: line.content.clone(),
                            old_lineno: None,
                            new_lineno: None,
                            hunk_idx: None,
                        });
                        new_old_count += 1;
                    }
                    DiffLineKind::Removed => {
                        patch_lines.push(DiffLine {
                            kind: DiffLineKind::Added,
                            content: line.content.clone(),
                            old_lineno: None,
                            new_lineno: None,
                            hunk_idx: None,
                        });
                        new_new_count += 1;
                    }
                    _ => {}
                }
            } else {
                match line.kind {
                    DiffLineKind::Added => {
                        patch_lines.push(DiffLine {
                            kind: DiffLineKind::Added,
                            content: line.content.clone(),
                            old_lineno: None,
                            new_lineno: None,
                            hunk_idx: None,
                        });
                        new_new_count += 1;
                    }
                    DiffLineKind::Removed => {
                        patch_lines.push(DiffLine {
                            kind: DiffLineKind::Removed,
                            content: line.content.clone(),
                            old_lineno: None,
                            new_lineno: None,
                            hunk_idx: None,
                        });
                        new_old_count += 1;
                    }
                    _ => {}
                }
            }
        } else {
            match line.kind {
                DiffLineKind::Context => {
                    patch_lines.push(line.clone());
                    new_old_count += 1;
                    new_new_count += 1;
                }
                DiffLineKind::Added => {
                    if target_has_modification {
                        patch_lines.push(DiffLine {
                            kind: DiffLineKind::Context,
                            content: line.content.clone(),
                            old_lineno: None,
                            new_lineno: None,
                            hunk_idx: None,
                        });
                        new_old_count += 1;
                        new_new_count += 1;
                    } else {
                        // Omit
                    }
                }
                DiffLineKind::Removed => {
                    if target_has_modification {
                        // Omit
                    } else {
                        patch_lines.push(DiffLine {
                            kind: DiffLineKind::Context,
                            content: line.content.clone(),
                            old_lineno: None,
                            new_lineno: None,
                            hunk_idx: None,
                        });
                        new_old_count += 1;
                        new_new_count += 1;
                    }
                }
                _ => {}
            }
        }
    }

    let mut patch = String::new();
    patch.push_str(&format!("diff --git a/{} b/{}\n", file_path, file_path));
    patch.push_str(&format!("--- a/{}\n", file_path));
    patch.push_str(&format!("+++ b/{}\n", file_path));
    patch.push_str(&format!(
        "@@ -{},{} +{},{} @@\n",
        old_start, new_old_count, new_start, new_new_count
    ));

    for line in patch_lines {
        let prefix = match line.kind {
            DiffLineKind::Added => "+",
            DiffLineKind::Removed => "-",
            DiffLineKind::Context => " ",
            DiffLineKind::Header => "",
            _ => "",
        };
        patch.push_str(prefix);
        patch.push_str(&line.content);
        patch.push('\n');
    }

    let mut args = vec!["apply"];
    if cached {
        args.push("--cached");
    }
    args.push("-");

    let mut cmd = git_command();
    let mut child = cmd
        .args(&args)
        .current_dir(repo_path)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .map_err(|e| format!("Failed to spawn git apply: {}", e))?;

    if let Some(mut stdin) = child.stdin.take() {
        stdin
            .write_all(patch.as_bytes())
            .map_err(|e| format!("Failed to write patch to stdin: {}", e))?;
    }

    let output =
        child.wait_with_output().map_err(|e| format!("Failed to wait for git apply: {}", e))?;

    if !output.status.success() {
        let err_msg = String::from_utf8_lossy(&output.stderr).to_string();
        return Err(format!("git apply failed: {}", err_msg.trim()));
    }

    Ok(())
}

fn apply_hunk_patch(
    repo_path: &Path,
    file_path: &str,
    hunk: &[DiffLine],
    reverse: bool,
    cached: bool,
) -> Result<(), String> {
    use std::io::Write;
    use std::process::Stdio;

    let path_check = std::path::Path::new(file_path);
    if path_check.is_absolute()
        || path_check.components().any(|c| c == std::path::Component::ParentDir)
    {
        return Err("Path escapes repository root".to_string());
    }

    let mut patch = String::new();
    patch.push_str(&format!("diff --git a/{} b/{}\n", file_path, file_path));
    patch.push_str(&format!("--- a/{}\n", file_path));
    patch.push_str(&format!("+++ b/{}\n", file_path));
    for line in hunk {
        let prefix = match line.kind {
            DiffLineKind::Added => "+",
            DiffLineKind::Removed => "-",
            DiffLineKind::Context => " ",
            DiffLineKind::Header => "",
            _ => "",
        };
        patch.push_str(prefix);
        patch.push_str(&line.content);
        patch.push('\n');
    }

    let mut args = vec!["apply"];
    if cached {
        args.push("--cached");
    }
    if reverse {
        args.push("--reverse");
    }
    args.push("-");

    let mut cmd = git_command();
    let mut child = cmd
        .args(&args)
        .current_dir(repo_path)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .map_err(|e| format!("Failed to spawn git apply: {}", e))?;

    if let Some(mut stdin) = child.stdin.take() {
        stdin
            .write_all(patch.as_bytes())
            .map_err(|e| format!("Failed to write patch to stdin: {}", e))?;
    }

    let output =
        child.wait_with_output().map_err(|e| format!("Failed to wait for git apply: {}", e))?;

    if !output.status.success() {
        let err_msg = String::from_utf8_lossy(&output.stderr).to_string();
        return Err(format!("git apply failed: {}", err_msg.trim()));
    }

    Ok(())
}

/// Discards uncommitted changes in `file_path`.
/// - If the file is untracked, it is deleted from the filesystem.
/// - If the file is tracked and modified/deleted, it is restored from the index.
/// - If the file is staged, it is first unstaged (reset to HEAD) and then restored from index.
pub fn discard_file_changes(repo_path: &Path, file_path: &str, staged: bool) -> Result<(), String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;

    if staged {
        // First unstage it (reset to HEAD)
        unstage_file(repo_path, file_path)?;
    }

    // Now check if the file is untracked
    let is_untracked = if let Ok(status) = repo.status_file(Path::new(file_path)) {
        status.contains(git2::Status::WT_NEW)
    } else {
        false
    };

    if is_untracked {
        let full_path = repo_path.join(file_path);
        if full_path.exists() {
            if full_path.is_file() {
                std::fs::remove_file(&full_path).map_err(|e| e.to_string())?;
            } else if full_path.is_dir() {
                std::fs::remove_dir_all(&full_path).map_err(|e| e.to_string())?;
            }
        }
    } else {
        // Tracked file: checkout from index to working tree
        let mut checkout_opts = git2::build::CheckoutBuilder::new();
        checkout_opts.path(Path::new(file_path));
        checkout_opts.force();
        repo.checkout_index(None, Some(&mut checkout_opts)).map_err(|e| e.to_string())?;
    }

    Ok(())
}

/// Create a commit in the repository with the given message.
/// Returns a human-readable error string on failure.
pub fn commit_changes(repo_path: &Path, message: &str) -> Result<(), String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut index = repo.index().map_err(|e| e.to_string())?;
    let tree_id = index.write_tree().map_err(|e| e.to_string())?;
    let tree = repo.find_tree(tree_id).map_err(|e| e.to_string())?;

    let signature = repo
        .signature()
        .map_err(|e| format!("Failed to get signature. Check user.name/email config: {}", e))?;

    // Find parent commits
    let mut parents = Vec::new();
    let mut has_head = false;
    if let Ok(head) = repo.head() {
        if let Ok(parent_commit) = head.peel_to_commit() {
            has_head = true;
            // Check if there are changes staged compared to HEAD
            let parent_tree = parent_commit.tree().map_err(|e| e.to_string())?;
            if parent_tree.id() == tree_id {
                return Err("No staged changes to commit".to_string());
            }
            parents.push(parent_commit);
        }
    }

    if !has_head && index.is_empty() {
        return Err("No staged changes to commit (index is empty)".to_string());
    }

    let parent_refs: Vec<&git2::Commit> = parents.iter().collect();

    repo.commit(Some("HEAD"), &signature, &signature, message, &tree, &parent_refs)
        .map_err(|e| e.to_string())?;

    Ok(())
}

// ── Public entry points ────────────────────────────────────────────────────

/// Expand a leading `~` or `~/` in a user-supplied path to the user's home
/// directory. Returns the input unchanged if there is no home dir or no
/// tilde to expand.
pub fn expand_tilde(s: &str) -> PathBuf {
    if s == "~" {
        return dirs::home_dir().unwrap_or_else(|| PathBuf::from(s));
    }
    if let Some(stripped) = s.strip_prefix("~/")
        && let Some(home) = dirs::home_dir()
    {
        return home.join(stripped);
    }
    PathBuf::from(s)
}

/// Walk up from `start` and return the first directory containing a `.git`
/// entry, or `None` if there is no repository above it.
///
/// `.git` is matched as either a directory (an ordinary clone) or a file (a
/// linked worktree or a submodule, where it holds a `gitdir:` pointer), so a
/// worktree checkout reports its own root rather than the main one.
pub fn discover_repo_root(start: &Path) -> Option<PathBuf> {
    let mut dir = if start.is_dir() { Some(start) } else { start.parent() };
    while let Some(current) = dir {
        if current.join(".git").exists() {
            return Some(current.to_path_buf());
        }
        dir = current.parent();
    }
    None
}

/// Add a new git remote.
pub fn remote_add(repo_path: &std::path::Path, name: &str, url: &str) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    repo.remote(name, url)?;
    Ok(())
}

/// Delete an existing git remote.
pub fn remote_delete(repo_path: &std::path::Path, name: &str) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    repo.remote_delete(name)?;
    Ok(())
}

/// Classify `item` and produce a card-level summary. Used by the list view.
pub fn inspect_summary(item: &str) -> ItemStatus {
    let path = expand_tilde(item);
    if !path.is_dir() {
        return ItemStatus::Missing;
    }
    if !path.join(".git").exists() {
        return ItemStatus::Directory;
    }
    match Repository::open(&path) {
        Ok(repo) => ItemStatus::GitRepo(Some(collect_summary(&repo))),
        Err(_) => ItemStatus::GitRepo(None),
    }
}

/// Inspect `item` and produce the rich detail report shown on Enter.
pub fn inspect_detail(
    item: &str,
    commit_limit: usize,
    graph_max_commits: usize,
    enable_commit_signatures: bool,
) -> ItemDetail {
    let resolved = expand_tilde(item);
    if !resolved.is_dir() {
        return ItemDetail::Missing { resolved };
    }
    if !resolved.join(".git").exists() {
        return ItemDetail::Directory { resolved };
    }
    match collect_info(&resolved, commit_limit, graph_max_commits, enable_commit_signatures) {
        Ok(info) => ItemDetail::Repo { resolved, info: Box::new(info) },
        Err(e) => ItemDetail::Error { resolved, message: e.to_string() },
    }
}

fn collect_signatures(repo_path: &Path, limit: usize) -> std::collections::HashMap<String, String> {
    let mut sigs = std::collections::HashMap::new();
    let mut cmd = git_command();
    cmd.arg("log").arg("--all");

    if limit > 0 {
        cmd.arg(format!("-n{}", limit));
    }

    cmd.arg("--pretty=format:%H %G?").current_dir(repo_path);

    if let Ok(out) = cmd.output() {
        if out.status.success() {
            let stdout_str = String::from_utf8_lossy(&out.stdout);
            for line in stdout_str.lines() {
                let parts: Vec<&str> = line.split_whitespace().collect();
                if parts.len() == 2 {
                    sigs.insert(parts[0].to_string(), parts[1].to_string());
                } else if parts.len() == 1 {
                    sigs.insert(parts[0].to_string(), "N".to_string());
                }
            }
        }
    }
    sigs
}

#[derive(serde::Serialize, serde::Deserialize, Clone)]
struct CachedCommit {
    id: String,
    author: String,
    date: String,
    summary: String,
    message: String,
    time: i64,
}

fn hash_path(path: &Path) -> String {
    use std::collections::hash_map::DefaultHasher;
    use std::hash::{Hash, Hasher};
    let mut hasher = DefaultHasher::new();
    path.hash(&mut hasher);
    format!("{:x}", hasher.finish())
}

fn collect_commits(
    repo: &Repository,
    limit: usize,
    repo_path: &Path,
    enable_commit_signatures: bool,
) -> Result<Vec<CommitEntry>, git2::Error> {
    let mut walk = repo.revwalk()?;
    if walk.push_head().is_err() {
        return Ok(Vec::new());
    }
    walk.set_sorting(git2::Sort::TOPOLOGICAL | git2::Sort::TIME)?;

    let mut commits = Vec::new();
    let oids: Vec<Result<git2::Oid, git2::Error>> =
        if limit > 0 { walk.take(limit).collect() } else { walk.collect() };

    let sig_map = if enable_commit_signatures {
        collect_signatures(repo_path, limit)
    } else {
        std::collections::HashMap::new()
    };
    let ref_map = get_cached_ref_map(repo, repo_path);

    // Load commit cache
    let cache_dir = dirs::home_dir().map(|h| h.join(".gitwig/commit_cache"));
    if let Some(ref dir) = cache_dir {
        let _ = std::fs::create_dir_all(dir);
    }
    let hash = hash_path(repo_path);
    let cache_file = cache_dir.as_ref().map(|d| d.join(format!("v2_{}.json", hash)));
    let mut cache: std::collections::HashMap<String, CachedCommit> = cache_file
        .as_ref()
        .and_then(|f| std::fs::read_to_string(f).ok())
        .and_then(|s| serde_json::from_str(&s).ok())
        .unwrap_or_default();

    let mut cache_updated = false;

    for id in oids {
        let oid = id?;
        let oid_str = oid.to_string();
        let sig_status = sig_map.get(&oid_str).cloned().unwrap_or_else(|| "N".to_string());
        let refs = ref_map.get(&oid).cloned().unwrap_or_default();
        let files = Vec::new();

        if let Some(cached) = cache.get(&oid_str) {
            let when = format_relative_time(cached.time);
            commits.push(CommitEntry {
                id: cached.id.clone(),
                oid: oid_str,
                author: sanitize_text(&cached.author),
                when,
                date: cached.date.clone(),
                summary: sanitize_text(&cached.summary),
                message: sanitize_text(&cached.message),
                refs,
                files,
                signature_status: sig_status,
            });
        } else if let Ok(commit) = repo.find_commit(oid) {
            let short_id = format!("{:.7}", commit.id());
            let summary =
                sanitize_text(commit.summary().ok().flatten().unwrap_or("(no commit message)"));
            let author = commit.author();
            let author_name = author.name().unwrap_or("?");
            let author_email = author.email().unwrap_or("?");
            let author_str = sanitize_text(&format!("{} <{}>", author_name, author_email));
            let time_secs = commit.time().seconds();
            let when = format_relative_time(time_secs);
            let date = format_utc_date(time_secs);
            let message = sanitize_text(commit.message().unwrap_or("(no commit message)"));

            let cached = CachedCommit {
                id: short_id.clone(),
                author: author_str.clone(),
                date: date.clone(),
                summary: summary.clone(),
                message: message.clone(),
                time: time_secs,
            };
            cache.insert(oid_str.clone(), cached);
            cache_updated = true;

            commits.push(CommitEntry {
                id: short_id,
                oid: oid_str,
                author: author_str,
                when,
                date,
                summary,
                message,
                refs,
                files,
                signature_status: sig_status,
            });
        }
    }

    if cache_updated {
        if let Some(ref f) = cache_file {
            if let Ok(json) = serde_json::to_string(&cache) {
                let _ = std::fs::write(f, json);
            }
        }
    }

    Ok(commits)
}

pub fn get_file_history(repo_path: &Path, file_path: &str) -> Result<Vec<FileRevision>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut walk = repo.revwalk().map_err(|e| e.to_string())?;
    if walk.push_head().is_err() {
        return Ok(Vec::new());
    }
    walk.set_sorting(git2::Sort::TOPOLOGICAL | git2::Sort::TIME).map_err(|e| e.to_string())?;

    let mut revisions = Vec::new();

    for oid_res in walk {
        let oid = oid_res.map_err(|e| e.to_string())?;
        let commit = repo.find_commit(oid).map_err(|e| e.to_string())?;

        let commit_tree = commit.tree().map_err(|e| e.to_string())?;
        let mut modified = false;

        if commit.parent_count() > 0 {
            for i in 0..commit.parent_count() {
                if let Ok(parent) = commit.parent(i) {
                    if let Ok(parent_tree) = parent.tree() {
                        let mut diff_opts = git2::DiffOptions::new();
                        diff_opts.pathspec(file_path);
                        if let Ok(diff) = repo.diff_tree_to_tree(
                            Some(&parent_tree),
                            Some(&commit_tree),
                            Some(&mut diff_opts),
                        ) {
                            if diff.deltas().len() > 0 {
                                modified = true;
                                break;
                            }
                        }
                    }
                }
            }
        } else {
            let mut diff_opts = git2::DiffOptions::new();
            diff_opts.pathspec(file_path);
            if let Ok(diff) = repo.diff_tree_to_tree(None, Some(&commit_tree), Some(&mut diff_opts))
            {
                if diff.deltas().len() > 0 {
                    modified = true;
                }
            }
        }

        if modified {
            let author = commit.author();
            let author_name = author.name().unwrap_or("?");
            let author_email = author.email().unwrap_or("?");
            let author_str = sanitize_text(&format!("{} <{}>", author_name, author_email));
            let time_secs = commit.time().seconds();
            let when = format_relative_time(time_secs);
            let date = format_utc_date(time_secs);
            let summary =
                sanitize_text(commit.summary().ok().flatten().unwrap_or("(no commit message)"));

            revisions.push(FileRevision {
                commit_oid: oid.to_string(),
                author: author_str,
                date,
                when,
                summary,
            });
        }
    }

    Ok(revisions)
}

#[derive(Debug, Clone)]
pub struct BlameEntry {
    pub line_no: usize,
    pub commit_id: String,
    pub author: String,
    pub date: String,
}

pub fn get_file_blame(repo_path: &Path, file_path: &str) -> Result<Vec<BlameEntry>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut opts = git2::BlameOptions::new();
    let blame = repo
        .blame_file(std::path::Path::new(file_path), Some(&mut opts))
        .map_err(|e| e.to_string())?;

    let mut entries = Vec::new();
    for i in 0..blame.len() {
        if let Some(hunk) = blame.get_index(i) {
            let commit_id = hunk.final_commit_id().to_string();
            let short_id = if commit_id.len() >= 7 { &commit_id[..7] } else { &commit_id };

            let mut author_name = "Unknown".to_string();
            let mut date_str = "unknown".to_string();
            if let Ok(commit) = repo.find_commit(hunk.final_commit_id()) {
                author_name = commit.author().name().unwrap_or("Unknown").to_string();
                date_str = format_utc_date(commit.time().seconds());
            }

            let start = hunk.final_start_line();
            let count = hunk.lines_in_hunk();
            for line_idx in 0..count {
                entries.push(BlameEntry {
                    line_no: start + line_idx,
                    commit_id: short_id.to_string(),
                    author: author_name.clone(),
                    date: date_str.clone(),
                });
            }
        }
    }

    entries.sort_by_key(|e| e.line_no);
    Ok(entries)
}

fn collect_committer_stats(
    repo: &Repository,
    limit: usize,
) -> Result<(Vec<CommitterStat>, bool), git2::Error> {
    let mut walk = repo.revwalk()?;
    if walk.push_head().is_err() {
        return Ok((Vec::new(), false));
    }
    let mut counts = std::collections::HashMap::new();
    let mut count = 0;
    let mut limit_reached = false;
    for id in walk {
        let oid = id?;
        if let Ok(commit) = repo.find_commit(oid) {
            let author = commit.author();
            let name = author.name().unwrap_or("?").to_string();
            let email = author.email().unwrap_or("?").to_string();
            let key = (name, email);
            *counts.entry(key).or_insert(0) += 1;
            count += 1;
            if count >= limit {
                limit_reached = true;
                break;
            }
        }
    }

    let mut stats: Vec<CommitterStat> = counts
        .into_iter()
        .map(|((name, email), count)| CommitterStat { name, email, count })
        .collect();

    stats.sort_by(|a, b| b.count.cmp(&a.count).then_with(|| a.name.cmp(&b.name)));

    Ok((stats, limit_reached))
}

/// Diff `commit` against its first parent (or against an empty tree for the
/// initial commit) and return the list of changed files. Capped at
/// `MAX_FILES_PER_SECTION` entries.
fn commit_changed_files(repo: &Repository, commit: &git2::Commit) -> Vec<FileEntry> {
    let commit_tree = match commit.tree() {
        Ok(t) => t,
        Err(_) => return Vec::new(),
    };
    // For the initial commit parent_tree is None — libgit2 treats that as an
    // empty tree, so all files appear as "added".
    let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

    let diff = match repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&commit_tree), None) {
        Ok(d) => d,
        Err(_) => return Vec::new(),
    };

    let mut files = Vec::new();
    for delta in diff.deltas() {
        if files.len() >= MAX_FILES_PER_SECTION {
            break;
        }
        let path = delta
            .new_file()
            .path()
            .or_else(|| delta.old_file().path())
            .map(|p| p.to_string_lossy().into_owned())
            .unwrap_or_else(|| "(unknown)".to_string());

        let label: &'static str = match delta.status() {
            git2::Delta::Added => "N",
            git2::Delta::Deleted => "D",
            git2::Delta::Modified => "M",
            git2::Delta::Renamed => "R",
            git2::Delta::Typechange => "T",
            _ => "M",
        };
        files.push(FileEntry { path, label });
    }
    files
}

pub fn get_commit_files(repo_path: &Path, oid: &str) -> Result<Vec<FileEntry>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let oid = git2::Oid::from_str(oid).map_err(|e| e.to_string())?;
    let commit = repo.find_commit(oid).map_err(|e| e.to_string())?;
    Ok(commit_changed_files(&repo, &commit))
}
fn match_pattern(path: &str, pattern: &str) -> bool {
    if let Some(suffix) = pattern.strip_prefix('*') {
        return path.ends_with(suffix);
    }
    if let Some(prefix) = pattern.strip_suffix('*') {
        return path.starts_with(prefix);
    }
    if pattern.contains('*') {
        let parts: Vec<&str> = pattern.split('*').collect();
        if parts.len() == 2 {
            return path.starts_with(parts[0]) && path.ends_with(parts[1]);
        }
    }
    path == pattern || path.ends_with(&format!("/{}", pattern))
}

static LFS_INSTALLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();

fn is_lfs_installed() -> bool {
    *LFS_INSTALLED.get_or_init(|| {
        if let Ok(output) = git_command().arg("lfs").arg("--version").output() {
            output.status.success()
        } else {
            false
        }
    })
}

fn get_lfs_info(repo_path: &Path) -> (bool, std::collections::HashSet<String>) {
    let mut tracked = std::collections::HashSet::new();

    // Skip LFS subprocesses entirely if the repo is not using LFS
    let lfs_dir = repo_path.join(".git").join("lfs");
    let gitattributes_path = repo_path.join(".gitattributes");
    let has_lfs_attributes = if gitattributes_path.exists() {
        if let Ok(content) = std::fs::read_to_string(&gitattributes_path) {
            content.contains("filter=lfs")
                || content.contains("diff=lfs")
                || content.contains("merge=lfs")
        } else {
            false
        }
    } else {
        false
    };

    if !lfs_dir.exists() && !has_lfs_attributes {
        return (false, tracked);
    }

    let installed = is_lfs_installed();
    if installed {
        if let Ok(output) =
            git_command().arg("lfs").arg("ls-files").arg("-n").current_dir(repo_path).output()
        {
            if output.status.success() {
                if let Ok(stdout) = String::from_utf8(output.stdout) {
                    for line in stdout.lines() {
                        let trimmed = line.trim();
                        if !trimmed.is_empty() {
                            tracked.insert(trimmed.to_string());
                        }
                    }
                }
            }
        }
    }

    let gitattributes_path = repo_path.join(".gitattributes");
    if gitattributes_path.exists() {
        if let Ok(content) = std::fs::read_to_string(&gitattributes_path) {
            let mut patterns = Vec::new();
            for line in content.lines() {
                let line = line.trim();
                if line.is_empty() || line.starts_with('#') {
                    continue;
                }
                if line.contains("filter=lfs")
                    || line.contains("diff=lfs")
                    || line.contains("merge=lfs")
                {
                    if let Some(pattern) = line.split_whitespace().next() {
                        patterns.push(pattern.to_string());
                    }
                }
            }

            if !patterns.is_empty() {
                if let Ok(repo) = Repository::open(repo_path) {
                    if let Ok(index) = repo.index() {
                        for entry in index.iter() {
                            if let Ok(path_str) = std::str::from_utf8(&entry.path) {
                                for pat in &patterns {
                                    if match_pattern(path_str, pat) {
                                        tracked.insert(path_str.to_string());
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    (installed, tracked)
}

fn get_lfs_storage_size(repo_path: &Path) -> Option<u64> {
    let lfs_path = repo_path.join(".git").join("lfs");
    if !lfs_path.exists() {
        return None;
    }

    fn calculate_dir_size(dir: &Path) -> u64 {
        let mut size = 0;
        if let Ok(entries) = std::fs::read_dir(dir) {
            for entry in entries.flatten() {
                if let Ok(metadata) = entry.metadata() {
                    if metadata.is_dir() {
                        size += calculate_dir_size(&entry.path());
                    } else {
                        size += metadata.len();
                    }
                }
            }
        }
        size
    }

    Some(calculate_dir_size(&lfs_path))
}

// ── Internal collection ────────────────────────────────────────────────────

fn collect_info(
    path: &Path,
    commit_limit: usize,
    _graph_max_commits: usize,
    enable_commit_signatures: bool,
) -> Result<RepoInfo, git2::Error> {
    let repo = Repository::open(path)?;
    let mut summary = RepoSummary::default();
    if let Ok(head) = repo.head() {
        summary.branch = head.shorthand().ok().map(String::from);
    }
    populate_ahead_behind(&repo, &mut summary);

    let mut info = RepoInfo { summary, ..RepoInfo::default() };
    let (lfs_inst, lfs_f) = get_lfs_info(path);
    info.lfs_installed = lfs_inst;
    info.lfs_files = lfs_f;
    info.lfs_storage_size = get_lfs_storage_size(path);

    let is_detached = repo.head_detached().unwrap_or(false);
    if is_detached {
        info.branch = Some("HEAD".to_string());
        if let Ok(head) = repo.head() {
            if let Ok(commit) = head.peel_to_commit() {
                let short_id = format!("{:.7}", commit.id());
                let summary_text =
                    sanitize_text(commit.summary().ok().flatten().unwrap_or("(no commit message)"));
                let author = commit.author();
                let author_str = sanitize_text(&format!(
                    "{} <{}>",
                    author.name().unwrap_or("?"),
                    author.email().unwrap_or("?")
                ));
                let when = format_relative_time(commit.time().seconds());
                info.head =
                    Some(HeadInfo { short_id, summary: summary_text, author: author_str, when });
            }
        }
    } else if let Ok(head) = repo.head() {
        info.branch = head.shorthand().ok().map(String::from);

        if let Ok(commit) = head.peel_to_commit() {
            let short_id = format!("{:.7}", commit.id());
            let summary_text =
                sanitize_text(commit.summary().ok().flatten().unwrap_or("(no commit message)"));
            let author = commit.author();
            let author_str = sanitize_text(&format!(
                "{} <{}>",
                author.name().unwrap_or("?"),
                author.email().unwrap_or("?")
            ));
            let when = format_relative_time(commit.time().seconds());
            info.head =
                Some(HeadInfo { short_id, summary: summary_text, author: author_str, when });
        }

        if let Ok(head_name) = head.name() {
            info.upstream = upstream_short_name(&repo, head_name);
        }
    }

    if let Ok(commits) = collect_commits(&repo, commit_limit, path, enable_commit_signatures) {
        info.commits = commits;
    }

    populate_summary_and_file_changes(&repo, &mut info);

    if let Ok(remotes) = load_tab_remotes(path) {
        info.remotes = TabData::Loaded(remotes);
        info.tab_loaded_at[5] = Some(std::time::Instant::now());
    }

    Ok(info)
}

pub fn load_tab_reflog(repo_path: &Path) -> Result<Vec<ReflogEntry>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let reflog = repo.reflog("HEAD").map_err(|e| e.to_string())?;
    let mut entries = Vec::new();
    for (i, entry) in reflog.iter().enumerate() {
        let target_oid = format!("{}", entry.id_new());
        let selector = format!("HEAD@{{{}}}", i);
        let msg = entry.message().ok().flatten().unwrap_or("").to_string();

        let (command, message) = if let Some(pos) = msg.find(':') {
            (msg[..pos].trim().to_string(), msg[pos + 1..].trim().to_string())
        } else {
            (String::new(), msg)
        };

        let sig = entry.committer();
        let when_secs = sig.when().seconds();
        let when = format_relative_time(when_secs);
        let date = format_utc_date(when_secs);

        entries.push(ReflogEntry { index: i, target_oid, selector, command, message, when, date });
    }
    Ok(entries)
}

pub fn checkout_commit(repo_path: &Path, commit_oid: &str) -> Result<(), git2::Error> {
    let output = git_command()
        .arg("checkout")
        .arg(commit_oid)
        .current_dir(repo_path)
        .output()
        .map_err(|e| git2::Error::from_str(&e.to_string()))?;

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(git2::Error::from_str(&err));
    }
    Ok(())
}

pub fn load_tab_files(repo_path: &Path) -> Result<Vec<String>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut files = Vec::new();
    if let Ok(index) = repo.index() {
        for entry in index.iter() {
            if let Ok(path_str) = std::str::from_utf8(&entry.path) {
                files.push(path_str.to_string());
            }
        }
    }
    Ok(files)
}

/// Everything the Graph tab needs from one `git log --graph` run.
#[derive(Debug, Clone, Default)]
pub struct GraphLoad {
    pub lines: Vec<GraphLine>,
    /// One-line, deduplicated summary of anything git wrote to stderr while
    /// still producing a graph (typically a missing signature program). The
    /// UI shows it in the status bar; it never replaces the graph itself.
    pub notice: Option<String>,
}

pub fn load_tab_graph_stream(
    repo_path: &Path,
    graph_max_commits: usize,
    enable_commit_signatures: bool,
    repo_resolved_path: String,
    tab_idx: usize,
    tx: std::sync::mpsc::Sender<(String, usize, TabPayload)>,
) -> Result<GraphLoad, String> {
    let mut graph_lines = Vec::new();
    // `%G?` makes git exec gpg/ssh-keygen for every signed commit, so it is only
    // requested when the user opted into signature badges.
    let format_str = if enable_commit_signatures {
        "%H__TWIG_SEP__%d__TWIG_SEP__%s__TWIG_SEP__%an__TWIG_SEP__%ad__TWIG_SEP__%G?"
    } else {
        "%H__TWIG_SEP__%d__TWIG_SEP__%s__TWIG_SEP__%an__TWIG_SEP__%ad"
    };

    let mut args = vec![
        "log".to_string(),
        "--graph".to_string(),
        "--all".to_string(),
        "--date=relative".to_string(),
    ];
    if graph_max_commits > 0 {
        args.push(format!("--max-count={}", graph_max_commits));
    }
    args.push(format!("--pretty=format:{}", format_str));
    args.push("--color=never".to_string());

    let mut child =
        git_command().args(&args).current_dir(repo_path).spawn().map_err(|e| e.to_string())?;

    // stderr must be drained alongside stdout: left unread it would fill and
    // stall git; left inherited (the old bug) it would print over the TUI.
    let stderr_reader = spawn_pipe_reader(&mut child);
    let stdout = child.stdout.take().ok_or_else(|| "Failed to open stdout".to_string())?;
    let reader = std::io::BufReader::new(stdout);
    use std::io::BufRead;

    for (idx, line_res) in reader.lines().enumerate() {
        let line = line_res.map_err(|e| e.to_string())?;
        let parsed = parse_graph_line(&line);
        graph_lines.push(parsed);

        // Every 200 lines, send a cloned batch to UI
        if (idx + 1) % 200 == 0 {
            let _ = tx.send((
                repo_resolved_path.clone(),
                tab_idx,
                TabPayload::Graph(Ok(graph_lines.clone())),
            ));
        }
    }

    // Wait for the child process to exit
    let status = child.wait().map_err(|e| e.to_string())?;
    let stderr = stderr_reader.join().unwrap_or_default();
    let notice = summarize_stderr(&stderr);
    if !status.success() && graph_lines.is_empty() {
        return Err(notice.unwrap_or_else(|| "git log failed".to_string()));
    }

    Ok(GraphLoad { lines: graph_lines, notice })
}

pub fn load_tab_branches(
    repo_path: &Path,
) -> (Result<Vec<BranchInfo>, String>, Result<Vec<BranchInfo>, String>) {
    let repo = match Repository::open(repo_path) {
        Ok(r) => r,
        Err(e) => return (Err(e.to_string()), Err(e.to_string())),
    };

    let mut local_branches = Vec::new();
    let is_detached = repo.head_detached().unwrap_or(false);
    if is_detached {
        let mut short_sha = String::new();
        let mut short_message = String::new();
        if let Ok(head) = repo.head() {
            if let Ok(target) = head.peel_to_commit() {
                let id = target.id();
                let id_str = id.to_string();
                short_sha = safe_sha_slice(&id_str, 7).to_string();
                if let Ok(Some(summary)) = target.summary() {
                    short_message = summary.to_string();
                }
            }
        }
        local_branches.push(BranchInfo {
            name: "HEAD".to_string(),
            is_head: true,
            short_sha,
            short_message: sanitize_text(&short_message),
        });
    }
    if let Ok(branches) = repo.branches(Some(git2::BranchType::Local)) {
        for (branch, _) in branches.flatten() {
            if let Ok(Some(name)) = branch.name() {
                let is_head = branch.is_head();
                let mut short_sha = String::new();
                let mut short_message = String::new();
                if let Ok(target) = branch.get().peel_to_commit() {
                    let id = target.id();
                    let id_str = id.to_string();
                    short_sha = safe_sha_slice(&id_str, 7).to_string();
                    if let Ok(Some(summary)) = target.summary() {
                        short_message = summary.to_string();
                    }
                }
                local_branches.push(BranchInfo {
                    name: sanitize_text(name),
                    is_head,
                    short_sha,
                    short_message: sanitize_text(&short_message),
                });
            }
        }
    }
    local_branches.sort_by(|a, b| b.is_head.cmp(&a.is_head).then_with(|| a.name.cmp(&b.name)));

    let mut remote_branches = Vec::new();
    if let Ok(branches) = repo.branches(Some(git2::BranchType::Remote)) {
        for (branch, _) in branches.flatten() {
            if let Ok(Some(name)) = branch.name() {
                if !name.ends_with("/HEAD") {
                    let is_head = branch.is_head();
                    let mut short_sha = String::new();
                    let mut short_message = String::new();
                    if let Ok(target) = branch.get().peel_to_commit() {
                        let id = target.id();
                        let id_str = id.to_string();
                        short_sha = safe_sha_slice(&id_str, 7).to_string();
                        if let Ok(Some(summary)) = target.summary() {
                            short_message = summary.to_string();
                        }
                    }
                    remote_branches.push(BranchInfo {
                        name: sanitize_text(name),
                        is_head,
                        short_sha,
                        short_message: sanitize_text(&short_message),
                    });
                }
            }
        }
    }
    remote_branches.sort_by(|a, b| a.name.cmp(&b.name));

    (Ok(local_branches), Ok(remote_branches))
}

pub fn load_tab_tags(
    repo_path: &Path,
) -> (Result<Vec<BranchInfo>, String>, Result<Vec<BranchInfo>, String>) {
    let repo = match Repository::open(repo_path) {
        Ok(r) => r,
        Err(e) => return (Err(e.to_string()), Err(e.to_string())),
    };

    let mut local_tags = Vec::new();
    if let Ok(tags) = repo.tag_names(None) {
        for tag_opt in tags.iter() {
            if let Ok(Some(tag)) = tag_opt {
                let mut short_sha = String::new();
                let mut short_message = String::new();
                if let Ok(reference) = repo.find_reference(&format!("refs/tags/{}", tag)) {
                    if let Ok(target) = reference.peel_to_commit() {
                        let id = target.id();
                        let id_str = id.to_string();
                        short_sha = safe_sha_slice(&id_str, 7).to_string();
                        if let Ok(Some(summary)) = target.summary() {
                            short_message = summary.to_string();
                        }
                    }
                }
                local_tags.push(BranchInfo {
                    name: sanitize_text(tag),
                    is_head: false,
                    short_sha,
                    short_message: sanitize_text(&short_message),
                });
            }
        }
    }
    local_tags.sort_by(|a, b| b.name.cmp(&a.name));

    (Ok(local_tags), Ok(Vec::new()))
}

pub fn load_tab_remotes(repo_path: &Path) -> Result<Vec<RemoteInfo>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut remotes_list = Vec::new();
    if let Ok(remotes) = repo.remotes() {
        for name in remotes.iter() {
            let Ok(Some(name)) = name else { continue };
            if let Ok(remote) = repo.find_remote(name) {
                let push_url = remote.pushurl().ok().flatten().map(String::from);
                let mut refspecs = Vec::new();
                for r in remote.refspecs() {
                    if let Ok(s) = r.str() {
                        refspecs.push(s.to_string());
                    }
                }
                remotes_list.push(RemoteInfo {
                    name: name.to_string(),
                    url: remote.url().unwrap_or("(no url)").to_string(),
                    push_url,
                    refspecs,
                });
            }
        }
    }
    Ok(remotes_list)
}

pub fn load_tab_stashes(repo_path: &Path) -> Result<Vec<StashInfo>, String> {
    let mut repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut temp_stashes = Vec::new();
    let _ = repo.stash_foreach(|index, message, oid| {
        temp_stashes.push((index, message.to_string(), *oid));
        true
    });

    let mut stashes = Vec::new();
    for (index, message, oid) in temp_stashes {
        let mut files = Vec::new();
        if let Ok(commit) = repo.find_commit(oid) {
            files = commit_changed_files(&repo, &commit);
        }
        stashes.push(StashInfo {
            index,
            message: sanitize_text(&message),
            commit_id: oid.to_string(),
            files,
        });
    }
    Ok(stashes)
}

pub fn load_tab_overview(
    repo_path: &Path,
    _commit_limit: usize,
) -> Result<(Vec<CommitterStat>, bool), String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let (stats, limit_reached) =
        collect_committer_stats(&repo, usize::MAX).map_err(|e| e.to_string())?;
    Ok((stats, limit_reached))
}

pub fn load_tab_submodules(repo_path: &Path) -> Result<Vec<SubmoduleInfo>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let submodules = repo.submodules().map_err(|e| e.to_string())?;
    let mut list = Vec::new();
    for sub in submodules {
        let name = sub.name().unwrap_or("").to_string();
        let path = sub.path().to_path_buf();
        let url = sub.url().unwrap_or(None).unwrap_or("").to_string();
        let commit_id = sub.index_id().map(|id| id.to_string());
        let head_id = sub.head_id().map(|id| id.to_string());

        let mut is_initialized = true;
        let mut is_dirty = false;

        if let Ok(status) = repo.submodule_status(&name, git2::SubmoduleIgnore::None) {
            is_initialized = !status.contains(git2::SubmoduleStatus::WD_UNINITIALIZED);
            is_dirty = status.contains(git2::SubmoduleStatus::WD_MODIFIED)
                || status.contains(git2::SubmoduleStatus::WD_WD_MODIFIED)
                || status.contains(git2::SubmoduleStatus::WD_UNTRACKED)
                || status.contains(git2::SubmoduleStatus::WD_INDEX_MODIFIED)
                || status.contains(git2::SubmoduleStatus::INDEX_MODIFIED);
        }

        list.push(SubmoduleInfo { name, path, url, commit_id, head_id, is_initialized, is_dirty });
    }
    Ok(list)
}

/// Deletes the submodule registered as `name` and checked out at `path`
/// (relative to the repository root): deinitialises it, removes its gitlink,
/// `.gitmodules` entry and working directory with `git rm`, then deletes its
/// module directory under the git dir so re-adding it later starts clean.
/// The result is staged, not committed.
///
/// `git submodule deinit` and `git rm` take a *path*. The *name* differs from
/// it after `git submodule add --name` or a `git mv`, and only locates the
/// module directory: passing the name to `git rm` once deleted an unrelated
/// tracked file that happened to share it. Nothing is changed unless `path` is
/// a submodule (gitlink) entry in the index.
pub fn submodule_remove(repo_path: &Path, name: &str, path: &Path) -> Result<(), String> {
    let plain_relative = |p: &Path| {
        !p.as_os_str().is_empty()
            && p.components().all(|c| matches!(c, std::path::Component::Normal(_)))
    };
    if !plain_relative(path) {
        return Err(format!("Refusing to remove submodule at unsafe path '{}'", path.display()));
    }
    if !plain_relative(Path::new(name)) {
        return Err(format!("Refusing to remove submodule with unsafe name '{}'", name));
    }
    let path_str = path.to_str().ok_or("Submodule path is not valid UTF-8")?;

    let run = |args: &[&str]| -> Result<Vec<u8>, String> {
        let output = git_command()
            .arg("--literal-pathspecs")
            .args(args)
            .current_dir(repo_path)
            .output()
            .map_err(|e| e.to_string())?;
        if !output.status.success() {
            return Err(String::from_utf8_lossy(&output.stderr).trim().to_string());
        }
        Ok(output.stdout)
    };

    // `ls-files --stage -z` prints `<mode> <oid> <stage>\t<path>\0` per entry;
    // a submodule is exactly one entry, of mode 160000, at exactly `path`.
    let staged = run(&["ls-files", "--stage", "-z", "--", path_str])?;
    let entries: Vec<&[u8]> = staged.split(|b| *b == 0).filter(|e| !e.is_empty()).collect();
    let is_gitlink = match entries.as_slice() {
        [entry] => {
            let entry = String::from_utf8_lossy(entry);
            entry.starts_with("160000 ")
                && entry.split_once('\t').is_some_and(|(_, p)| p == path_str)
        }
        _ => false,
    };
    if !is_gitlink {
        return Err(format!("'{}' is not a submodule in the index; nothing was removed", path_str));
    }

    run(&["submodule", "deinit", "-f", "--", path_str])?;
    run(&["rm", "-f", "--", path_str])?;

    // Module directories are per worktree, so ask git where this one's lives
    // (relative to `repo_path` in the main worktree, absolute in a linked one).
    let module_path = run(&["rev-parse", "--git-path", &format!("modules/{}", name)])?;
    let module_dir = repo_path.join(String::from_utf8_lossy(&module_path).trim());
    if module_dir.is_dir() {
        std::fs::remove_dir_all(&module_dir).map_err(|e| {
            format!(
                "Submodule removed, but its module directory {} could not be deleted: {}",
                module_dir.display(),
                e
            )
        })?;
    }
    Ok(())
}

/// Initialises and updates the submodule checked out at `path` (relative to
/// the repository root), or every submodule when `path` is `None`, together
/// with any submodules nested inside it: `git submodule update --init
/// --recursive`. Each submodule's configured update mode applies and nothing
/// is forced, so local changes a checkout would overwrite fail the update
/// instead of being lost. It may clone or fetch, so it is bounded by `timeout`
/// (zero means no limit).
pub fn submodule_update(
    repo_path: &Path,
    path: Option<&Path>,
    timeout: Duration,
) -> Result<(), String> {
    let mut cmd = git_command();
    cmd.args(["--literal-pathspecs", "submodule", "update", "--init", "--recursive"])
        .current_dir(repo_path);
    if let Some(path) = path {
        cmd.arg("--").arg(path);
    }
    let output = run_git_with_timeout(cmd, timeout).map_err(|e| e.to_string())?;
    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).trim().replace('\n', " "));
    }
    Ok(())
}

/// Build a map from commit `Oid` → list of ref names that point to it.
/// Local branches are stored as plain names (e.g. `"main"`).
/// Lightweight and annotated tags are stored with a `"tag:"` prefix
/// (e.g. `"tag:v1.0"`) so the UI can colour them differently.
fn build_ref_map(repo: &Repository) -> std::collections::HashMap<git2::Oid, Vec<String>> {
    let mut map: std::collections::HashMap<git2::Oid, Vec<String>> =
        std::collections::HashMap::new();

    if let Ok(refs) = repo.references() {
        for reference in refs.flatten() {
            // Resolve to the underlying commit Oid (peeling through tags).
            let Ok(target) = reference.peel_to_commit() else {
                continue;
            };
            let oid = target.id();

            let Ok(full_name) = reference.name() else {
                continue;
            };

            let label = if let Some(branch) = full_name.strip_prefix("refs/heads/") {
                branch.to_string()
            } else if let Some(tag) = full_name.strip_prefix("refs/tags/") {
                format!("tag:{}", tag)
            } else if let Some(remote) = full_name.strip_prefix("refs/remotes/") {
                // Skip the symbolic HEAD pointer each remote keeps (e.g. origin/HEAD).
                if remote.ends_with("/HEAD") {
                    continue;
                }
                format!("remote:{}", remote)
            } else {
                continue;
            };

            map.entry(oid).or_default().push(label);
        }
    }

    if repo.head_detached().unwrap_or(false) {
        if let Ok(head) = repo.head() {
            if let Ok(target) = head.peel_to_commit() {
                let oid = target.id();
                let label = "head:HEAD".to_string();
                let mut entries = map.remove(&oid).unwrap_or_default();
                entries.insert(0, label);
                map.insert(oid, entries);
            }
        }
    }

    map
}

#[allow(clippy::type_complexity)]
static REF_MAP_CACHE: std::sync::OnceLock<
    std::sync::Mutex<
        std::collections::HashMap<
            String,
            (std::collections::HashMap<git2::Oid, Vec<String>>, std::time::Instant),
        >,
    >,
> = std::sync::OnceLock::new();

fn get_cached_ref_map(
    repo: &Repository,
    repo_path: &Path,
) -> std::collections::HashMap<git2::Oid, Vec<String>> {
    let cache_lock =
        REF_MAP_CACHE.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()));
    let mut cache = cache_lock.lock().unwrap_or_else(|e| e.into_inner());
    let path_key = repo_path.to_string_lossy().to_string();

    if let Some((map, loaded_at)) = cache.get(&path_key) {
        if loaded_at.elapsed() < std::time::Duration::from_secs(10) {
            return map.clone();
        }
    }

    let map = build_ref_map(repo);
    cache.insert(path_key, (map.clone(), std::time::Instant::now()));
    map
}

pub fn invalidate_ref_map_cache(repo_path: &Path) {
    if let Some(cache_lock) = REF_MAP_CACHE.get() {
        if let Ok(mut cache) = cache_lock.lock() {
            cache.remove(&repo_path.to_string_lossy().to_string());
        }
    }
}

/// Maximum file entries collected per bucket. Prevents pathologically large
/// working trees from overwhelming the detail view.
const MAX_FILES_PER_SECTION: usize = 100;

/// Walk the working-tree status once and collect both summary counts and per-file info.
fn populate_summary_and_file_changes(repo: &Repository, info: &mut RepoInfo) {
    let mut opts = StatusOptions::new();
    opts.include_untracked(true)
        .renames_head_to_index(true)
        .recurse_untracked_dirs(true)
        .show(StatusShow::IndexAndWorkdir);
    let Ok(statuses) = repo.statuses(Some(&mut opts)) else {
        return;
    };
    for entry in statuses.iter() {
        let path = entry.path().unwrap_or("(unknown)").to_string();
        let flags = entry.status();

        // 1. Populate summary counters
        if flags.is_conflicted() {
            info.summary.conflicted += 1;
        } else {
            if flags.is_wt_new() {
                info.summary.untracked += 1;
            }
            if flags.is_wt_modified()
                || flags.is_wt_deleted()
                || flags.is_wt_renamed()
                || flags.is_wt_typechange()
            {
                info.summary.modified += 1;
            }
            if flags.is_index_new()
                || flags.is_index_modified()
                || flags.is_index_deleted()
                || flags.is_index_renamed()
                || flags.is_index_typechange()
            {
                info.summary.staged += 1;
            }
        }

        // 2. Populate file entries
        // Skip directories to avoid showing folders in staging panels.
        // We only call is_dir() for untracked files (since tracked items in git status are always files).
        let is_dir = if flags.is_wt_new() && !flags.is_index_new() {
            let path_buf = repo.workdir().unwrap_or(Path::new("")).join(&path);
            path_buf.is_dir()
        } else {
            false
        };
        if is_dir {
            continue;
        }

        if flags.is_conflicted() {
            if info.changes.conflicted.len() < MAX_FILES_PER_SECTION {
                info.changes.conflicted.push(FileEntry { path: path.clone(), label: "C" });
            }
            continue;
        }

        // Index (staged) changes
        if (flags.is_index_new()
            || flags.is_index_modified()
            || flags.is_index_deleted()
            || flags.is_index_renamed()
            || flags.is_index_typechange())
            && info.changes.staged.len() < MAX_FILES_PER_SECTION
        {
            let label = if flags.is_index_new() {
                "N"
            } else if flags.is_index_deleted() {
                "D"
            } else if flags.is_index_renamed() {
                "R"
            } else if flags.is_index_typechange() {
                "T"
            } else {
                "M"
            };
            info.changes.staged.push(FileEntry { path: path.clone(), label });
        }

        // Working-tree changes
        if flags.is_wt_new() {
            if info.changes.untracked.len() < MAX_FILES_PER_SECTION {
                info.changes.untracked.push(FileEntry { path: path.clone(), label: "?" });
            }
            if info.changes.unstaged.len() < MAX_FILES_PER_SECTION {
                info.changes.unstaged.push(FileEntry { path: path.clone(), label: "N" });
            }
        } else if (flags.is_wt_modified()
            || flags.is_wt_deleted()
            || flags.is_wt_renamed()
            || flags.is_wt_typechange())
            && info.changes.unstaged.len() < MAX_FILES_PER_SECTION
        {
            let label = if flags.is_wt_deleted() {
                "D"
            } else if flags.is_wt_renamed() {
                "R"
            } else if flags.is_wt_typechange() {
                "T"
            } else {
                "M"
            };
            info.changes.unstaged.push(FileEntry { path: path.clone(), label });
        }
    }
}

/// Collect the branch name, worktree counts, and ahead/behind for an opened
/// repo. Used by both `inspect_summary` (card) and `collect_info` (detail)
/// so the values shown in both places always agree.
fn collect_summary(repo: &Repository) -> RepoSummary {
    let mut s = RepoSummary::default();
    let is_detached = repo.head_detached().unwrap_or(false);
    if is_detached {
        s.branch = Some("HEAD".to_string());
        if let Ok(head) = repo.head() {
            if let Ok(commit) = head.peel_to_commit() {
                s.last_commit_time = Some(commit.time().seconds());
            }
        }
    } else if let Ok(head) = repo.head() {
        s.branch = head.shorthand().ok().map(String::from);
        if let Ok(commit) = head.peel_to_commit() {
            s.last_commit_time = Some(commit.time().seconds());
        }
    }
    populate_worktree(repo, &mut s);
    populate_ahead_behind(repo, &mut s);
    s.state = match repo.state() {
        git2::RepositoryState::Clean => RepoState::Clean,
        git2::RepositoryState::Merge => RepoState::Merge,
        git2::RepositoryState::Revert | git2::RepositoryState::RevertSequence => RepoState::Revert,
        git2::RepositoryState::CherryPick | git2::RepositoryState::CherryPickSequence => {
            RepoState::CherryPick
        }
        git2::RepositoryState::Bisect => RepoState::Bisect,
        git2::RepositoryState::Rebase
        | git2::RepositoryState::RebaseInteractive
        | git2::RepositoryState::RebaseMerge => RepoState::Rebase,
        git2::RepositoryState::ApplyMailbox | git2::RepositoryState::ApplyMailboxOrRebase => {
            RepoState::ApplyMailbox
        }
    };
    s
}

fn populate_worktree(repo: &Repository, s: &mut RepoSummary) {
    let mut opts = StatusOptions::new();
    opts.include_untracked(true).renames_head_to_index(true).show(StatusShow::IndexAndWorkdir);
    let Ok(statuses) = repo.statuses(Some(&mut opts)) else {
        return;
    };
    for entry in statuses.iter() {
        let flags = entry.status();
        if flags.is_conflicted() {
            s.conflicted += 1;
            continue;
        }
        if flags.is_wt_new() {
            s.untracked += 1;
        }
        if flags.is_wt_modified()
            || flags.is_wt_deleted()
            || flags.is_wt_renamed()
            || flags.is_wt_typechange()
        {
            s.modified += 1;
        }
        if flags.is_index_new()
            || flags.is_index_modified()
            || flags.is_index_deleted()
            || flags.is_index_renamed()
            || flags.is_index_typechange()
        {
            s.staged += 1;
        }
    }
}

/// Compute commits ahead/behind the upstream branch. Silently leaves
/// both at 0 if HEAD is detached, the branch has no upstream configured,
/// or any libgit2 lookup fails — the card simply shows no ↑/↓ then.
fn populate_ahead_behind(repo: &Repository, s: &mut RepoSummary) {
    let Ok(head) = repo.head() else { return };
    let Some(local_oid) = head.target() else {
        return;
    };
    let Ok(head_name) = head.name() else { return };
    let Ok(upstream_buf) = repo.branch_upstream_name(head_name) else {
        return;
    };
    let Ok(upstream_name) = std::str::from_utf8(&upstream_buf) else {
        return;
    };
    let Ok(upstream_ref) = repo.find_reference(upstream_name) else {
        return;
    };
    let Some(upstream_oid) = upstream_ref.target() else {
        return;
    };
    if let Ok((ahead, behind)) = repo.graph_ahead_behind(local_oid, upstream_oid) {
        s.ahead = ahead;
        s.behind = behind;
    }
}

/// `"origin/main"`-style short name for HEAD's upstream, or `None`.
fn upstream_short_name(repo: &Repository, head_name: &str) -> Option<String> {
    let buf = repo.branch_upstream_name(head_name).ok()?;
    let raw = std::str::from_utf8(&buf).ok()?;
    Some(raw.strip_prefix("refs/remotes/").unwrap_or(raw).to_string())
}

/// Format a unix-epoch timestamp as a relative time string ("3 days ago").
pub fn format_relative_time(secs: i64) -> String {
    if secs <= 0 {
        return "unknown".to_string();
    }
    let then = UNIX_EPOCH + Duration::from_secs(secs as u64);
    let now = SystemTime::now();
    let Ok(elapsed) = now.duration_since(then) else {
        return "in the future".to_string();
    };
    let secs = elapsed.as_secs();
    let (n, unit) = if secs < 60 {
        (secs, "second")
    } else if secs < 3600 {
        (secs / 60, "minute")
    } else if secs < 86_400 {
        (secs / 3600, "hour")
    } else if secs < 86_400 * 30 {
        (secs / 86_400, "day")
    } else if secs < 86_400 * 365 {
        (secs / (86_400 * 30), "month")
    } else {
        (secs / (86_400 * 365), "year")
    };
    let plural = if n == 1 { "" } else { "s" };
    format!("{} {}{} ago", n, unit, plural)
}

/// Format a unix-epoch timestamp as a UTC date string ("YYYY-MM-DD HH:MM:SS UTC").
fn format_utc_date(secs: i64) -> String {
    if secs <= 0 {
        return "unknown".to_string();
    }
    let seconds_in_day = 86400;
    let day_number = secs / seconds_in_day;
    let time_of_day = secs % seconds_in_day;

    let mut hour = time_of_day / 3600;
    let mut minute = (time_of_day % 3600) / 60;
    let mut second = time_of_day % 60;
    if hour < 0 {
        hour += 24;
    }
    if minute < 0 {
        minute += 60;
    }
    if second < 0 {
        second += 60;
    }

    // Howard Hinnant's civil date from epoch days algorithm
    let z = day_number + 719468;
    let era = (if z >= 0 { z } else { z - 146096 }) / 146097;
    let doe = (z - era * 146097) as u32;
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    let y = (yoe as i32) + (era as i32) * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = doy - (153 * mp + 2) / 5 + 1;
    let m = if mp < 10 { mp + 3 } else { mp - 9 };
    let y = y + if m <= 2 { 1 } else { 0 };

    format!("{:04}-{:02}-{:02} {:02}:{:02}:{:02} UTC", y, m, d, hour, minute, second)
}

// ── Per-file diff (private) ────────────────────────────────────────────────

fn get_file_diff_inner(
    repo_path: &Path,
    commit_oid: &str,
    file_path: &str,
) -> Option<Vec<DiffLine>> {
    let repo = Repository::open(repo_path).ok()?;
    let oid = git2::Oid::from_str(commit_oid).ok()?;
    let commit = repo.find_commit(oid).ok()?;

    let commit_tree = commit.tree().ok()?;
    // For the initial commit, parent_tree is None; libgit2 treats it as empty.
    let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

    let mut opts = git2::DiffOptions::new();
    opts.pathspec(file_path);

    let diff =
        repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&commit_tree), Some(&mut opts)).ok()?;

    collect_diff_lines(&diff)
}

/// Diff a single file in the working tree.
///
/// `staged = true`:  HEAD-tree → index (what `git diff --cached` shows).
/// `staged = false`: index → working directory (what `git diff` shows).
fn get_worktree_diff_inner(
    repo_path: &Path,
    file_path: &str,
    staged: bool,
) -> Option<Vec<DiffLine>> {
    let repo = Repository::open(repo_path).ok()?;
    let mut opts = git2::DiffOptions::new();
    opts.pathspec(file_path);
    opts.include_untracked(true);
    opts.recurse_untracked_dirs(true);
    opts.show_untracked_content(true);

    let diff = if staged {
        // Staged: diff HEAD tree (or empty tree for new repos) → index.
        let head_tree = repo.head().ok().and_then(|h| h.peel_to_tree().ok());
        repo.diff_tree_to_index(head_tree.as_ref(), None, Some(&mut opts)).ok()?
    } else {
        // Unstaged: diff index → working directory.
        repo.diff_index_to_workdir(None, Some(&mut opts)).ok()?
    };

    collect_diff_lines(&diff)
}

/// Walk a libgit2 `Diff` and collect coloured `DiffLine` values.
fn collect_diff_lines(diff: &git2::Diff<'_>) -> Option<Vec<DiffLine>> {
    let mut lines: Vec<DiffLine> = Vec::new();
    let mut current_hunk_idx = None;
    let mut hunk_count = 0;
    diff.print(git2::DiffFormat::Patch, |_, _, line| {
        let kind = match line.origin() {
            '+' => DiffLineKind::Added,
            '-' => DiffLineKind::Removed,
            'H' => {
                current_hunk_idx = Some(hunk_count);
                hunk_count += 1;
                DiffLineKind::Header
            }
            ' ' => DiffLineKind::Context,
            _ => return true, // skip file-header meta lines
        };
        let content = String::from_utf8_lossy(line.content())
            .trim_end_matches('\n')
            .trim_end_matches('\r')
            .to_string();
        lines.push(DiffLine {
            kind,
            content,
            old_lineno: line.old_lineno(),
            new_lineno: line.new_lineno(),
            hunk_idx: current_hunk_idx,
        });
        true
    })
    .ok()?;
    Some(lines)
}

fn parse_graph_line(line: &str) -> GraphLine {
    if line.contains("__TWIG_SEP__") {
        let parts: Vec<&str> = line.split("__TWIG_SEP__").collect();
        if parts.len() >= 5 {
            let graph_and_hash = parts[0];
            let decoration = parts[1].trim().to_string();
            let summary = parts[2].trim().to_string();
            let author = parts[3].trim().to_string();
            let date = parts[4].trim().to_string();
            let signature_status =
                if parts.len() >= 6 { parts[5].trim().to_string() } else { "N".to_string() };

            let char_count = graph_and_hash.chars().count();
            if char_count >= 40 {
                let graph: String = graph_and_hash.chars().take(char_count - 40).collect();
                let oid: String = graph_and_hash.chars().skip(char_count - 40).collect();
                GraphLine {
                    graph,
                    commit: Some(GraphCommit {
                        oid,
                        decoration,
                        summary,
                        author,
                        date,
                        signature_status,
                    }),
                }
            } else {
                GraphLine { graph: graph_and_hash.to_string(), commit: None }
            }
        } else {
            GraphLine { graph: line.to_string(), commit: None }
        }
    } else {
        GraphLine { graph: line.to_string(), commit: None }
    }
}

#[allow(dead_code)]
fn collect_graph_lines(repo_path: &Path, graph_max_commits: usize) -> Vec<GraphLine> {
    let mut graph_lines = Vec::new();
    let format_str = "%H__TWIG_SEP__%d__TWIG_SEP__%s__TWIG_SEP__%an__TWIG_SEP__%ad__TWIG_SEP__%G?";

    let mut args = vec![
        "log".to_string(),
        "--graph".to_string(),
        "--all".to_string(),
        "--date=relative".to_string(),
    ];
    if graph_max_commits > 0 {
        args.push(format!("--max-count={}", graph_max_commits));
    }
    args.push(format!("--pretty=format:{}", format_str));
    args.push("--color=never".to_string());

    let output = git_command().args(&args).current_dir(repo_path).output();

    if let Ok(out) = output {
        if out.status.success() {
            let stdout_str = String::from_utf8_lossy(&out.stdout);
            for line in stdout_str.lines() {
                graph_lines.push(parse_graph_line(line));
            }
        }
    }
    graph_lines
}

pub fn checkout_local_branch(repo_path: &Path, branch_name: &str) -> Result<(), git2::Error> {
    let output = git_command()
        .arg("checkout")
        .arg(branch_name)
        .current_dir(repo_path)
        .output()
        .map_err(|e| git2::Error::from_str(&e.to_string()))?;

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(git2::Error::from_str(&err));
    }
    Ok(())
}

pub fn checkout_remote_branch(
    repo_path: &Path,
    remote_branch_name: &str,
) -> Result<String, git2::Error> {
    let parts: Vec<&str> = remote_branch_name.splitn(2, '/').collect();
    if parts.len() < 2 {
        return Err(git2::Error::from_str("Invalid remote branch name"));
    }
    let local_name = parts[1];

    let output = git_command()
        .arg("checkout")
        .arg(local_name)
        .current_dir(repo_path)
        .output()
        .map_err(|e| git2::Error::from_str(&e.to_string()))?;

    if output.status.success() {
        return Ok(format!("Switched to existing branch '{}'", local_name));
    }

    let output = git_command()
        .arg("checkout")
        .arg("--track")
        .arg(remote_branch_name)
        .current_dir(repo_path)
        .output()
        .map_err(|e| git2::Error::from_str(&e.to_string()))?;

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(git2::Error::from_str(&err));
    }

    Ok(format!("Created and switched to branch '{}' tracking '{}'", local_name, remote_branch_name))
}

/// Creates a new local branch pointing at HEAD.
pub fn create_branch(repo_path: &Path, branch_name: &str) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    let head = repo.head()?;
    let target_commit = head.peel_to_commit()?;
    repo.branch(branch_name, &target_commit, false)?;
    Ok(())
}

/// Deletes a local branch.
pub fn delete_local_branch(repo_path: &Path, branch_name: &str) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    let mut branch = repo.find_branch(branch_name, git2::BranchType::Local)?;
    branch.delete()?;
    Ok(())
}

/// Deletes a remote-tracking branch locally.
pub fn delete_remote_branch(repo_path: &Path, branch_name: &str) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    let mut branch = repo.find_branch(branch_name, git2::BranchType::Remote)?;
    branch.delete()?;
    Ok(())
}

/// Creates or updates a tag pointing at the specified commit OID with optional message and force flag.
pub fn create_tag(
    repo_path: &Path,
    tag_name: &str,
    commit_oid_str: &str,
    message: Option<&str>,
    force: bool,
) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    let oid = git2::Oid::from_str(commit_oid_str)?;
    let target_object = repo.find_object(oid, Some(git2::ObjectType::Commit))?;
    if let Some(msg) = message.filter(|m| !m.trim().is_empty()) {
        let tagger_sig = repo.signature();
        let default_sig;
        let tagger = match &tagger_sig {
            Ok(s) => s,
            Err(_) => {
                if let Ok(sig) = git2::Signature::now("Gitwig", "gitwig@local") {
                    default_sig = sig;
                    &default_sig
                } else {
                    return Err(git2::Error::from_str("Failed to create signature"));
                }
            }
        };
        repo.tag(tag_name, &target_object, tagger, msg, force)?;
    } else {
        repo.tag_lightweight(tag_name, &target_object, force)?;
    }
    Ok(())
}

/// Checks if a local tag exists in the repository.
pub fn tag_exists(repo_path: &Path, tag_name: &str) -> bool {
    if let Ok(repo) = Repository::open(repo_path) {
        let ref_name = format!("refs/tags/{}", tag_name);
        repo.find_reference(&ref_name).is_ok()
    } else {
        false
    }
}

/// Deletes a local tag.
pub fn delete_tag(repo_path: &Path, tag_name: &str) -> Result<(), git2::Error> {
    let repo = Repository::open(repo_path)?;
    repo.tag_delete(tag_name)?;
    Ok(())
}

/// Deletes a tag on the remote.
pub fn delete_remote_tag(
    repo_path: &Path,
    remote_name: &str,
    tag_name: &str,
    timeout: Duration,
) -> Result<(), Box<dyn std::error::Error>> {
    let safe_remote = safe_ref(remote_name)?;
    let safe_tag = safe_ref(tag_name)?;
    let mut cmd = git_command();
    cmd.arg("push").arg(safe_remote).arg("--delete").arg(safe_tag).current_dir(repo_path);
    let output = run_git_with_timeout(cmd, timeout)?;
    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(err.into());
    }
    Ok(())
}

pub fn checkout_tag(repo_path: &Path, tag_name: &str) -> Result<(), git2::Error> {
    let safe_tag = safe_ref(tag_name).map_err(|e| git2::Error::from_str(&e))?;
    let output = git_command()
        .arg("checkout")
        .arg(safe_tag)
        .current_dir(repo_path)
        .output()
        .map_err(|e| git2::Error::from_str(&e.to_string()))?;

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(git2::Error::from_str(&err));
    }
    Ok(())
}

/// Helper to run `git ls-remote --tags` and return parsed tag information.
pub fn get_remote_tags(
    repo_path: &Path,
    remote_name: &str,
    timeout: Duration,
) -> Result<Vec<BranchInfo>, Box<dyn std::error::Error>> {
    let safe_remote = safe_ref(remote_name)?;
    let mut cmd = git_command();
    cmd.arg("ls-remote").arg("--tags").arg(safe_remote).current_dir(repo_path);
    let output = run_git_with_timeout(cmd, timeout)?;

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(err.into());
    }

    let stdout = String::from_utf8_lossy(&output.stdout);
    let repo = git2::Repository::open(repo_path)?;
    let mut tags_map = std::collections::HashMap::new();

    for line in stdout.lines() {
        let parts: Vec<&str> = line.split_whitespace().collect();
        if parts.len() >= 2 {
            let sha = parts[0];
            let ref_name = parts[1];
            if ref_name.starts_with("refs/tags/") {
                let is_peeled = ref_name.ends_with("^{}");
                let clean_ref = if is_peeled {
                    safe_sha_slice(ref_name, ref_name.len().saturating_sub(3))
                } else {
                    ref_name
                };
                let tag_name = clean_ref.strip_prefix("refs/tags/").unwrap_or(clean_ref);
                let short_sha = safe_sha_slice(sha, 7);

                // Try to resolve the summary locally
                let mut short_message = String::new();
                if let Ok(oid) = git2::Oid::from_str(sha) {
                    if let Ok(commit) = repo.find_commit(oid) {
                        if let Ok(Some(summary)) = commit.summary() {
                            short_message = summary.to_string();
                        }
                    }
                }
                if short_message.is_empty() {
                    short_message = "(not fetched)".to_string();
                }

                let sanitized_tag = sanitize_text(tag_name);
                let sanitized_msg = sanitize_text(&short_message);

                if is_peeled {
                    tags_map.insert(sanitized_tag, (short_sha.to_string(), sanitized_msg));
                } else {
                    tags_map
                        .entry(sanitized_tag)
                        .or_insert_with(|| (short_sha.to_string(), sanitized_msg));
                }
            }
        }
    }

    let mut tags = Vec::new();
    for (name, (short_sha, short_message)) in tags_map {
        tags.push(BranchInfo { name, is_head: false, short_sha, short_message });
    }
    tags.sort_by(|a, b| b.name.cmp(&a.name));
    Ok(tags)
}

pub fn serialize_tags(tags: &[BranchInfo]) -> String {
    let mut s = String::new();
    for tag in tags {
        s.push_str(&format!("{}|{}|{}\n", tag.name, tag.short_sha, tag.short_message));
    }
    s
}

pub fn deserialize_tags(s: &str) -> Vec<BranchInfo> {
    let mut tags = Vec::new();
    for line in s.lines() {
        let parts: Vec<&str> = line.split('|').collect();
        if parts.len() >= 3 {
            tags.push(BranchInfo {
                name: parts[0].to_string(),
                is_head: false,
                short_sha: parts[1].to_string(),
                short_message: parts[2].to_string(),
            });
        }
    }
    tags
}

pub fn delete_stash(repo_path: &Path, index: usize) -> Result<(), git2::Error> {
    let mut repo = Repository::open(repo_path)?;
    repo.stash_drop(index)?;
    Ok(())
}

pub fn apply_stash(repo_path: &Path, index: usize) -> Result<(), String> {
    let stash_ref = format!("stash@{{{}}}", index);
    let output = git_command()
        .arg("stash")
        .arg("apply")
        .arg(&stash_ref)
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if !output.status.success() {
        let err_msg = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(err_msg);
    }
    Ok(())
}

pub fn save_stash(
    repo_path: &Path,
    message: &str,
    include_untracked: bool,
    keep_index: bool,
) -> Result<(), String> {
    let mut cmd = git_command();
    cmd.arg("stash").arg("push");

    if include_untracked {
        cmd.arg("--include-untracked");
    }
    if keep_index {
        cmd.arg("--keep-index");
    }

    if !message.is_empty() {
        cmd.arg("-m").arg(message);
    }

    let output = cmd.current_dir(repo_path).output().map_err(|e| e.to_string())?;

    if !output.status.success() {
        let err_msg = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(err_msg);
    }
    Ok(())
}

pub fn get_latest_change_time(item: &str) -> u64 {
    let path = expand_tilde(item);
    if !path.exists() {
        return 0;
    }

    if path.join(".git").exists() {
        if let Ok(repo) = Repository::open(&path) {
            if let Ok(head) = repo.head() {
                if let Ok(commit) = head.peel_to_commit() {
                    return commit.time().seconds() as u64;
                }
            }
        }
    }

    if let Ok(meta) = std::fs::metadata(&path) {
        if let Ok(modified) = meta.modified() {
            if let Ok(duration) = modified.duration_since(std::time::UNIX_EPOCH) {
                return duration.as_secs();
            }
        }
    }
    0
}

pub fn get_last_commit_message(repo_path: &Path) -> Option<String> {
    if let Ok(repo) = Repository::open(repo_path) {
        if let Ok(head) = repo.head() {
            if let Ok(commit) = head.peel_to_commit() {
                if let Ok(msg) = commit.message() {
                    return Some(msg.to_string());
                }
            }
        }
    }
    None
}

pub fn commit_amend(repo_path: &Path, message: &str) -> Result<(), String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let head = repo.head().map_err(|e| format!("No HEAD commit to amend: {}", e))?;
    let head_commit = head.peel_to_commit().map_err(|e| e.to_string())?;

    let mut index = repo.index().map_err(|e| e.to_string())?;
    let tree_id = index.write_tree().map_err(|e| e.to_string())?;
    let tree = repo.find_tree(tree_id).map_err(|e| e.to_string())?;

    let signature = repo
        .signature()
        .map_err(|e| format!("Failed to get signature. Check user.name/email config: {}", e))?;

    head_commit
        .amend(Some("HEAD"), None, Some(&signature), None, Some(message), Some(&tree))
        .map_err(|e| e.to_string())?;

    Ok(())
}

// ── Merge Conflict Helpers ──────────────────────────────────────────────────

/// Returns `true` when `.git/MERGE_HEAD` exists — i.e. a merge is in progress.
/// Cheap file-existence check, no libgit2 required.
pub fn is_merging(repo_path: &Path) -> bool {
    repo_path.join(".git/MERGE_HEAD").exists()
}

/// Returns the conflict-marker diff for a conflicted file by parsing the file on disk.
/// Colorizes conflict blocks using DiffLineKind variants.
pub fn get_conflict_markers_diff(repo_path: &Path, file_path: &str) -> Vec<DiffLine> {
    let full_path = repo_path.join(file_path);
    let content = match std::fs::read_to_string(&full_path) {
        Ok(s) => s,
        Err(_) => return Vec::new(),
    };

    let mut lines = Vec::new();
    let mut in_ours = false;
    let mut in_theirs = false;

    for line in content.lines() {
        if line.starts_with("<<<<<<<") {
            in_ours = true;
            in_theirs = false;
            lines.push(DiffLine {
                kind: DiffLineKind::ConflictSeparator,
                content: line.to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            });
        } else if line.starts_with("=======") {
            in_ours = false;
            in_theirs = true;
            lines.push(DiffLine {
                kind: DiffLineKind::ConflictSeparator,
                content: line.to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            });
        } else if line.starts_with(">>>>>>>") {
            in_ours = false;
            in_theirs = false;
            lines.push(DiffLine {
                kind: DiffLineKind::ConflictSeparator,
                content: line.to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            });
        } else if in_ours {
            lines.push(DiffLine {
                kind: DiffLineKind::ConflictOurs,
                content: line.to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            });
        } else if in_theirs {
            lines.push(DiffLine {
                kind: DiffLineKind::ConflictTheirs,
                content: line.to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            });
        } else {
            lines.push(DiffLine {
                kind: DiffLineKind::Context,
                content: line.to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            });
        }
    }
    lines
}

/// Accept the OURS (HEAD) version of a conflicted file.
/// Equivalent to: git checkout --ours <file> && git add <file>
pub fn resolve_ours(repo_path: &Path, file_path: &str) -> Result<(), String> {
    let output1 = git_command()
        .args(["checkout", "--ours", file_path])
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;
    if !output1.status.success() {
        return Err(String::from_utf8_lossy(&output1.stderr).to_string());
    }
    stage_file(repo_path, file_path)?;
    Ok(())
}

/// Accept the THEIRS (incoming) version of a conflicted file.
/// Equivalent to: git checkout --theirs <file> && git add <file>
pub fn resolve_theirs(repo_path: &Path, file_path: &str) -> Result<(), String> {
    let output1 = git_command()
        .args(["checkout", "--theirs", file_path])
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;
    if !output1.status.success() {
        return Err(String::from_utf8_lossy(&output1.stderr).to_string());
    }
    stage_file(repo_path, file_path)?;
    Ok(())
}

/// Mark the file as resolved (stage it) after manual edits.
pub fn mark_resolved(repo_path: &Path, file_path: &str) -> Result<(), String> {
    stage_file(repo_path, file_path)
}

/// Resolve a specific conflict hunk inside a file (Ours vs Theirs).
/// Replaces the hunk at index `hunk_idx` in the file on disk.
/// If no more conflicts remain in the file, it automatically stages the file.
pub fn resolve_conflict_hunk(
    repo_path: &Path,
    file_path: &str,
    hunk_idx: usize,
    accept_ours: bool,
) -> Result<(), String> {
    let full_path = repo_path.join(file_path);
    let content = std::fs::read_to_string(&full_path).map_err(|e| e.to_string())?;

    let mut new_lines = Vec::new();
    let mut lines_iter = content.lines().peekable();
    let mut current_hunk_idx = 0;

    while let Some(line) = lines_iter.next() {
        if line.starts_with("<<<<<<<") {
            let mut ours_block = Vec::new();
            let mut theirs_block = Vec::new();

            // Read ours block (until =======)
            let mut found_separator = false;
            while let Some(&next_line) = lines_iter.peek() {
                if next_line.starts_with("=======") {
                    lines_iter.next(); // consume =======
                    found_separator = true;
                    break;
                }
                if let Some(line) = lines_iter.next() {
                    ours_block.push(line.to_string());
                }
            }

            // Read theirs block (until >>>>>>>)
            let mut found_end = false;
            let mut end_line_marker = ">>>>>>>".to_string();
            while let Some(&next_line) = lines_iter.peek() {
                if next_line.starts_with(">>>>>>>") {
                    if let Some(marker) = lines_iter.next() {
                        end_line_marker = marker.to_string(); // consume >>>>>>>
                    }
                    found_end = true;
                    break;
                }
                if let Some(line) = lines_iter.next() {
                    theirs_block.push(line.to_string());
                }
            }

            if current_hunk_idx == hunk_idx {
                if accept_ours {
                    new_lines.extend(ours_block);
                } else {
                    new_lines.extend(theirs_block);
                }
            } else {
                new_lines.push(line.to_string());
                new_lines.extend(ours_block);
                if found_separator {
                    new_lines.push("=======".to_string());
                }
                new_lines.extend(theirs_block);
                if found_end {
                    new_lines.push(end_line_marker);
                }
            }

            current_hunk_idx += 1;
        } else {
            new_lines.push(line.to_string());
        }
    }

    let mut new_content = new_lines.join("\n");
    if content.ends_with('\n') && !new_content.ends_with('\n') {
        new_content.push('\n');
    }
    std::fs::write(&full_path, new_content).map_err(|e| e.to_string())?;

    // Check if any conflict markers remain in the file
    let updated_content = std::fs::read_to_string(&full_path).map_err(|e| e.to_string())?;
    let has_conflict_markers = updated_content
        .lines()
        .any(|l| l.starts_with("<<<<<<<") || l.starts_with("=======") || l.starts_with(">>>>>>>"));

    if !has_conflict_markers {
        stage_file(repo_path, file_path)?;
    }

    Ok(())
}

/// Abort the in-progress merge.
pub fn abort_merge(repo_path: &Path) -> Result<(), String> {
    let output = git_command()
        .args(["merge", "--abort"])
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;
    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(())
}

/// Continue the merge after conflicts are resolved.
pub fn continue_merge(repo_path: &Path) -> Result<(), String> {
    let output = git_command()
        .args(["merge", "--continue"])
        .env("GIT_EDITOR", "true")
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;
    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(())
}

/// Returns the upstream tracking remote name for a branch, if configured.
pub fn get_branch_upstream_remote(repo_path: &Path, branch_name: &str) -> Option<String> {
    let repo = Repository::open(repo_path).ok()?;
    let branch = repo.find_branch(branch_name, git2::BranchType::Local).ok()?;
    let _upstream = branch.upstream().ok()?;
    let local_ref = branch.get().name().ok()?;
    let remote_buf = repo.branch_upstream_remote(local_ref).ok()?;
    remote_buf.as_str().ok().map(|s| s.to_string())
}

/// Returns whether the specified branch has a configured upstream tracking branch.
pub fn has_upstream_remote(repo_path: &Path, branch_name: &str) -> bool {
    get_branch_upstream_remote(repo_path, branch_name).is_some()
}

/// Finds the remote target for pushing a branch. Returns `(remote_name, set_upstream)`.
pub fn get_branch_push_target(repo_path: &Path, branch_name: &str) -> Option<(String, bool)> {
    let repo = Repository::open(repo_path).ok()?;
    let branch = repo.find_branch(branch_name, git2::BranchType::Local).ok()?;
    if branch.upstream().is_ok() {
        if let Ok(local_ref) = branch.get().name() {
            if let Ok(remote_buf) = repo.branch_upstream_remote(local_ref) {
                if let Ok(name) = remote_buf.as_str() {
                    return Some((name.to_string(), false));
                }
            }
        }
    }
    let remotes = repo.remotes().ok()?;
    let first_remote = remotes.iter().next()?.ok()??.to_string();
    Some((first_remote, true))
}

/// Returns whether the specified commit OID has no parents (i.e. it is the root commit).
pub fn is_root_commit(repo_path: &Path, commit_oid: &str) -> bool {
    if let Ok(repo) = Repository::open(repo_path) {
        if let Ok(oid) = git2::Oid::from_str(commit_oid) {
            if let Ok(commit) = repo.find_commit(oid) {
                return commit.parent_count() == 0;
            }
        }
    }
    false
}

pub fn load_tab_worktrees(repo_path: &Path) -> Result<Vec<WorktreeInfo>, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut worktrees_list = Vec::new();
    if let Ok(worktree_names) = repo.worktrees() {
        for name in worktree_names.iter() {
            let Ok(Some(wt_name)) = name else { continue };
            if let Ok(wt) = repo.find_worktree(wt_name) {
                let path = wt.path().to_path_buf();
                let mut branch = None;
                if let Ok(wt_repo) = Repository::open(&path) {
                    if let Ok(head) = wt_repo.head() {
                        branch = head.shorthand().map(String::from).ok();
                    }
                }

                let mut is_locked = false;
                let mut lock_reason = None;
                if let Ok(git2::WorktreeLockStatus::Locked(reason_opt)) = wt.is_locked() {
                    is_locked = true;
                    if let Some(reason) = reason_opt {
                        if !reason.is_empty() {
                            lock_reason = Some(reason);
                        }
                    }
                }

                worktrees_list.push(WorktreeInfo {
                    name: wt_name.to_string(),
                    path,
                    branch,
                    is_locked,
                    lock_reason,
                });
            }
        }
    }
    Ok(worktrees_list)
}

/// Adds a worktree at `wt_path` for `branch`. An existing branch, tag or
/// commit is checked out there, and a branch that only exists on one remote
/// becomes a local branch tracking it (git's own guess). Any other name
/// creates that branch, at HEAD, for the new worktree. Returns whether a new
/// branch was created.
pub fn worktree_add(repo_path: &Path, branch: &str, wt_path: &Path) -> Result<bool, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let exists = repo.revparse_single(&format!("{}^{{commit}}", branch)).is_ok();
    let on_one_remote = || {
        let Ok(remotes) = repo.remotes() else { return false };
        let on = remotes.iter().flatten().flatten().filter(|remote| {
            repo.find_branch(&format!("{}/{}", remote, branch), git2::BranchType::Remote).is_ok()
        });
        on.count() == 1
    };
    let create = !exists && !on_one_remote();

    let mut cmd = git_command();
    cmd.arg("worktree").arg("add");
    if create {
        cmd.arg("-b").arg(branch);
    }
    cmd.arg("--").arg(wt_path);
    if !create {
        cmd.arg(branch);
    }
    let output = cmd.current_dir(repo_path).output().map_err(|e| e.to_string())?;

    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(create)
}

// The `git worktree lock` / `unlock` / `remove` helpers below take the
// worktree's checkout path (`WorktreeInfo::path`), never its admin name
// (`WorktreeInfo::name`, the directory under `.git/worktrees`). Git resolves a
// bare name as the trailing component of a worktree *path*, so the admin name
// of a moved worktree, or of one whose folder name another worktree shares,
// matches a different worktree or none at all: `remove` once force-deleted the
// wrong checkout that way.

pub fn worktree_lock(repo_path: &Path, worktree: &Path, reason: &str) -> Result<(), String> {
    let output = git_command()
        .arg("worktree")
        .arg("lock")
        .arg("--reason")
        .arg(reason)
        .arg(worktree)
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(())
}

pub fn worktree_unlock(repo_path: &Path, worktree: &Path) -> Result<(), String> {
    let output = git_command()
        .arg("worktree")
        .arg("unlock")
        .arg(worktree)
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(())
}

/// Removes the worktree checked out at `worktree`, deleting its directory.
///
/// Without `force`, git refuses a worktree with modified or untracked files, or
/// a locked one, and nothing is touched. With `force`, `--force` is passed
/// twice, which discards those changes and overrides the lock.
pub fn worktree_remove(repo_path: &Path, worktree: &Path, force: bool) -> Result<(), String> {
    let mut cmd = git_command();
    cmd.arg("worktree").arg("remove");
    if force {
        cmd.arg("--force").arg("--force");
    }
    let output = cmd.arg(worktree).current_dir(repo_path).output().map_err(|e| e.to_string())?;

    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(())
}

pub fn worktree_prune(repo_path: &Path) -> Result<(), String> {
    let output = git_command()
        .arg("worktree")
        .arg("prune")
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;

    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }
    Ok(())
}

pub fn load_tab_forge_issues(
    repo_path: &Path,
    assigned_only: bool,
) -> Result<Vec<ForgeIssue>, String> {
    let mut cmd = tool_command("gh");
    cmd.arg("issue").arg("list");
    if assigned_only {
        cmd.arg("--assignee").arg("@me");
    }
    cmd.arg("--limit")
        .arg("50")
        .arg("--json")
        .arg("number,title,state,author,assignees,url")
        .current_dir(repo_path);

    let output = match cmd.output() {
        Ok(out) => out,
        Err(e) => {
            return Err(format!(
                "GitHub CLI ('gh') not found or failed to execute: {}. Ensure 'gh' is installed and in your PATH.",
                e
            ));
        }
    };

    if !output.status.success() {
        let err_msg = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(format!(
            "GitHub CLI error: {}. Make sure you are authenticated (run 'gh auth login') and this is a GitHub repository.",
            err_msg
        ));
    }

    #[derive(serde::Deserialize)]
    struct GhAuthor {
        login: String,
    }

    #[derive(serde::Deserialize)]
    struct GhAssignee {
        login: String,
    }

    #[derive(serde::Deserialize)]
    struct GhIssue {
        number: u32,
        title: String,
        state: String,
        author: Option<GhAuthor>,
        assignees: Option<Vec<GhAssignee>>,
        url: String,
    }

    let raw_issues: Vec<GhIssue> = serde_json::from_slice(&output.stdout)
        .map_err(|e| format!("Failed to parse GitHub CLI response: {}", e))?;

    let issues = raw_issues
        .into_iter()
        .map(|item| {
            let author = item.author.map(|a| a.login).unwrap_or_else(|| "none".to_string());
            let assignees =
                item.assignees.unwrap_or_default().into_iter().map(|a| a.login).collect();
            ForgeIssue {
                number: item.number,
                title: item.title,
                state: item.state,
                author,
                assignees,
                url: item.url,
            }
        })
        .collect();

    Ok(issues)
}

#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
pub struct ForgePR {
    pub number: u32,
    pub title: String,
    pub state: String,
    pub author: String,
    pub assignees: Vec<String>,
    pub url: String,
    pub head_ref: String,
    pub head_ref_oid: String,
    pub body: String,
    pub status_checks: Vec<CIStatusCheck>,
    pub reviews: Vec<PRReview>,
}

#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
pub struct ForgePRComment {
    pub path: String,
    pub line: Option<u32>,
    pub body: String,
    pub author: String,
    pub commit_id: String,
}

#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
pub struct CIStatusCheck {
    pub name: String,
    pub state: Option<String>,
    pub status: Option<String>,
    pub conclusion: Option<String>,
}

#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
pub struct PRReview {
    pub author: String,
    pub body: String,
    pub state: String,
}

pub fn load_tab_forge_prs(repo_path: &Path) -> Result<Vec<ForgePR>, String> {
    let mut cmd = tool_command("gh");
    cmd.arg("pr")
        .arg("list")
        .arg("--limit")
        .arg("50")
        .arg("--json")
        .arg("number,title,state,author,assignees,url,headRefName,headRefOid,statusCheckRollup,body,reviews")
        .current_dir(repo_path);

    let output = match cmd.output() {
        Ok(out) => out,
        Err(e) => {
            return Err(format!(
                "GitHub CLI ('gh') not found or failed to execute: {}. Ensure 'gh' is installed and in your PATH.",
                e
            ));
        }
    };

    if !output.status.success() {
        let err_msg = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(format!(
            "GitHub CLI error: {}. Make sure you are authenticated (run 'gh auth login') and this is a GitHub repository.",
            err_msg
        ));
    }

    parse_forge_prs(&output.stdout)
}

/// Parses the JSON `gh pr list --json ...` prints (see `load_tab_forge_prs`).
fn parse_forge_prs(json: &[u8]) -> Result<Vec<ForgePR>, String> {
    #[derive(serde::Deserialize)]
    struct GhAuthor {
        login: String,
    }

    #[derive(serde::Deserialize)]
    struct GhAssignee {
        login: String,
    }

    #[derive(serde::Deserialize)]
    struct GhReview {
        author: Option<GhAuthor>,
        body: String,
        state: String,
    }

    // `statusCheckRollup` mixes two kinds of entry: check runs (GitHub
    // Actions and other apps) carry `name`, `status` and `conclusion`, while
    // commit statuses (`StatusContext`, e.g. an external CI) carry `context`
    // and `state` and no `name`. A required `name` failed the whole list.
    #[derive(serde::Deserialize)]
    struct GhStatusCheck {
        name: Option<String>,
        context: Option<String>,
        state: Option<String>,
        status: Option<String>,
        conclusion: Option<String>,
    }

    #[derive(serde::Deserialize)]
    struct GhPR {
        number: u32,
        title: String,
        state: String,
        author: Option<GhAuthor>,
        assignees: Option<Vec<GhAssignee>>,
        url: String,
        #[serde(rename = "headRefName")]
        head_ref_name: String,
        #[serde(rename = "headRefOid")]
        head_ref_oid: String,
        body: String,
        #[serde(rename = "statusCheckRollup")]
        status_check_rollup: Option<Vec<GhStatusCheck>>,
        reviews: Option<Vec<GhReview>>,
    }

    let raw_prs: Vec<GhPR> = serde_json::from_slice(json)
        .map_err(|e| format!("Failed to parse GitHub CLI response: {}", e))?;

    let prs = raw_prs
        .into_iter()
        .map(|item| {
            let author = item.author.map(|a| a.login).unwrap_or_else(|| "none".to_string());
            let assignees =
                item.assignees.unwrap_or_default().into_iter().map(|a| a.login).collect();
            let status_checks = item
                .status_check_rollup
                .unwrap_or_default()
                .into_iter()
                .map(|c| {
                    // gh reports a check run that is still going as `conclusion: ""`.
                    let non_empty = |v: Option<String>| v.filter(|s| !s.is_empty());
                    CIStatusCheck {
                        name: c.name.or(c.context).unwrap_or_else(|| "unnamed check".to_string()),
                        state: non_empty(c.state),
                        status: non_empty(c.status),
                        conclusion: non_empty(c.conclusion),
                    }
                })
                .collect();
            let reviews = item
                .reviews
                .unwrap_or_default()
                .into_iter()
                .map(|r| PRReview {
                    author: r.author.map(|a| a.login).unwrap_or_else(|| "none".to_string()),
                    body: r.body,
                    state: r.state,
                })
                .collect();

            ForgePR {
                number: item.number,
                title: item.title,
                state: item.state,
                author,
                assignees,
                url: item.url,
                head_ref: item.head_ref_name,
                head_ref_oid: item.head_ref_oid,
                body: item.body,
                status_checks,
                reviews,
            }
        })
        .collect();

    Ok(prs)
}

pub fn load_pr_comments(repo_path: &Path, pr_number: u32) -> Result<Vec<ForgePRComment>, String> {
    // GitHub pages review comments 30 at a time; ask for the largest page and
    // let gh follow the rest.
    let mut cmd = tool_command("gh");
    cmd.arg("api")
        .arg(format!("repos/:owner/:repo/pulls/{}/comments?per_page=100", pr_number))
        .arg("--paginate")
        .current_dir(repo_path);

    let output = match cmd.output() {
        Ok(out) => out,
        Err(e) => return Err(format!("Failed to execute gh: {}", e)),
    };

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(format!("Failed to load PR comments: {}", err));
    }

    parse_pr_comments(&output.stdout)
}

/// Parses `gh api --paginate` output for PR review comments: one JSON array
/// per page, printed back to back (`[...][...]`).
fn parse_pr_comments(json: &[u8]) -> Result<Vec<ForgePRComment>, String> {
    #[derive(serde::Deserialize)]
    struct GhUser {
        login: String,
    }

    #[derive(serde::Deserialize)]
    struct GhPRComment {
        path: String,
        line: Option<u32>,
        body: String,
        user: Option<GhUser>,
        #[serde(rename = "commit_id")]
        commit_id: String,
    }

    let mut comments = Vec::new();
    for page in serde_json::Deserializer::from_slice(json).into_iter::<Vec<GhPRComment>>() {
        let page = page.map_err(|e| format!("Failed to parse PR comments: {}", e))?;
        comments.extend(page.into_iter().map(|c| ForgePRComment {
            path: c.path,
            line: c.line,
            body: c.body,
            author: c.user.map(|u| u.login).unwrap_or_else(|| "none".to_string()),
            commit_id: c.commit_id,
        }));
    }
    Ok(comments)
}

/// The `gh api` arguments that post `body` as a review comment on `line` of
/// `path` at `commit_id`. Text fields use `-f` (sent verbatim): `-F` reads a
/// value starting with `@` as a file name, sends `123` or `true` as a number or
/// boolean, and fills `{owner}`-style placeholders, so a comment such as
/// "@alice please look" failed. Only `line` uses `-F`, to be sent as a number.
fn pr_line_comment_args(
    pr_number: u32,
    commit_id: &str,
    path: &str,
    line: u32,
    body: &str,
) -> Vec<String> {
    vec![
        "api".to_string(),
        format!("repos/:owner/:repo/pulls/{}/comments", pr_number),
        "--method".to_string(),
        "POST".to_string(),
        "-f".to_string(),
        format!("body={}", body),
        "-f".to_string(),
        format!("commit_id={}", commit_id),
        "-f".to_string(),
        format!("path={}", path),
        "-F".to_string(),
        format!("line={}", line),
        "-f".to_string(),
        "side=RIGHT".to_string(),
    ]
}

pub fn add_pr_line_comment(
    repo_path: &Path,
    pr_number: u32,
    commit_id: &str,
    path: &str,
    line: u32,
    body: &str,
) -> Result<(), String> {
    let mut cmd = tool_command("gh");
    cmd.args(pr_line_comment_args(pr_number, commit_id, path, line, body)).current_dir(repo_path);

    let output = match cmd.output() {
        Ok(out) => out,
        Err(e) => return Err(format!("Failed to execute gh: {}", e)),
    };

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(format!("Failed to add PR comment: {}", err));
    }
    Ok(())
}

pub fn checkout_pr_branch(repo_path: &Path, pr_number: u32) -> Result<String, String> {
    let mut cmd = tool_command("gh");
    cmd.arg("pr").arg("checkout").arg(pr_number.to_string()).current_dir(repo_path);

    let output = cmd.output().map_err(|e| e.to_string())?;
    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
        return Err(format!("Failed to checkout PR branch: {}", err));
    }
    Ok(format!("Checked out branch for PR #{}", pr_number))
}

/// Switches to the branch for GitHub issue `issue_number`. In order:
///
/// 1. the branch linked to the issue on GitHub (its Development section, or
///    `gh issue develop`), when there is exactly one;
/// 2. the one local branch, else the one remote-tracking branch, whose name
///    carries the number as a token of its own (see [`branch_names_issue`]);
/// 3. a new `issue-<number>` branch at HEAD.
///
/// Several candidates at any step are reported instead of guessed between.
/// The linked-branch lookup used to ask `gh issue view` for a
/// `developmentBranch` field gh does not have, so it always fell through to a
/// substring match that took issue #2 to `issue-12-login` and #1 to `v1.2`.
pub fn resolve_and_checkout_issue_branch(
    repo_path: &Path,
    issue_number: u32,
) -> Result<String, String> {
    // No GitHub remote, gh missing or signed out, or a server without linked
    // branches: fall back to matching branch names.
    let linked = linked_issue_branches(repo_path, issue_number).unwrap_or_default();
    match linked.as_slice() {
        [] => checkout_issue_branch_by_name(repo_path, issue_number),
        [name] => checkout_linked_issue_branch(repo_path, issue_number, name),
        many => Err(format!(
            "Issue #{} has {} linked branches ({}); check one out from the Branches tab",
            issue_number,
            many.len(),
            many.join(", ")
        )),
    }
}

/// Names of the branches linked to the issue on GitHub.
fn linked_issue_branches(repo_path: &Path, issue_number: u32) -> Result<Vec<String>, String> {
    const QUERY: &str = "query($owner: String!, $repo: String!, $number: Int!) { \
        repository(owner: $owner, name: $repo) { issue(number: $number) { \
        linkedBranches(first: 10) { nodes { ref { name } } } } } }";
    // `-F` fills gh's `{owner}` / `{repo}` placeholders from the current
    // repository and sends `number` as an integer.
    let output = tool_command("gh")
        .args(["api", "graphql", "-f"])
        .arg(format!("query={}", QUERY))
        .args(["-F", "owner={owner}", "-F", "repo={repo}", "-F"])
        .arg(format!("number={}", issue_number))
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;
    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).trim().to_string());
    }
    parse_linked_branches(&output.stdout)
}

/// Parses the `gh api graphql` response of [`linked_issue_branches`]: the
/// distinct branch names, skipping links whose branch was deleted.
fn parse_linked_branches(json: &[u8]) -> Result<Vec<String>, String> {
    #[derive(serde::Deserialize)]
    struct GhRef {
        name: String,
    }
    #[derive(serde::Deserialize)]
    struct GhLinkedBranch {
        #[serde(rename = "ref")]
        git_ref: Option<GhRef>,
    }
    #[derive(serde::Deserialize)]
    struct GhLinkedBranches {
        nodes: Vec<Option<GhLinkedBranch>>,
    }
    #[derive(serde::Deserialize)]
    struct GhIssue {
        #[serde(rename = "linkedBranches")]
        linked_branches: GhLinkedBranches,
    }
    #[derive(serde::Deserialize)]
    struct GhRepository {
        issue: Option<GhIssue>,
    }
    #[derive(serde::Deserialize)]
    struct GhData {
        repository: Option<GhRepository>,
    }
    #[derive(serde::Deserialize)]
    struct GhResponse {
        data: GhData,
    }

    let response: GhResponse = serde_json::from_slice(json)
        .map_err(|e| format!("Failed to parse linked branches: {}", e))?;
    let mut names: Vec<String> = Vec::new();
    let links = response.data.repository.and_then(|r| r.issue).map(|i| i.linked_branches.nodes);
    for name in links.into_iter().flatten().flatten().filter_map(|n| n.git_ref).map(|r| r.name) {
        if !names.contains(&name) {
            names.push(name);
        }
    }
    Ok(names)
}

/// Whether `branch` names issue `issue_number`: the number appears as a token
/// of its own, after the start of the name or one of `-` `_` `/` `#`, and
/// before its end or one of `-` `_` `/`. So `issue-12-login`, `12-fix` and
/// `fix/12` name #12, while `v1.2`, `issue-123` and `issue12` do not.
pub fn branch_names_issue(branch: &str, issue_number: u32) -> bool {
    let number = issue_number.to_string();
    branch.match_indices(&number).any(|(at, _)| {
        let before = branch[..at].chars().next_back();
        let after = branch[at + number.len()..].chars().next();
        before.is_none_or(|c| matches!(c, '-' | '_' | '/' | '#'))
            && after.is_none_or(|c| matches!(c, '-' | '_' | '/'))
    })
}

/// `git checkout <args>`, with git's message as the error.
fn run_checkout(repo_path: &Path, args: &[&str]) -> Result<(), String> {
    let output = git_command()
        .arg("checkout")
        .args(args)
        .current_dir(repo_path)
        .output()
        .map_err(|e| e.to_string())?;
    if !output.status.success() {
        return Err(String::from_utf8_lossy(&output.stderr).trim().to_string());
    }
    Ok(())
}

/// Checks out `branch`, linked to the issue on GitHub: the local branch, or a
/// new one tracking the single remote that has it. Only branches that exist are
/// passed to `git checkout`, as `<branch> --`: a bare name that is no branch is
/// read as a path, and would discard the local changes under it.
fn checkout_linked_issue_branch(
    repo_path: &Path,
    issue_number: u32,
    branch: &str,
) -> Result<String, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    if repo.find_branch(branch, git2::BranchType::Local).is_ok() {
        run_checkout(repo_path, &[branch, "--"])?;
        return Ok(format!("Checked out '{}', linked to issue #{}", branch, issue_number));
    }
    let mut on_remotes = Vec::new();
    if let Ok(remotes) = repo.remotes() {
        for remote in remotes.iter().flatten().flatten() {
            let tracking = format!("{}/{}", remote, branch);
            if repo.find_branch(&tracking, git2::BranchType::Remote).is_ok() {
                on_remotes.push(tracking);
            }
        }
    }
    match on_remotes.as_slice() {
        [tracking] => {
            run_checkout(repo_path, &["--track", tracking])?;
            Ok(format!(
                "Checked out '{}' from '{}', linked to issue #{}",
                branch, tracking, issue_number
            ))
        }
        [] => Err(format!(
            "Issue #{} is linked to branch '{}', which is not in this clone yet; fetch it first",
            issue_number, branch
        )),
        many => Err(format!(
            "Issue #{} is linked to branch '{}', found on several remotes ({}); check one out from the Branches tab",
            issue_number,
            branch,
            many.join(", ")
        )),
    }
}

/// Steps 2 and 3 of [`resolve_and_checkout_issue_branch`]: a branch whose name
/// names the issue, else a new `issue-<number>` branch at HEAD.
pub fn checkout_issue_branch_by_name(
    repo_path: &Path,
    issue_number: u32,
) -> Result<String, String> {
    let repo = Repository::open(repo_path).map_err(|e| e.to_string())?;
    let mut local = Vec::new();
    let mut remote = Vec::new();
    for (branch, kind) in repo.branches(None).map_err(|e| e.to_string())?.flatten() {
        let Ok(Some(name)) = branch.name() else { continue };
        match kind {
            git2::BranchType::Local => {
                if branch_names_issue(name, issue_number) {
                    local.push(name.to_string());
                }
            }
            git2::BranchType::Remote => {
                // Match on the branch part, so the remote's own name cannot.
                let Some((_, short)) = name.split_once('/') else { continue };
                if short != "HEAD" && branch_names_issue(short, issue_number) {
                    remote.push(name.to_string());
                }
            }
        }
    }
    let ambiguous = |kind: &str, names: &[String]| {
        format!(
            "Several {} branches match issue #{} ({}); check one out from the Branches tab",
            kind,
            issue_number,
            names.join(", ")
        )
    };

    match local.as_slice() {
        [name] => {
            run_checkout(repo_path, &[name, "--"])?;
            return Ok(format!("Checked out matched local branch '{}'", name));
        }
        [] => {}
        many => return Err(ambiguous("local", many)),
    }
    match remote.as_slice() {
        [name] => {
            run_checkout(repo_path, &["--track", name])?;
            return Ok(format!("Checked out matched remote branch '{}'", name));
        }
        [] => {}
        many => return Err(ambiguous("remote", many)),
    }

    let new_branch_name = format!("issue-{}", issue_number);
    run_checkout(repo_path, &["-b", &new_branch_name])
        .map_err(|e| format!("Failed to create new branch: {}", e))?;
    Ok(format!("Created and switched to new branch '{}'", new_branch_name))
}

pub fn open_browser(url: &str) {
    #[cfg(target_os = "macos")]
    let _ = detached_command("open").arg(url).status();
    #[cfg(target_os = "windows")]
    let _ = detached_command("cmd").args(["/C", "start", url]).status();
    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
    let _ = detached_command("xdg-open").arg(url).status();
}

#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
pub struct ForgeIssue {
    pub number: u32,
    pub title: String,
    pub state: String,
    pub author: String,
    pub assignees: Vec<String>,
    pub url: String,
}

pub fn get_remote_url(repo_path: &Path, remote_name: &str) -> Option<String> {
    let remotes = load_tab_remotes(repo_path).ok()?;
    remotes.into_iter().find(|r| r.name == remote_name).map(|r| r.url)
}

pub fn get_default_remote_url(repo_path: &Path) -> Option<String> {
    let remotes = load_tab_remotes(repo_path).ok()?;
    remotes.into_iter().next().map(|r| r.url)
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic)]
// Test fixtures drive real `git` to build repositories; the TUI is not running here.
#[allow(clippy::disallowed_methods)]
mod tests {
    use super::*;
    use std::fs::File;

    #[test]
    fn test_match_pattern() {
        assert!(match_pattern("test.psd", "*.psd"));
        assert!(match_pattern("assets/test.psd", "*.psd"));
        assert!(match_pattern("assets/img.png", "assets/*.png"));
        assert!(match_pattern("src/app.rs", "src/*"));
        assert!(match_pattern("test.txt", "test.txt"));
        assert!(!match_pattern("src/app.rs", "*.psd"));
    }

    #[test]
    fn test_run_git_with_timeout_kills_a_hanging_child() {
        // Stand in for a remote that accepts the connection and never replies.
        let mut cmd = if cfg!(target_os = "windows") {
            let mut c = std::process::Command::new("cmd");
            c.arg("/c").arg("timeout").arg("/t").arg("30").arg("/nobreak");
            c
        } else {
            let mut c = std::process::Command::new("sleep");
            c.arg("30");
            c
        };
        cmd.stdin(std::process::Stdio::null());

        let started = Instant::now();
        let res = run_git_with_timeout(cmd, Duration::from_millis(300));
        let elapsed = started.elapsed();

        assert!(res.is_err(), "expected a timeout error, got {:?}", res);
        assert!(elapsed < Duration::from_secs(10), "child was not killed promptly: {:?}", elapsed);
    }

    #[test]
    fn test_get_lfs_info() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_lfs_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // 1. Create a dummy git repo with .git/lfs directory to bypass the short-circuit check
        let _repo = Repository::init(&temp_path).unwrap();
        let lfs_dir = temp_path.join(".git").join("lfs");
        std::fs::create_dir_all(&lfs_dir).unwrap();

        // 2. Call get_lfs_info (which will trigger is_lfs_installed and cover them)
        let (installed, tracked) = get_lfs_info(&temp_path);

        // Assert that get_lfs_info completed (whether lfs is installed on user's machine or not)
        assert!(tracked.is_empty());

        // 3. Create .gitattributes with lfs pattern
        let gitattributes_path = temp_path.join(".gitattributes");
        std::fs::write(&gitattributes_path, "*.bin filter=lfs diff=lfs merge=lfs").unwrap();

        let (installed2, _tracked2) = get_lfs_info(&temp_path);
        assert_eq!(installed, installed2);

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_comprehensive_gitwig_core_coverage() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_cov_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // 1. Repository init
        let repo = Repository::init(&temp_path).unwrap();

        // 2. Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // 3. Create dummy file & commit
        let file_path = temp_path.join("test.txt");
        std::fs::write(&file_path, "line 1\nline 2\nline 3\n").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "first commit").unwrap();

        let head_commit = repo.head().unwrap().peel_to_commit().unwrap();
        let head_oid = head_commit.id().to_string();

        // 4. Test diff & worktree helpers
        let _diffs = get_commit_file_diff(&temp_path, &head_oid, "test.txt");
        let _worktree_diff = get_worktree_file_diff(&temp_path, "test.txt", false);

        // 5. Test stage/unstage/discard all
        let _ = stage_all_changes(&temp_path);
        let _ = unstage_all_changes(&temp_path);

        std::fs::write(&file_path, "modified content").unwrap();
        let _ = discard_all_changes(&temp_path);

        // 6. Test LFS functions
        let _lfs_size = get_lfs_storage_size(&temp_path);

        // 7. Test load tab listings
        let _reflog = load_tab_reflog(&temp_path);
        let _tags = load_tab_tags(&temp_path);
        let _stashes = load_tab_stashes(&temp_path);
        let _submodules = load_tab_submodules(&temp_path);
        let _worktrees = load_tab_worktrees(&temp_path);

        // 8. Test remote add / delete
        let _ = remote_add(&temp_path, "upstream", "https://github.com/example/upstream.git");
        let _ = remote_delete(&temp_path, "upstream");

        // 9. Test worktree add / remove
        let wt_path = temp_path.join("wt-path");
        let _ = worktree_add(&temp_path, "new-branch", &wt_path);
        let _ = worktree_remove(&temp_path, &wt_path, true);

        // 10. Test tag delete
        let _ = delete_tag(&temp_path, "v1.0.0");

        // 11. Test stash apply & drop
        let _ = apply_stash(&temp_path, 0);
        let _ = delete_stash(&temp_path, 0);

        // 12. Test merge abort / continue
        let _ = abort_merge(&temp_path);
        let _ = continue_merge(&temp_path);

        // 13. Test merge conflict resolver helpers
        let _ = is_merging(&temp_path);
        let _ = get_conflict_markers_diff(&temp_path, "test.txt");
        let _ = resolve_ours(&temp_path, "test.txt");
        let _ = resolve_theirs(&temp_path, "test.txt");
        let _ = mark_resolved(&temp_path, "test.txt");

        // 14. Test push target & upstream
        let _target = get_branch_push_target(&temp_path, "master");
        let _target2 = get_branch_push_target(&temp_path, "main");

        // 15. Test inspect_detail & inspect_summary
        let _detail = inspect_detail(temp_path.to_str().unwrap(), 10, 10, true);
        let _summary = inspect_summary(temp_path.to_str().unwrap());

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_more_gitwig_core_coverage() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_cov2_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // 1. Repository init
        let repo = Repository::init(&temp_path).unwrap();

        // 2. Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // 3. Create dummy file & commit
        let file_path = temp_path.join("test.txt");
        std::fs::write(&file_path, "line 1\nline 2\nline 3\n").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "first commit").unwrap();

        let head_commit = repo.head().unwrap().peel_to_commit().unwrap();
        let head_oid = head_commit.id().to_string();

        // 4. Test checkout functions
        let _ = checkout_commit(&temp_path, &head_oid);
        let _ = checkout_local_branch(&temp_path, "master");
        let _ = checkout_remote_branch(&temp_path, "origin/master");
        let _ = checkout_tag(&temp_path, "v1.0.0");

        // 5. Test branch / tag creation & deletion
        let _ = create_branch(&temp_path, "new-branch-2");
        let _ = delete_local_branch(&temp_path, "new-branch-2");
        let _ = delete_remote_branch(&temp_path, "origin/new-branch-2");
        let _ = create_tag(&temp_path, "v1.0.0", &head_oid, None, false);
        let _ = delete_remote_tag(&temp_path, "origin", "v1.0.0", Duration::from_secs(5));
        let _ = get_remote_tags(&temp_path, "origin", Duration::from_secs(5));

        // 6. Test serialize & deserialize tags
        let tag_info = vec![BranchInfo {
            name: "v1.0.0".to_string(),
            is_head: false,
            short_sha: "abc1234".to_string(),
            short_message: "tag msg".to_string(),
        }];
        let serialized = serialize_tags(&tag_info);
        let deserialized = deserialize_tags(&serialized);
        assert_eq!(deserialized.len(), 1);
        assert_eq!(deserialized[0].name, "v1.0.0");

        // 7. Test history / blame / commit files
        let _ = get_file_history(&temp_path, "test.txt");
        let _ = get_file_blame(&temp_path, "test.txt");
        let _ = get_commit_files(&temp_path, &head_oid);

        // 8. Test load tab functions
        let _ = load_tab_files(&temp_path);
        let _ = load_tab_branches(&temp_path);
        let _ = load_tab_remotes(&temp_path);
        let _ = load_tab_overview(&temp_path, 10);

        // 9. Test load_tab_graph_stream
        let (tx, _rx) = std::sync::mpsc::channel();
        let _ = load_tab_graph_stream(
            &temp_path,
            10,
            true,
            temp_path.to_str().unwrap().to_string(),
            0,
            tx,
        );

        // 10. Test invalidate cache
        invalidate_ref_map_cache(&temp_path);

        // 11. Test Forge API/command execution fallbacks/errors
        let _ = load_tab_forge_issues(&temp_path, false);
        let _ = load_tab_forge_issues(&temp_path, true);
        let _ = load_tab_forge_prs(&temp_path);
        let _ = load_pr_comments(&temp_path, 1);
        let _ = add_pr_line_comment(&temp_path, 1, "sha", "file.txt", 10, "comment");

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_create_tag_annotated_and_force_update() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_tag_force_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        let repo = Repository::init(&temp_path).unwrap();
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        let file_path = temp_path.join("test.txt");
        std::fs::write(&file_path, "commit 1\n").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "commit 1").unwrap();

        let head_commit1 = repo.head().unwrap().peel_to_commit().unwrap();
        let oid1 = head_commit1.id().to_string();

        assert!(!tag_exists(&temp_path, "v1.0.1"));
        assert!(create_tag(&temp_path, "v1.0.1", &oid1, Some("Release v1.0.1"), false).is_ok());
        assert!(tag_exists(&temp_path, "v1.0.1"));

        // Creating without force should fail if tag exists
        std::fs::write(&file_path, "commit 2\n").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "commit 2").unwrap();

        let head_commit2 = repo.head().unwrap().peel_to_commit().unwrap();
        let oid2 = head_commit2.id().to_string();

        assert!(create_tag(&temp_path, "v1.0.1", &oid2, Some("Updated release"), false).is_err());

        // Creating with force = true should succeed and update tag
        assert!(create_tag(&temp_path, "v1.0.1", &oid2, Some("Updated release"), true).is_ok());

        let _ = std::fs::remove_dir_all(&temp_path);
    }

    use std::io::Write;

    #[test]
    fn test_commit_amend() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_amend_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file
        let file_path = temp_path.join("test.txt");
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "initial content").unwrap();

        // Stage and commit initial
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Verify message
        let msg = get_last_commit_message(&temp_path).unwrap();
        assert_eq!(msg, "initial commit");

        // Amend the commit message
        commit_amend(&temp_path, "amended commit").unwrap();

        // Verify amended message
        let amended_msg = get_last_commit_message(&temp_path).unwrap();
        assert_eq!(amended_msg, "amended commit");

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_commit_signatures_collection() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_sig_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file
        let file_path = temp_path.join("test.txt");
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "initial content").unwrap();

        // Stage and commit initial
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // 1. Test collect_signatures
        let sigs = collect_signatures(&temp_path, 0);
        assert_eq!(sigs.len(), 1);
        let head_oid = repo.head().unwrap().target().unwrap().to_string();
        let sig_status = sigs.get(&head_oid).unwrap();
        assert_eq!(sig_status, "N");

        // 2. Test collect_commits (files should be empty by default)
        let commits = collect_commits(&repo, 0, &temp_path, true).unwrap();
        assert_eq!(commits.len(), 1);
        assert_eq!(commits[0].signature_status, "N");
        assert!(commits[0].files.is_empty());

        // Test get_commit_files (lazy loading)
        let files = get_commit_files(&temp_path, &commits[0].oid).unwrap();
        assert_eq!(files.len(), 1);
        assert_eq!(files[0].path, "test.txt");
        assert_eq!(files[0].label, "N");

        // 3. Test collect_graph_lines
        let graph = collect_graph_lines(&temp_path, 1000);
        assert_eq!(graph.len(), 1);
        assert!(graph[0].commit.is_some());
        assert_eq!(graph[0].commit.as_ref().unwrap().signature_status, "N");

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    fn run_git(dir: &Path, args: &[&str]) {
        let out = git_command()
            .args(["-c", "user.name=Gitwig Test", "-c", "user.email=test@gitwig.invalid"])
            .args(["-c", "commit.gpgsign=false"])
            .args(args)
            .current_dir(dir)
            .output()
            .unwrap();
        assert!(out.status.success(), "git {:?}: {}", args, String::from_utf8_lossy(&out.stderr));
    }

    /// A fresh directory per call. `SystemTime` is only microsecond-precise on
    /// macOS, so parallel tests can read the same clock value; the process id and
    /// a per-process counter keep concurrent callers (and concurrent test runs)
    /// apart.
    fn unique_temp_dir(tag: &str) -> PathBuf {
        use std::sync::atomic::{AtomicUsize, Ordering};
        static NEXT: AtomicUsize = AtomicUsize::new(0);
        let dir = std::env::temp_dir().join(format!(
            "twig_test_{}_{}_{}_{}",
            tag,
            std::process::id(),
            NEXT.fetch_add(1, Ordering::Relaxed),
            SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&dir).unwrap();
        dir
    }

    /// A repo with one commit and `branches`, at `<root>/main`.
    fn repo_with_branches(root: &Path, branches: &[&str]) -> PathBuf {
        let main = root.join("main");
        std::fs::create_dir_all(&main).unwrap();
        run_git(&main, &["init", "-q"]);
        run_git(&main, &["commit", "-q", "--allow-empty", "-m", "init"]);
        for branch in branches {
            run_git(&main, &["branch", branch]);
        }
        main
    }

    fn worktree_at<'a>(worktrees: &'a [WorktreeInfo], suffix: &str) -> &'a WorktreeInfo {
        worktrees
            .iter()
            .find(|wt| wt.path.ends_with(suffix))
            .unwrap_or_else(|| panic!("no worktree at {} in {:?}", suffix, worktrees))
    }

    /// `git worktree` resolves a bare admin name as a path suffix. A worktree
    /// moved from `x/foo` to `x/renamed` keeps the admin name `foo`, which then
    /// names the unrelated `z/foo`: removing `x/renamed` by name force-deleted
    /// `z/foo` and its uncommitted work.
    #[test]
    fn test_worktree_helpers_act_on_the_checkout_path_not_the_admin_name() {
        let root = unique_temp_dir("wt_admin_name");
        let main = repo_with_branches(&root, &["a", "b"]);
        let (x_foo, x_renamed, z_foo) =
            (root.join("x/foo"), root.join("x/renamed"), root.join("z/foo"));
        run_git(&main, &["worktree", "add", "-q", &x_foo.to_string_lossy(), "a"]);
        run_git(
            &main,
            &["worktree", "move", &x_foo.to_string_lossy(), &x_renamed.to_string_lossy()],
        );
        run_git(&main, &["worktree", "add", "-q", &z_foo.to_string_lossy(), "b"]);
        std::fs::write(z_foo.join("precious.txt"), "uncommitted work").unwrap();

        let worktrees = load_tab_worktrees(&main).unwrap();
        let renamed = worktree_at(&worktrees, "x/renamed").clone();
        assert_eq!(renamed.name, "foo", "the moved worktree keeps its admin name");

        worktree_lock(&main, &renamed.path, "testing").unwrap();
        assert!(worktree_at(&load_tab_worktrees(&main).unwrap(), "x/renamed").is_locked);
        worktree_unlock(&main, &renamed.path).unwrap();
        assert!(!worktree_at(&load_tab_worktrees(&main).unwrap(), "x/renamed").is_locked);

        worktree_remove(&main, &renamed.path, false).unwrap();
        assert!(!x_renamed.exists(), "the selected worktree is removed");
        assert!(z_foo.join("precious.txt").exists(), "the other worktree is untouched");
        let _ = std::fs::remove_dir_all(&root);
    }

    /// `a` in the Worktrees tab could only check out an existing branch (its own
    /// example, `main`, always failed). A name that resolves to nothing now
    /// creates that branch for the new worktree.
    #[test]
    fn test_worktree_add_checks_out_existing_refs_and_creates_new_branches() {
        let root = unique_temp_dir("wt_add");
        let main = repo_with_branches(&root, &["existing"]);
        run_git(&main, &["tag", "v1"]);
        let branch_of = |wt: &Path| {
            let out =
                git_command().args(["rev-parse", "--abbrev-ref", "HEAD"]).current_dir(wt).output();
            String::from_utf8_lossy(&out.unwrap().stdout).trim().to_string()
        };

        assert!(!worktree_add(&main, "existing", &root.join("a")).unwrap());
        assert_eq!(branch_of(&root.join("a")), "existing");
        assert!(worktree_add(&main, "feature/new", &root.join("b")).unwrap(), "created");
        assert_eq!(branch_of(&root.join("b")), "feature/new");
        assert!(!worktree_add(&main, "v1", &root.join("c")).unwrap());
        assert_eq!(branch_of(&root.join("c")), "HEAD", "a tag is checked out detached");
        // A path starting with `-` is a path, not an option.
        assert!(worktree_add(&main, "dash", &root.join("-dash")).unwrap());
        // The branch already checked out in the main worktree is refused.
        let current = branch_of(&main);
        assert!(worktree_add(&main, &current, &root.join("d")).is_err());

        // A branch only on the remote becomes a local branch tracking it.
        let clone = root.join("clone");
        run_git(&root, &["clone", "-q", &main.to_string_lossy(), &clone.to_string_lossy()]);
        assert!(!worktree_add(&clone, "existing", &root.join("e")).unwrap());
        assert_eq!(branch_of(&root.join("e")), "existing");
        let upstream = git_command()
            .args(["rev-parse", "--abbrev-ref", "existing@{upstream}"])
            .current_dir(root.join("e"))
            .output()
            .unwrap();
        assert_eq!(String::from_utf8_lossy(&upstream.stdout).trim(), "origin/existing");
        let _ = std::fs::remove_dir_all(&root);
    }

    #[test]
    fn test_worktree_remove_keeps_uncommitted_or_locked_work_unless_forced() {
        let root = unique_temp_dir("wt_remove_force");
        let main = repo_with_branches(&root, &["dirty", "locked"]);
        let (dirty, locked) = (root.join("dirty"), root.join("locked"));
        run_git(&main, &["worktree", "add", "-q", &dirty.to_string_lossy(), "dirty"]);
        run_git(&main, &["worktree", "add", "-q", &locked.to_string_lossy(), "locked"]);
        std::fs::write(dirty.join("wip.txt"), "untracked work").unwrap();
        run_git(&main, &["worktree", "lock", &locked.to_string_lossy()]);

        assert!(worktree_remove(&main, &dirty, false).is_err());
        assert!(dirty.join("wip.txt").exists(), "a refused remove deletes nothing");
        assert!(worktree_remove(&main, &locked, false).is_err());
        assert!(locked.exists());

        worktree_remove(&main, &dirty, true).unwrap();
        worktree_remove(&main, &locked, true).unwrap();
        assert!(!dirty.exists() && !locked.exists(), "force removes both");
        assert!(load_tab_worktrees(&main).unwrap().is_empty());
        let _ = std::fs::remove_dir_all(&root);
    }

    /// `git submodule deinit` and `git rm` take a path; the submodule's name was
    /// passed instead, so a tracked file sharing that name was deleted (local
    /// edits and all) while the submodule stayed registered.
    #[test]
    fn test_submodule_remove_deletes_the_submodule_path_not_a_same_named_file() {
        let root = unique_temp_dir("submodule_remove");
        let lib = root.join("lib");
        std::fs::create_dir_all(&lib).unwrap();
        run_git(&lib, &["init", "-q"]);
        run_git(&lib, &["commit", "-q", "--allow-empty", "-m", "lib"]);
        let main = repo_with_branches(&root, &[]);
        std::fs::write(main.join("notes"), "tracked notes\n").unwrap();
        run_git(&main, &["add", "notes"]);
        run_git(&main, &["commit", "-q", "-m", "notes"]);
        std::fs::write(main.join("notes"), "tracked notes\nlocal edit\n").unwrap();
        run_git(
            &main,
            &["submodule", "add", "-q", "--name", "notes", &lib.to_string_lossy(), "vendor/n"],
        );
        run_git(&main, &["commit", "-q", "-m", "add submodule"]);
        assert!(main.join(".git/modules/notes").is_dir());

        // Anything that is not the submodule's gitlink is refused untouched.
        assert!(submodule_remove(&main, "notes", Path::new("notes")).is_err());
        assert!(submodule_remove(&main, "notes", Path::new("../lib")).is_err());
        assert!(submodule_remove(&main, "../notes", Path::new("vendor/n")).is_err());
        assert!(main.join("vendor/n").is_dir());

        submodule_remove(&main, "notes", Path::new("vendor/n")).unwrap();
        assert_eq!(
            std::fs::read_to_string(main.join("notes")).unwrap(),
            "tracked notes\nlocal edit\n",
            "the same-named file keeps its local edit"
        );
        assert!(!main.join("vendor/n").exists());
        assert!(!main.join(".git/modules/notes").exists());
        assert!(!std::fs::read_to_string(main.join(".gitmodules")).unwrap().contains("vendor/n"));
        let status = git_command().args(["status", "--porcelain"]).current_dir(&main).output();
        let status = status.unwrap();
        assert!(status.status.success(), "the repository is still usable");
        // The removal is staged for the user to commit, next to the untouched edit.
        let status = String::from_utf8_lossy(&status.stdout);
        assert!(status.lines().any(|l| l == "D  vendor/n"), "{}", status);
        assert!(status.lines().any(|l| l == " M notes"), "{}", status);
        // Until that is committed the tab still lists it, from HEAD, with no
        // index commit: what the Submodules tab shows as "Removal staged".
        let listed = load_tab_submodules(&main).unwrap();
        let removed = listed.iter().find(|s| s.path == Path::new("vendor/n")).unwrap();
        assert!(removed.commit_id.is_none() && removed.head_id.is_some(), "{:?}", removed);
        let _ = std::fs::remove_dir_all(&root);
    }

    /// An uninitialised submodule is cloned and checked out (only the one asked
    /// for, unless every one was), and one moved to another commit goes back to
    /// the recorded one, but never over a local edit the checkout would overwrite.
    #[test]
    fn test_submodule_update_initialises_and_returns_to_the_recorded_commit() {
        let root = unique_temp_dir("submodule_update");
        let lib = root.join("lib");
        std::fs::create_dir_all(&lib).unwrap();
        run_git(&lib, &["init", "-q"]);
        std::fs::write(lib.join("f"), "1\n").unwrap();
        run_git(&lib, &["add", "f"]);
        run_git(&lib, &["commit", "-q", "-m", "one"]);
        let main = repo_with_branches(&root, &[]);
        let lib_url = lib.to_string_lossy().to_string();
        run_git(&main, &["submodule", "add", "-q", &lib_url, "vendor/a"]);
        run_git(&main, &["submodule", "add", "-q", &lib_url, "vendor/b"]);
        run_git(&main, &["commit", "-q", "-m", "add submodules"]);
        run_git(&main, &["submodule", "deinit", "-q", "-f", "--all"]);
        let listed = |p: &str| {
            let subs = load_tab_submodules(&main).unwrap();
            subs.into_iter().find(|s| s.path == Path::new(p)).unwrap()
        };
        assert!(!listed("vendor/a").is_initialized && !listed("vendor/b").is_initialized);

        let timeout = Duration::from_secs(60);
        submodule_update(&main, Some(Path::new("vendor/a")), timeout).unwrap();
        assert!(listed("vendor/a").is_initialized);
        assert!(!listed("vendor/b").is_initialized, "only the selected submodule");
        let sub_a = main.join("vendor/a");
        assert_eq!(std::fs::read_to_string(sub_a.join("f")).unwrap(), "1\n");
        submodule_update(&main, None, timeout).unwrap();
        assert!(listed("vendor/b").is_initialized, "no path updates every submodule");

        // Check out a newer lib commit inside vendor/a: the tab shows Modified.
        std::fs::write(lib.join("f"), "2\n").unwrap();
        run_git(&lib, &["commit", "-q", "-am", "two"]);
        run_git(&sub_a, &["fetch", "-q", "origin", "HEAD"]);
        run_git(&sub_a, &["checkout", "-q", "FETCH_HEAD"]);
        assert!(listed("vendor/a").is_dirty);
        submodule_update(&main, Some(Path::new("vendor/a")), timeout).unwrap();
        assert!(!listed("vendor/a").is_dirty, "back on the recorded commit");
        assert_eq!(std::fs::read_to_string(sub_a.join("f")).unwrap(), "1\n");

        // Moved again, with an uncommitted edit the checkout would overwrite.
        run_git(&sub_a, &["checkout", "-q", "FETCH_HEAD"]);
        std::fs::write(sub_a.join("f"), "local\n").unwrap();
        assert!(submodule_update(&main, Some(Path::new("vendor/a")), timeout).is_err());
        assert_eq!(std::fs::read_to_string(sub_a.join("f")).unwrap(), "local\n");

        assert!(submodule_update(&main, Some(Path::new("nope")), timeout).is_err());
        let _ = std::fs::remove_dir_all(&root);
    }

    /// `gh api -F` reads `@alice ...` as a file name, sends `123` as a number and
    /// fills `{owner}`; review comment text must go through `-f` verbatim.
    #[test]
    fn test_pr_line_comment_args_send_text_fields_verbatim() {
        let args = pr_line_comment_args(42, "abc123", "src/{owner}.rs", 7, "@alice 123");
        let field =
            |flag: &str, value: &str| args.windows(2).any(|w| w[0] == flag && w[1] == value);
        assert!(field("-f", "body=@alice 123"), "{:?}", args);
        assert!(field("-f", "path=src/{owner}.rs"), "{:?}", args);
        assert!(field("-f", "commit_id=abc123"), "{:?}", args);
        assert!(field("-f", "side=RIGHT"), "{:?}", args);
        assert!(field("-F", "line=7"), "line is sent as a number: {:?}", args);
        assert_eq!(args.iter().filter(|a| *a == "-F").count(), 1, "{:?}", args);
        assert_eq!(args[1], "repos/:owner/:repo/pulls/42/comments");
    }

    /// `statusCheckRollup` as `gh pr list --json` prints it: a finished and a
    /// running check run, and a commit status (`StatusContext`, no `name`),
    /// which used to fail the whole PR list with "missing field `name`".
    #[test]
    fn test_parse_forge_prs_accepts_commit_statuses_and_running_checks() {
        let json = br#"[{"number":42,"title":"Add retry","state":"OPEN",
            "author":{"login":"alice"},"assignees":[],"url":"https://github.com/o/r/pull/42",
            "headRefName":"retry","headRefOid":"abc","body":"",
            "statusCheckRollup":[
              {"__typename":"CheckRun","name":"build","workflowName":"CI","status":"COMPLETED",
               "conclusion":"SUCCESS","startedAt":"2026-01-01T00:00:00Z","completedAt":"2026-01-01T00:01:00Z","detailsUrl":"https://x"},
              {"__typename":"CheckRun","name":"lint","workflowName":"CI","status":"IN_PROGRESS",
               "conclusion":"","startedAt":"2026-01-01T00:00:00Z","completedAt":"0001-01-01T00:00:00Z","detailsUrl":"https://x"},
              {"__typename":"StatusContext","context":"ci/circleci","state":"FAILURE",
               "targetUrl":"https://circleci.com/x","startedAt":"2026-01-01T00:00:00Z"}],
            "reviews":[{"author":null,"body":"LGTM","state":"APPROVED"}]}]"#;
        let prs = parse_forge_prs(json).unwrap();
        let checks = &prs[0].status_checks;
        assert_eq!(checks.len(), 3);
        assert_eq!(checks[0].conclusion.as_deref(), Some("SUCCESS"));
        assert_eq!((checks[1].name.as_str(), checks[1].conclusion.as_deref()), ("lint", None));
        assert_eq!(checks[1].status.as_deref(), Some("IN_PROGRESS"));
        assert_eq!(checks[2].name, "ci/circleci");
        assert_eq!(checks[2].state.as_deref(), Some("FAILURE"));
        assert_eq!(prs[0].reviews[0].author, "none");
    }

    /// `gh api --paginate` prints each page's array back to back; all of them
    /// count (only the first 30 comments used to load).
    #[test]
    fn test_parse_pr_comments_reads_every_page() {
        let comment = |n: u32| {
            format!(
                r#"{{"path":"a.rs","line":{},"body":"c{}","user":{{"login":"bob"}},"commit_id":"x"}}"#,
                n, n
            )
        };
        let page = |range: std::ops::Range<u32>| {
            format!("[{}]", range.map(comment).collect::<Vec<_>>().join(","))
        };
        let json = format!("{}\n{}", page(0..100), page(100..130));
        let comments = parse_pr_comments(json.as_bytes()).unwrap();
        assert_eq!(comments.len(), 130);
        assert_eq!(comments[129].body, "c129");
        assert!(parse_pr_comments(b"[]").unwrap().is_empty());
        let deleted_user = br#"[{"path":"a","line":null,"body":"b","user":null,"commit_id":"x"}]"#;
        assert_eq!(parse_pr_comments(deleted_user).unwrap()[0].author, "none");
        assert!(parse_pr_comments(b"[{").is_err());
    }

    #[test]
    fn test_parse_linked_branches() {
        let json = br#"{"data":{"repository":{"issue":{"linkedBranches":{"nodes":[
            {"ref":{"name":"12-login-fails"}},{"ref":null},{"ref":{"name":"12-login-fails"}},
            {"ref":{"name":"alt-12"}}]}}}}}"#;
        assert_eq!(parse_linked_branches(json).unwrap(), vec!["12-login-fails", "alt-12"]);
        let none = br#"{"data":{"repository":{"issue":{"linkedBranches":{"nodes":[]}}}}}"#;
        assert!(parse_linked_branches(none).unwrap().is_empty());
        let no_issue = br#"{"data":{"repository":{"issue":null}}}"#;
        assert!(parse_linked_branches(no_issue).unwrap().is_empty());
        assert!(parse_linked_branches(b"not json").is_err());
    }

    #[test]
    fn test_branch_names_issue_matches_whole_tokens_only() {
        for (branch, issue) in [
            ("fix-1-typo", 1),
            ("issue-12-login", 12),
            ("12-login", 12),
            ("feature/12", 12),
            ("gh#12", 12),
            ("issue_12", 12),
            ("v1.2-release-2", 2),
        ] {
            assert!(branch_names_issue(branch, issue), "{} names #{}", branch, issue);
        }
        for (branch, issue) in [
            ("v1.2-release", 1),
            ("v1.2-release", 2),
            ("issue-12-login", 1),
            ("issue-12-login", 2),
            ("issue-123", 12),
            ("issue12", 12),
            ("main", 1),
        ] {
            assert!(!branch_names_issue(branch, issue), "{} does not name #{}", branch, issue);
        }
    }

    fn current_branch(repo: &Path) -> String {
        let out = git_command().args(["branch", "--show-current"]).current_dir(repo).output();
        String::from_utf8_lossy(&out.unwrap().stdout).trim().to_string()
    }

    #[test]
    fn test_checkout_issue_branch_by_name_picks_the_one_branch_naming_the_issue() {
        let root = unique_temp_dir("issue_branch");
        let main = repo_with_branches(
            &root,
            &["fix-1-typo", "v1.2-release", "issue-12-login", "7-crash", "fix/7"],
        );
        let start = current_branch(&main);

        // #2 used to land on issue-12-login (substring "2"); no branch names it.
        assert_eq!(
            checkout_issue_branch_by_name(&main, 2).unwrap(),
            "Created and switched to new branch 'issue-2'"
        );
        assert_eq!(current_branch(&main), "issue-2");
        checkout_issue_branch_by_name(&main, 12).unwrap();
        assert_eq!(current_branch(&main), "issue-12-login");
        checkout_issue_branch_by_name(&main, 1).unwrap();
        assert_eq!(current_branch(&main), "fix-1-typo");

        // Two candidates: report them and stay put.
        let err = checkout_issue_branch_by_name(&main, 7).unwrap_err();
        assert!(err.contains("7-crash") && err.contains("fix/7"), "{}", err);
        assert_eq!(current_branch(&main), "fix-1-typo");

        // A branch only on the remote is checked out as a tracking branch.
        run_git(&main, &["checkout", "-q", &start]);
        run_git(&main, &["branch", "fix-9-remote"]);
        let clone = root.join("clone");
        run_git(&root, &["clone", "-q", &main.to_string_lossy(), &clone.to_string_lossy()]);
        assert_eq!(
            checkout_issue_branch_by_name(&clone, 9).unwrap(),
            "Checked out matched remote branch 'origin/fix-9-remote'"
        );
        assert_eq!(current_branch(&clone), "fix-9-remote");
        let _ = std::fs::remove_dir_all(&root);
    }

    /// A linked branch missing from the clone must not reach `git checkout` as
    /// a bare name: git would read `docs` as a path and discard its changes.
    #[test]
    fn test_checkout_linked_issue_branch_never_restores_a_same_named_path() {
        let root = unique_temp_dir("linked_branch");
        let main = repo_with_branches(&root, &[]);
        std::fs::create_dir_all(main.join("docs")).unwrap();
        std::fs::write(main.join("docs/guide.md"), "v1\n").unwrap();
        run_git(&main, &["add", "docs"]);
        run_git(&main, &["commit", "-q", "-m", "docs"]);
        run_git(&main, &["branch", "linked-5"]);
        std::fs::write(main.join("docs/guide.md"), "v1\nunsaved edit\n").unwrap();

        let err = checkout_linked_issue_branch(&main, 5, "docs").unwrap_err();
        assert!(err.contains("not in this clone"), "{}", err);
        assert_eq!(
            std::fs::read_to_string(main.join("docs/guide.md")).unwrap(),
            "v1\nunsaved edit\n"
        );
        checkout_linked_issue_branch(&main, 5, "linked-5").unwrap();
        assert_eq!(current_branch(&main), "linked-5");
        let _ = std::fs::remove_dir_all(&root);
    }

    /// Builds a repo whose only commit carries a (fake) gpg signature and whose
    /// `gpg.program` points at a binary that does not exist. Any `%G?` lookup then
    /// makes git print `error: cannot run …` on stderr and still exit 0, which is
    /// exactly what a machine without gpg does for a real signed commit.
    fn make_repo_with_unverifiable_signature() -> PathBuf {
        use std::io::Write;
        use std::process::Stdio;
        // Two tests build this fixture and libtest runs them in parallel.
        let temp_path = unique_temp_dir("nogpg");
        let repo = Repository::init(&temp_path).unwrap();
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();
        config.set_str("gpg.program", "/nonexistent/gitwig-test-no-gpg").unwrap();

        let mut file = File::create(temp_path.join("test.txt")).unwrap();
        writeln!(file, "initial content").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "signed commit").unwrap();

        // Re-hash the commit with a gpgsig header spliced in after `committer`.
        let raw = git_command()
            .args(["cat-file", "-p", "HEAD"])
            .current_dir(&temp_path)
            .output()
            .unwrap();
        let mut signed = String::new();
        for line in String::from_utf8_lossy(&raw.stdout).lines() {
            signed.push_str(line);
            signed.push('\n');
            if line.starts_with("committer ") {
                signed.push_str("gpgsig -----BEGIN PGP SIGNATURE-----\n \n iQEzBAABCAAdFiEEfake\n -----END PGP SIGNATURE-----\n");
            }
        }
        let mut hash_cmd = git_command();
        hash_cmd.args(["hash-object", "-t", "commit", "-w", "--stdin"]).current_dir(&temp_path);
        hash_cmd.stdin(Stdio::piped());
        let mut child = hash_cmd.spawn().unwrap();
        child.stdin.take().unwrap().write_all(signed.as_bytes()).unwrap();
        let out = child.wait_with_output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        let new_oid = String::from_utf8_lossy(&out.stdout).trim().to_string();
        let head_ref = String::from_utf8_lossy(
            &git_command()
                .args(["symbolic-ref", "HEAD"])
                .current_dir(&temp_path)
                .output()
                .unwrap()
                .stdout,
        )
        .trim()
        .to_string();
        let upd = git_command()
            .args(["update-ref", &head_ref, &new_oid])
            .current_dir(&temp_path)
            .output()
            .unwrap();
        assert!(upd.status.success());
        temp_path
    }

    #[test]
    fn graph_survives_missing_signature_program_and_reports_it() {
        let temp_path = make_repo_with_unverifiable_signature();
        let (tx, rx) = std::sync::mpsc::channel();

        let load = load_tab_graph_stream(&temp_path, 100, true, String::new(), 2, tx)
            .expect("a missing gpg must not fail the graph");
        assert_eq!(load.lines.len(), 1);
        assert!(load.lines[0].commit.is_some());
        let notice = load.notice.expect("git's stderr must surface as a notice");
        assert!(
            notice.contains("/nonexistent/gitwig-test-no-gpg"),
            "notice must name the program git could not start: {notice}"
        );
        assert!(!notice.starts_with("error:"), "prefix should be stripped: {notice}");
        assert!(rx.try_recv().is_err(), "no batch is streamed for a one-commit graph");

        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn graph_skips_signature_lookup_when_disabled() {
        let temp_path = make_repo_with_unverifiable_signature();
        let (tx, _rx) = std::sync::mpsc::channel();

        let load = load_tab_graph_stream(&temp_path, 100, false, String::new(), 2, tx).unwrap();
        assert_eq!(load.lines.len(), 1);
        assert_eq!(load.lines[0].commit.as_ref().unwrap().signature_status, "N");
        assert!(load.notice.is_none(), "no %G? means git never touches gpg");

        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_ref_map_cache_behavior() {
        let temp_dir = std::env::temp_dir();
        let repo_path = temp_dir.join("test_ref_map_repo");
        let _ = std::fs::remove_dir_all(&repo_path);
        std::fs::create_dir_all(&repo_path).unwrap();

        let repo = Repository::init(&repo_path).unwrap();

        // 1. First fetch (rebuilds and caches)
        let map1 = get_cached_ref_map(&repo, &repo_path);

        // 2. Second fetch (returns cached map)
        let map2 = get_cached_ref_map(&repo, &repo_path);
        assert_eq!(map1.len(), map2.len());

        // 3. Invalidate cache
        invalidate_ref_map_cache(&repo_path);

        // Clean up
        let _ = std::fs::remove_dir_all(&repo_path);
    }

    #[test]
    fn test_get_latest_change_time() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_time_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        let change_time = get_latest_change_time(temp_path.to_str().unwrap());
        assert!(change_time > 0);

        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_committer_stats() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_stats_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file
        let file_path = temp_path.join("test.txt");
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "initial content").unwrap();

        // Stage and commit initial
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Collect stats
        let (stats, limit_reached) = collect_committer_stats(&repo, 10).unwrap();
        assert_eq!(stats.len(), 1);
        assert_eq!(stats[0].name, "Test User");
        assert_eq!(stats[0].email, "test@example.com");
        assert_eq!(stats[0].count, 1);
        assert!(!limit_reached);

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_untracked_files_in_unstaged() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_untracked_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let _repo = Repository::init(&temp_path).unwrap();

        // Create an untracked file
        let file_path = temp_path.join("untracked.txt");
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "hello untracked").unwrap();

        // Create an untracked directory and a file inside it
        let untracked_dir = temp_path.join("untracked_dir");
        std::fs::create_dir_all(&untracked_dir).unwrap();
        let nested_file_path = untracked_dir.join("nested.txt");
        std::fs::write(&nested_file_path, "nested untracked file").unwrap();

        // Inspect detail
        let detail = inspect_detail(temp_path.to_str().unwrap(), 0, 1000, false);
        match detail {
            ItemDetail::Repo { info, .. } => {
                // Verify no folders are in the unstaged/untracked list
                let unstaged_paths: Vec<String> =
                    info.changes.unstaged.iter().map(|f| f.path.clone()).collect();
                let untracked_paths: Vec<String> =
                    info.changes.untracked.iter().map(|f| f.path.clone()).collect();

                // Folder itself should NOT be listed
                assert!(!unstaged_paths.contains(&"untracked_dir".to_string()));
                assert!(!unstaged_paths.contains(&"untracked_dir/".to_string()));
                assert!(!untracked_paths.contains(&"untracked_dir".to_string()));
                assert!(!untracked_paths.contains(&"untracked_dir/".to_string()));

                // Untracked files (both root and nested) should be listed
                assert!(unstaged_paths.contains(&"untracked.txt".to_string()));
                assert!(unstaged_paths.contains(&"untracked_dir/nested.txt".to_string()));
                assert!(untracked_paths.contains(&"untracked.txt".to_string()));
                assert!(untracked_paths.contains(&"untracked_dir/nested.txt".to_string()));
            }
            _ => panic!("Expected ItemDetail::Repo"),
        }

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_stage_new_and_deleted_files() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_new_del_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file & commit
        let init_file = temp_path.join("init.txt");
        std::fs::write(&init_file, "initial").unwrap();
        stage_file(&temp_path, "init.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // 1. Create a new file (untracked)
        let untracked_file = temp_path.join("untracked.txt");
        std::fs::write(&untracked_file, "new file content").unwrap();

        // Try staging untracked file
        stage_file(&temp_path, "untracked.txt").unwrap();

        // 2. Delete the initial file
        std::fs::remove_file(&init_file).unwrap();

        // Try staging deleted file
        stage_file(&temp_path, "init.txt").unwrap();

        // Check status of repo
        let detail = inspect_detail(temp_path.to_str().unwrap(), 0, 1000, false);
        match detail {
            ItemDetail::Repo { info, .. } => {
                // Both should be in staged changes
                assert_eq!(info.changes.staged.len(), 2);
                let paths: Vec<String> =
                    info.changes.staged.iter().map(|f| f.path.clone()).collect();
                assert!(paths.contains(&"untracked.txt".to_string()));
                assert!(paths.contains(&"init.txt".to_string()));
            }
            _ => panic!("Expected ItemDetail::Repo"),
        }

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_discard_file_changes_all_cases() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_discard_all_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create and commit initial files
        let file_tracked = temp_path.join("tracked.txt");
        std::fs::write(&file_tracked, "original content\n").unwrap();
        stage_file(&temp_path, "tracked.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Case 1: Untracked file
        let file_untracked = temp_path.join("untracked.txt");
        std::fs::write(&file_untracked, "new untracked file\n").unwrap();
        assert!(file_untracked.exists());
        discard_file_changes(&temp_path, "untracked.txt", false).unwrap();
        assert!(!file_untracked.exists());

        // Case 2: Tracked file with unstaged modification
        std::fs::write(&file_tracked, "unstaged modifications\n").unwrap();
        discard_file_changes(&temp_path, "tracked.txt", false).unwrap();
        assert_eq!(std::fs::read_to_string(&file_tracked).unwrap(), "original content\n");

        // Case 3: Tracked file with staged modification
        std::fs::write(&file_tracked, "staged modifications\n").unwrap();
        stage_file(&temp_path, "tracked.txt").unwrap();
        // verify it's staged
        let detail = inspect_detail(temp_path.to_str().unwrap(), 0, 1000, false);
        match detail {
            ItemDetail::Repo { info, .. } => {
                assert!(!info.changes.staged.is_empty());
            }
            _ => panic!("Expected ItemDetail::Repo"),
        }
        discard_file_changes(&temp_path, "tracked.txt", true).unwrap();
        assert_eq!(std::fs::read_to_string(&file_tracked).unwrap(), "original content\n");
        // verify it's no longer staged/unstaged (it's clean)
        let detail = inspect_detail(temp_path.to_str().unwrap(), 0, 1000, false);
        match detail {
            ItemDetail::Repo { info, .. } => {
                assert!(info.changes.staged.is_empty());
                assert!(info.changes.unstaged.is_empty());
            }
            _ => panic!("Expected ItemDetail::Repo"),
        }

        // Case 4: Tracked deleted file
        std::fs::remove_file(&file_tracked).unwrap();
        assert!(!file_tracked.exists());
        discard_file_changes(&temp_path, "tracked.txt", false).unwrap();
        assert!(file_tracked.exists());
        assert_eq!(std::fs::read_to_string(&file_tracked).unwrap(), "original content\n");

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    #[cfg_attr(target_os = "windows", ignore = "CRLF patch issues on Windows")]
    fn test_stage_unstage_by_hunk() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_hunk_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file with multiple lines
        let file_path = temp_path.join("multihunk.txt");
        let mut file = File::create(&file_path).unwrap();
        for i in 1..=20 {
            writeln!(file, "Line {}", i).unwrap();
        }
        drop(file);

        // Stage and commit initial
        stage_file(&temp_path, "multihunk.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Now modify lines 2 and 18 to create two distinct hunks
        let mut file = File::create(&file_path).unwrap();
        for i in 1..=20 {
            if i == 2 || i == 18 {
                writeln!(file, "Line {} modified", i).unwrap();
            } else {
                writeln!(file, "Line {}", i).unwrap();
            }
        }
        drop(file);

        // Get the unstaged diff lines
        let diff_lines = get_worktree_file_diff(&temp_path, "multihunk.txt", false);
        // Identify hunk ranges. A hunk header starts with "@@"
        let mut hunk_ranges = Vec::new();
        let mut current_start = None;
        for (i, line) in diff_lines.iter().enumerate() {
            if line.kind == DiffLineKind::Header {
                if let Some(start) = current_start {
                    hunk_ranges.push(start..i);
                }
                current_start = Some(i);
            }
        }
        if let Some(start) = current_start {
            hunk_ranges.push(start..diff_lines.len());
        }

        // We expect exactly 2 hunks
        assert_eq!(hunk_ranges.len(), 2);

        // Stage the second hunk
        let hunk2 = &diff_lines[hunk_ranges[1].clone()];
        stage_hunk(&temp_path, "multihunk.txt", hunk2).unwrap();

        // Now check staged diff for the file: it should contain the second modification
        let staged_diff = get_worktree_file_diff(&temp_path, "multihunk.txt", true);
        let staged_content: String =
            staged_diff.iter().map(|l| l.content.as_str()).collect::<Vec<_>>().join("\n");
        assert!(staged_content.contains("Line 18 modified"));
        assert!(!staged_content.contains("Line 2 modified"));

        // Check unstaged diff for the file: it should contain the first modification
        let unstaged_diff = get_worktree_file_diff(&temp_path, "multihunk.txt", false);
        let unstaged_content: String =
            unstaged_diff.iter().map(|l| l.content.as_str()).collect::<Vec<_>>().join("\n");
        assert!(unstaged_content.contains("Line 2 modified"));
        assert!(!unstaged_content.contains("Line 18 modified"));

        // Unstage the staged hunk
        let staged_hunk_ranges = {
            let mut ranges = Vec::new();
            let mut current_start = None;
            for (i, line) in staged_diff.iter().enumerate() {
                if line.kind == DiffLineKind::Header {
                    if let Some(start) = current_start {
                        ranges.push(start..i);
                    }
                    current_start = Some(i);
                }
            }
            if let Some(start) = current_start {
                ranges.push(start..staged_diff.len());
            }
            ranges
        };
        assert_eq!(staged_hunk_ranges.len(), 1);
        let staged_hunk = &staged_diff[staged_hunk_ranges[0].clone()];
        unstage_hunk(&temp_path, "multihunk.txt", staged_hunk).unwrap();

        // Staged diff should now be empty
        let staged_diff_after = get_worktree_file_diff(&temp_path, "multihunk.txt", true);
        assert!(staged_diff_after.is_empty());

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    #[cfg_attr(target_os = "windows", ignore = "CRLF patch issues on Windows")]
    fn test_discard_hunk() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_discard_h_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file with multiple lines
        let file_path = temp_path.join("discardhunk.txt");
        let mut file = File::create(&file_path).unwrap();
        for i in 1..=20 {
            writeln!(file, "Line {}", i).unwrap();
        }
        drop(file);

        // Stage and commit initial
        stage_file(&temp_path, "discardhunk.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Now modify lines 2 and 18 to create two distinct hunks
        let mut file = File::create(&file_path).unwrap();
        for i in 1..=20 {
            if i == 2 || i == 18 {
                writeln!(file, "Line {} modified", i).unwrap();
            } else {
                writeln!(file, "Line {}", i).unwrap();
            }
        }
        drop(file);

        // Get the unstaged diff lines
        let diff_lines = get_worktree_file_diff(&temp_path, "discardhunk.txt", false);
        // Identify hunk ranges
        let mut hunk_ranges = Vec::new();
        let mut current_start = None;
        for (i, line) in diff_lines.iter().enumerate() {
            if line.kind == DiffLineKind::Header {
                if let Some(start) = current_start {
                    hunk_ranges.push(start..i);
                }
                current_start = Some(i);
            }
        }
        if let Some(start) = current_start {
            hunk_ranges.push(start..diff_lines.len());
        }

        // We expect exactly 2 hunks
        assert_eq!(hunk_ranges.len(), 2);

        // Discard the second hunk (Line 18 modified)
        let hunk2 = &diff_lines[hunk_ranges[1].clone()];
        discard_hunk(&temp_path, "discardhunk.txt", hunk2).unwrap();

        // Now check file contents: line 18 should be reverted to "Line 18", while line 2 should remain "Line 2 modified"
        let contents = std::fs::read_to_string(&file_path).unwrap();
        assert!(contents.contains("Line 2 modified"));
        assert!(contents.contains("Line 18\n"));
        assert!(!contents.contains("Line 18 modified"));

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    #[cfg_attr(target_os = "windows", ignore = "CRLF patch issues on Windows")]
    fn test_stage_unstage_discard_line() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_line_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        let repo = Repository::init(&temp_path).unwrap();
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // 1. Create initial file
        let file_path = temp_path.join("line_test.txt");
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "line A").unwrap();
        writeln!(file, "line B").unwrap();
        writeln!(file, "line C").unwrap();
        drop(file);

        stage_file(&temp_path, "line_test.txt").unwrap();
        commit_changes(&temp_path, "initial").unwrap();

        // 2. Modify to introduce two distinct changes in one hunk
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "line A modified").unwrap();
        writeln!(file, "line B").unwrap();
        writeln!(file, "line C modified").unwrap();
        drop(file);

        let diff_lines = get_worktree_file_diff(&temp_path, "line_test.txt", false);
        let mut hunk_ranges = Vec::new();
        let mut current_start = None;
        for (i, line) in diff_lines.iter().enumerate() {
            if line.kind == DiffLineKind::Header {
                if let Some(start) = current_start {
                    hunk_ranges.push(start..i);
                }
                current_start = Some(i);
            }
        }
        if let Some(start) = current_start {
            hunk_ranges.push(start..diff_lines.len());
        }

        assert_eq!(hunk_ranges.len(), 1);
        let hunk0 = &diff_lines[hunk_ranges[0].clone()];

        assert_eq!(hunk0[2].content, "line A modified");
        assert_eq!(hunk0[5].content, "line C modified");

        // A) Stage line A modified (relative index 2)
        stage_line(&temp_path, "line_test.txt", hunk0, 2).unwrap();

        // Check staged diff
        let staged_diff = get_worktree_file_diff(&temp_path, "line_test.txt", true);
        assert!(
            staged_diff
                .iter()
                .any(|l| l.kind == DiffLineKind::Added && l.content == "line A modified")
        );
        assert!(
            !staged_diff
                .iter()
                .any(|l| l.kind == DiffLineKind::Added && l.content == "line C modified")
        );

        // Check unstaged diff
        let unstaged_diff = get_worktree_file_diff(&temp_path, "line_test.txt", false);
        assert!(
            !unstaged_diff
                .iter()
                .any(|l| l.kind == DiffLineKind::Added && l.content == "line A modified")
        );
        assert!(
            unstaged_diff
                .iter()
                .any(|l| l.kind == DiffLineKind::Added && l.content == "line C modified")
        );

        // B) Unstage line A modified
        assert_eq!(staged_diff[2].content, "line A modified");
        unstage_line(&temp_path, "line_test.txt", &staged_diff, 2).unwrap();

        // Staged diff should now be empty
        assert!(get_worktree_file_diff(&temp_path, "line_test.txt", true).is_empty());

        // C) Discard line C modified (index 5) in unstaged diff
        let unstaged_diff2 = get_worktree_file_diff(&temp_path, "line_test.txt", false);
        assert_eq!(unstaged_diff2[5].content, "line C modified");
        discard_line(&temp_path, "line_test.txt", &unstaged_diff2, 5).unwrap();

        let unstaged_diff3 = get_worktree_file_diff(&temp_path, "line_test.txt", false);
        let remove_idx = unstaged_diff3
            .iter()
            .position(|l| l.kind == DiffLineKind::Removed && l.content == "line C")
            .unwrap();
        discard_line(&temp_path, "line_test.txt", &unstaged_diff3, remove_idx).unwrap();

        // File contents check
        let contents = std::fs::read_to_string(&file_path).unwrap();
        assert!(contents.contains("line A modified"));
        assert!(contents.contains("line B"));
        assert!(contents.contains("line C\n"));
        assert!(!contents.contains("line C modified"));

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    #[cfg_attr(target_os = "windows", ignore = "CRLF patch issues on Windows")]
    fn test_stage_unstage_discard_all_changes() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_all_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // Create initial file & commit it
        let file_path = temp_path.join("tracked.txt");
        std::fs::write(&file_path, "original content\n").unwrap();
        stage_file(&temp_path, "tracked.txt").unwrap();
        commit_changes(&temp_path, "initial").unwrap();

        // 1. Make a modification and create a new untracked file
        std::fs::write(&file_path, "modified content\n").unwrap();
        let untracked_path = temp_path.join("untracked.txt");
        std::fs::write(&untracked_path, "untracked content\n").unwrap();

        // Verify status has unstaged changes
        let status = repo.statuses(None).unwrap();
        assert_eq!(status.len(), 2);

        // Stage all changes
        stage_all_changes(&temp_path).unwrap();

        // Verify all changes are staged
        let status = repo.statuses(None).unwrap();
        for entry in status.iter() {
            assert!(
                entry.status().intersects(git2::Status::INDEX_MODIFIED | git2::Status::INDEX_NEW)
            );
        }

        // Unstage all changes
        unstage_all_changes(&temp_path).unwrap();

        // Verify all changes are unstaged again
        let status = repo.statuses(None).unwrap();
        for entry in status.iter() {
            assert!(entry.status().intersects(git2::Status::WT_MODIFIED | git2::Status::WT_NEW));
        }

        // Discard all changes
        discard_all_changes(&temp_path).unwrap();

        // Verify repo is completely clean
        let status = repo.statuses(None).unwrap();
        assert_eq!(status.len(), 0);

        // Verify tracked file is reset and untracked file is removed
        let contents = std::fs::read_to_string(&file_path).unwrap();
        assert_eq!(contents, "original content\n");
        assert!(!untracked_path.exists());

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_merge_conflicts_flow() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_conflict_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // 1. Initial commit on main
        let file_path = temp_path.join("conflict.txt");
        std::fs::write(&file_path, "line 1\nline 2\nline 3\n").unwrap();
        stage_file(&temp_path, "conflict.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Get the main branch name first
        let output = git_command()
            .args(["symbolic-ref", "--short", "HEAD"])
            .current_dir(&temp_path)
            .output()
            .unwrap();
        let main_branch = String::from_utf8_lossy(&output.stdout).trim().to_string();

        // 2. Create feature branch and edit
        git_command().args(["checkout", "-b", "feature"]).current_dir(&temp_path).output().unwrap();

        std::fs::write(&file_path, "line 1\nline 2 on feature\nline 3\n").unwrap();
        stage_file(&temp_path, "conflict.txt").unwrap();
        commit_changes(&temp_path, "feature commit").unwrap();

        // 3. Checkout main/master and edit differently
        git_command().args(["checkout", &main_branch]).current_dir(&temp_path).output().unwrap();

        std::fs::write(&file_path, "line 1\nline 2 on main\nline 3\n").unwrap();
        stage_file(&temp_path, "conflict.txt").unwrap();
        commit_changes(&temp_path, "main commit").unwrap();

        // 4. Merge feature into main -> conflict
        assert!(!is_merging(&temp_path));
        let merge_output =
            git_command().args(["merge", "feature"]).current_dir(&temp_path).output().unwrap();

        assert!(!merge_output.status.success());
        assert!(is_merging(&temp_path));

        // 5. Check conflict markers diff
        let diff = get_conflict_markers_diff(&temp_path, "conflict.txt");
        assert!(!diff.is_empty());
        let has_separator = diff.iter().any(|l| matches!(l.kind, DiffLineKind::ConflictSeparator));
        let has_ours = diff.iter().any(|l| matches!(l.kind, DiffLineKind::ConflictOurs));
        let has_theirs = diff.iter().any(|l| matches!(l.kind, DiffLineKind::ConflictTheirs));
        assert!(has_separator);
        assert!(has_ours);
        assert!(has_theirs);

        // 6. Abort merge and verify
        abort_merge(&temp_path).unwrap();
        assert!(!is_merging(&temp_path));

        // 7. Conflict again to test resolve_ours/resolve_theirs
        git_command().args(["merge", "feature"]).current_dir(&temp_path).output().unwrap();
        assert!(is_merging(&temp_path));

        // Test resolve_ours
        resolve_ours(&temp_path, "conflict.txt").unwrap();
        let contents = std::fs::read_to_string(&file_path).unwrap();
        assert!(contents.contains("line 2 on main"));
        assert!(!contents.contains("<<<<<<<"));

        // Since it's resolved, we can continue merge
        continue_merge(&temp_path).unwrap();
        assert!(!is_merging(&temp_path));

        // 8. Test resolve_theirs by resetting main to before the merge
        git_command().args(["reset", "--hard", "HEAD~1"]).current_dir(&temp_path).output().unwrap();

        git_command().args(["merge", "feature"]).current_dir(&temp_path).output().unwrap();
        assert!(is_merging(&temp_path));

        resolve_theirs(&temp_path, "conflict.txt").unwrap();
        let contents_theirs = std::fs::read_to_string(&file_path).unwrap();
        assert!(contents_theirs.contains("line 2 on feature"));
        assert!(!contents_theirs.contains("<<<<<<<"));

        continue_merge(&temp_path).unwrap();
        assert!(!is_merging(&temp_path));

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_resolve_conflict_hunk() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_hunk_conflict_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        // Init repo
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // 1. Initial commit on main
        let file_path = temp_path.join("conflict.txt");
        let initial_lines = "line 1\nline 2\nline 3\nline 4\nline 5\nline 6\nline 7\nline 8\nline 9\nline 10\nline 11\nline 12\n";
        std::fs::write(&file_path, initial_lines).unwrap();
        stage_file(&temp_path, "conflict.txt").unwrap();
        commit_changes(&temp_path, "initial commit").unwrap();

        // Get the main branch name first
        let output = git_command()
            .args(["symbolic-ref", "--short", "HEAD"])
            .current_dir(&temp_path)
            .output()
            .unwrap();
        let main_branch = String::from_utf8_lossy(&output.stdout).trim().to_string();

        // 2. Create feature branch and edit line 2 and line 11
        git_command().args(["checkout", "-b", "feature"]).current_dir(&temp_path).output().unwrap();
        let feature_lines = "line 1\nline 2 on feature\nline 3\nline 4\nline 5\nline 6\nline 7\nline 8\nline 9\nline 10\nline 11 on feature\nline 12\n";
        std::fs::write(&file_path, feature_lines).unwrap();
        stage_file(&temp_path, "conflict.txt").unwrap();
        commit_changes(&temp_path, "feature commit").unwrap();

        // 3. Checkout main/master and edit line 2 and line 11 differently
        git_command().args(["checkout", &main_branch]).current_dir(&temp_path).output().unwrap();
        let main_lines = "line 1\nline 2 on main\nline 3\nline 4\nline 5\nline 6\nline 7\nline 8\nline 9\nline 10\nline 11 on main\nline 12\n";
        std::fs::write(&file_path, main_lines).unwrap();
        stage_file(&temp_path, "conflict.txt").unwrap();
        commit_changes(&temp_path, "main commit").unwrap();

        // 4. Merge feature into main -> conflict
        let merge_output =
            git_command().args(["merge", "feature"]).current_dir(&temp_path).output().unwrap();
        assert!(!merge_output.status.success());
        assert!(is_merging(&temp_path));

        // 5. Resolve first hunk as Ours
        resolve_conflict_hunk(&temp_path, "conflict.txt", 0, true).unwrap();
        let contents_after_first = std::fs::read_to_string(&file_path).unwrap();
        // Line 2 should be resolved to main
        assert!(contents_after_first.contains("line 2 on main"));
        assert!(!contents_after_first.contains("line 2 on feature"));
        // Line 11 should still have conflict markers
        assert!(contents_after_first.contains("<<<<<<<"));
        assert!(contents_after_first.contains("line 11 on main"));
        assert!(contents_after_first.contains("line 11 on feature"));

        // Repo should still be in a merging state because 1 conflict hunk remains
        assert!(is_merging(&temp_path));

        // 6. Resolve second hunk (which is now hunk 0, since hunk 0 was resolved and removed)
        // Wait, did the hunk count change? Yes, the first conflict block was removed,
        // so the remaining conflict block at line 11 becomes the 0th hunk in the file!
        // Let's call resolve_conflict_hunk with hunk_idx 0!
        resolve_conflict_hunk(&temp_path, "conflict.txt", 0, false).unwrap();
        let contents_after_second = std::fs::read_to_string(&file_path).unwrap();
        // Both lines should be resolved, no conflict markers left
        assert!(contents_after_second.contains("line 2 on main"));
        assert!(contents_after_second.contains("line 11 on feature"));
        assert!(!contents_after_second.contains("<<<<<<<"));

        // File is fully resolved so it should have been automatically staged
        let status = repo.statuses(None).unwrap();
        assert_eq!(status.len(), 1);
        assert!(status.get(0).unwrap().status().contains(git2::Status::INDEX_MODIFIED));

        // Continue and finalize the merge
        continue_merge(&temp_path).unwrap();
        assert!(!is_merging(&temp_path));

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_branch_and_commit_helpers() {
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_helpers_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        let _ = std::fs::remove_dir_all(&temp_path);
        std::fs::create_dir_all(&temp_path).unwrap();

        // 1. Initialize repository
        let repo = Repository::init(&temp_path).unwrap();

        // Configure author
        let mut config = repo.config().unwrap();
        config.set_str("user.name", "Test User").unwrap();
        config.set_str("user.email", "test@example.com").unwrap();

        // 2. Create initial commit (root commit)
        let file_path = temp_path.join("test.txt");
        std::fs::write(&file_path, "root content").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "root commit").unwrap();

        let head_oid = repo.head().unwrap().target().unwrap().to_string();
        assert!(is_root_commit(&temp_path, &head_oid));

        // 3. Create second commit (non-root commit)
        std::fs::write(&file_path, "second content").unwrap();
        stage_file(&temp_path, "test.txt").unwrap();
        commit_changes(&temp_path, "second commit").unwrap();

        let new_head_oid = repo.head().unwrap().target().unwrap().to_string();
        assert!(!is_root_commit(&temp_path, &new_head_oid));

        // 4. Test push target with first remote config
        // Currently there are no remotes, so it should return None or fallback.
        // Wait, get_branch_push_target returns None if no remotes are found and no upstream config.
        // Let's add a remote.
        remote_add(&temp_path, "origin", "https://github.com/example/repo.git").unwrap();
        let active_branch = if repo.find_branch("master", git2::BranchType::Local).is_ok() {
            "master"
        } else {
            "main"
        };
        let target = get_branch_push_target(&temp_path, active_branch);
        assert!(target.is_some());
        let (remote_name, set_upstream) = target.unwrap();
        assert_eq!(remote_name, "origin");
        assert!(set_upstream);

        // Configure tracking branch
        let mut git_config = repo.config().unwrap();
        git_config.set_str(&format!("branch.{}.remote", active_branch), "origin").unwrap();
        git_config
            .set_str(
                &format!("branch.{}.merge", active_branch),
                &format!("refs/heads/{}", active_branch),
            )
            .unwrap();

        // Create mock remote tracking reference so resolve succeeds
        let commit_obj = repo.head().unwrap().peel_to_commit().unwrap();
        repo.reference(
            &format!("refs/remotes/origin/{}", active_branch),
            commit_obj.id(),
            true,
            "create mock remote ref",
        )
        .unwrap();

        // Test has_upstream_remote and get_branch_upstream_remote
        assert!(has_upstream_remote(&temp_path, active_branch));
        assert_eq!(
            get_branch_upstream_remote(&temp_path, active_branch),
            Some("origin".to_string())
        );

        // Test push target with tracking branch configured
        let target_tracking = get_branch_push_target(&temp_path, active_branch);
        assert!(target_tracking.is_some());
        let (remote_name_tr, set_upstream_tr) = target_tracking.unwrap();
        assert_eq!(remote_name_tr, "origin");
        assert!(!set_upstream_tr);

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }

    #[test]
    fn test_core_helpers_comprehensive() {
        // 1. format_relative_time
        assert_eq!(format_relative_time(0), "unknown");
        assert_eq!(format_relative_time(-100), "unknown");

        let now_sec = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() as i64;
        assert_eq!(format_relative_time(now_sec - 10), "10 seconds ago");
        assert_eq!(format_relative_time(now_sec - 120), "2 minutes ago");
        assert_eq!(format_relative_time(now_sec - 7200), "2 hours ago");
        assert_eq!(format_relative_time(now_sec - 86400 * 2), "2 days ago");
        assert_eq!(format_relative_time(now_sec - 86400 * 60), "2 months ago");
        assert_eq!(format_relative_time(now_sec - 86400 * 730), "2 years ago");

        // 2. format_utc_date
        assert_eq!(format_utc_date(0), "unknown");
        assert_eq!(format_utc_date(-1), "unknown");
        let date_str = format_utc_date(1700000000);
        assert!(date_str.contains("2023-11-14"));

        // 3. expand_tilde
        assert_eq!(expand_tilde("path"), PathBuf::from("path"));
        let tilde_path = expand_tilde("~/path");
        assert!(tilde_path.is_absolute() || tilde_path.to_string_lossy().contains("path"));

        // 4. sanitize_text
        assert_eq!(sanitize_text("hello\nworld\r\t\x01"), "hello\nworld\r\t ");
        assert_eq!(sanitize_text("hello\x1B[31mworld\x1B B"), "helloworldB");
        assert_eq!(sanitize_text("M4 — UAS"), "M4 — UAS");
        assert_eq!(
            sanitize_text("feat: support utf-8 — – … 🚀 日本語"),
            "feat: support utf-8 — – … 🚀 日本語"
        );

        // 5. safe_sha_slice
        assert_eq!(safe_sha_slice("12345", 10), "12345");
        assert_eq!(safe_sha_slice("12345", 3), "123");

        // 6. safe_ref
        assert_eq!(safe_ref("  refs/heads/main  "), Ok("refs/heads/main"));
        assert!(safe_ref("-invalid").is_err());
        assert!(safe_ref("   ").is_err());

        // 7. RepoSummary helpers
        let mut status = RepoSummary::default();
        assert!(status.is_clean());
        assert!(status.is_synced());
        assert!(status.unchanged());

        status.modified = 1;
        assert!(!status.is_clean());
        assert!(!status.unchanged());

        status.modified = 0;
        status.ahead = 1;
        assert!(!status.is_synced());
        assert!(!status.unchanged());

        // 8. TabData helpers
        let data_not_loaded: TabData<Vec<i32>> = TabData::NotLoaded;
        assert!(data_not_loaded.is_not_loaded());
        assert!(!data_not_loaded.is_loading());
        assert!(!data_not_loaded.is_loaded());
        assert_eq!(data_not_loaded.len(), 0);
        assert!(data_not_loaded.is_empty());
        assert!(data_not_loaded.as_ref().is_none());
        assert!(data_not_loaded.first().is_none());
        assert!(data_not_loaded.get(0).is_none());
        assert_eq!(data_not_loaded.iter().count(), 0);
        assert_eq!(data_not_loaded.as_slice().len(), 0);

        let data_loading: TabData<Vec<i32>> = TabData::Loading;
        assert!(!data_loading.is_not_loaded());
        assert!(data_loading.is_loading());

        let data_loaded = TabData::Loaded(vec![10, 20]);
        assert!(!data_loaded.is_not_loaded());
        assert!(!data_loaded.is_loading());
        assert!(data_loaded.is_loaded());
        assert_eq!(data_loaded.len(), 2);
        assert!(!data_loaded.is_empty());
        assert_eq!(data_loaded.as_ref().unwrap(), &vec![10, 20]);
        assert_eq!(data_loaded.first().unwrap(), &10);
        assert_eq!(data_loaded.get(1).unwrap(), &20);
        assert_eq!(data_loaded.iter().count(), 2);
        assert_eq!(data_loaded.as_slice(), &[10, 20]);
    }

    #[test]
    fn test_comprehensive_gitwig_core_coverage_booster() {
        // 1. Trigger the then_with tie-breaker in collect_committer_stats
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!(
            "twig_test_boost_{}",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
        ));
        std::fs::create_dir_all(&temp_path).unwrap();

        let repo = Repository::init(&temp_path).unwrap();

        // Commit 1 under User A
        {
            let mut config = repo.config().unwrap();
            config.set_str("user.name", "User A").unwrap();
            config.set_str("user.email", "a@example.com").unwrap();
            std::fs::write(temp_path.join("file1.txt"), "content A").unwrap();
            stage_file(&temp_path, "file1.txt").unwrap();
            commit_changes(&temp_path, "commit A").unwrap();
        }

        // Commit 2 under User B (both have 1 commit count)
        {
            let mut config = repo.config().unwrap();
            config.set_str("user.name", "User B").unwrap();
            config.set_str("user.email", "b@example.com").unwrap();
            std::fs::write(temp_path.join("file2.txt"), "content B").unwrap();
            stage_file(&temp_path, "file2.txt").unwrap();
            commit_changes(&temp_path, "commit B").unwrap();
        }

        // Call collect_committer_stats - will sort and execute the then_with closure
        let (stats, _) = collect_committer_stats(&repo, 10).unwrap();
        assert_eq!(stats.len(), 2);
        assert_eq!(stats[0].count, 1);
        assert_eq!(stats[1].count, 1);

        // 2. Trigger deleted file old_file().path() or_else fallback in commit_changed_files
        // Delete file1.txt
        std::fs::remove_file(temp_path.join("file1.txt")).unwrap();
        stage_file(&temp_path, "file1.txt").unwrap();
        commit_changes(&temp_path, "deleted file1").unwrap();
        let head_oid = repo.head().unwrap().target().unwrap().to_string();
        let files = get_commit_files(&temp_path, &head_oid).unwrap();
        assert!(files.iter().any(|f| f.path == "file1.txt" && f.label == "D"));

        // 3. Trigger expand_tilde
        let path_tilde = expand_tilde("~");
        assert!(path_tilde.is_absolute());

        // 4. Trigger calculate_dir_size inside get_lfs_storage_size
        let lfs_dir = temp_path.join(".git").join("lfs");
        std::fs::create_dir_all(&lfs_dir).unwrap();
        let nested_dir = lfs_dir.join("objects").join("xx");
        std::fs::create_dir_all(&nested_dir).unwrap();
        std::fs::write(nested_dir.join("dummy_lfs"), "hello").unwrap();
        let lfs_size = get_lfs_storage_size(&temp_path);
        assert_eq!(lfs_size, Some(5));

        // 5. Trigger load_tab_submodules loop closures
        let mut sub = repo
            .submodule("https://github.com/example/sub.git", Path::new("sub-path"), true)
            .unwrap();
        let _ = sub.init(false);
        let subs = load_tab_submodules(&temp_path).unwrap();
        assert!(!subs.is_empty());

        // 6. Test worktree locking/unlocking/pruning
        let wt_path = temp_path.join("wt-booster");
        let _ = worktree_add(&temp_path, "wt-branch", &wt_path);
        let _ = worktree_lock(&temp_path, &wt_path, "lock reason");
        let _ = worktree_unlock(&temp_path, &wt_path);
        let _ = worktree_prune(&temp_path);
        let _ = std::fs::remove_dir_all(&wt_path);

        // 7. Test open_browser
        open_browser("");

        // 8. Test error paths for almost all gitwig-core functions
        let nonexistent = Path::new("/nonexistent_directory_twig_test");
        let _ = stage_file(nonexistent, "test.txt");
        let _ = unstage_file(nonexistent, "test.txt");
        let _ = discard_all_changes(nonexistent);
        let _ = discard_file_changes(nonexistent, "test.txt", false);
        let _ = commit_changes(nonexistent, "msg");
        let _ = remote_add(nonexistent, "origin", "url");
        let _ = get_file_history(nonexistent, "test.txt");
        let _ = get_file_blame(nonexistent, "test.txt");
        let _ = get_commit_files(nonexistent, "sha");
        let _ = load_tab_reflog(nonexistent);
        let _ = load_tab_files(nonexistent);
        let _ = load_tab_branches(nonexistent);
        let _ = load_tab_tags(nonexistent);
        let _ = load_tab_remotes(nonexistent);
        let _ = load_tab_stashes(nonexistent);
        let _ = load_tab_overview(nonexistent, 10);
        let _ = load_tab_submodules(nonexistent);
        let _ = checkout_remote_branch(nonexistent, "origin/branch");
        let _ = checkout_local_branch(nonexistent, "branch");
        let _ = checkout_tag(nonexistent, "tag");
        let _ = delete_local_branch(nonexistent, "branch");
        let _ = delete_remote_branch(nonexistent, "origin/branch");
        let _ = create_tag(nonexistent, "tag", "sha", None, false);
        let _ = delete_remote_tag(nonexistent, "origin", "tag", Duration::from_secs(5));
        let _ = get_remote_tags(nonexistent, "origin", Duration::from_secs(5));
        let _ = apply_stash(nonexistent, 0);
        let _ = delete_stash(nonexistent, 0);
        let _ = save_stash(nonexistent, "msg", false, false);
        let _ = commit_amend(nonexistent, "msg");
        let _ = resolve_ours(nonexistent, "file");
        let _ = resolve_theirs(nonexistent, "file");
        let _ = resolve_conflict_hunk(nonexistent, "file", 0, true);
        let _ = abort_merge(nonexistent);
        let _ = continue_merge(nonexistent);
        let _ = get_branch_upstream_remote(nonexistent, "branch");
        let _ = load_tab_worktrees(nonexistent);
        let _ = worktree_add(nonexistent, "branch", Path::new("path"));
        let _ = worktree_lock(nonexistent, Path::new("path"), "reason");
        let _ = worktree_unlock(nonexistent, Path::new("path"));
        let _ = worktree_remove(nonexistent, Path::new("path"), true);
        let _ = submodule_remove(nonexistent, "name", Path::new("path"));
        let _ = worktree_prune(nonexistent);
        let _ = load_tab_forge_issues(nonexistent, true);
        let _ = load_tab_forge_prs(nonexistent);
        let _ = load_pr_comments(nonexistent, 1);
        let _ = checkout_pr_branch(nonexistent, 1);
        let _ = resolve_and_checkout_issue_branch(nonexistent, 1);
        let _ = get_remote_url(nonexistent, "origin");
        let _ = get_default_remote_url(nonexistent);
        let _ = get_latest_change_time("/nonexistent");

        let dummy_hunk = vec![
            DiffLine {
                kind: DiffLineKind::Header,
                content: "@@ -1,1 +1,1 @@".to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            },
            DiffLine {
                kind: DiffLineKind::Added,
                content: "line".to_string(),
                old_lineno: None,
                new_lineno: None,
                hunk_idx: None,
            },
        ];
        let _ = stage_line(nonexistent, "file", &dummy_hunk, 1);
        let _ = unstage_line(nonexistent, "file", &dummy_hunk, 1);
        let _ = discard_line(nonexistent, "file", &dummy_hunk, 1);
        let _ = stage_hunk(nonexistent, "file", &dummy_hunk);
        let _ = unstage_hunk(nonexistent, "file", &dummy_hunk);
        let _ = discard_hunk(nonexistent, "file", &dummy_hunk);

        // Clean up
        let _ = std::fs::remove_dir_all(&temp_path);
    }
}