git-loom 0.20.1

use anyhow::{Context, Result, bail};
use git2::{Repository, StatusOptions};
use serde::{Deserialize, Serialize};
use std::path::Path;

use crate::core::diff;
use crate::core::graph;
use crate::core::msg;
use crate::core::repo::{self, Target, TargetKind};
use crate::core::staging;
use crate::core::transaction::{self, LoomState, Rollback};
use crate::core::weave::{self, RebaseOutcome, Weave};
use crate::git;
use crate::tui::hunk_selector::FileEntry;

#[derive(Serialize, Deserialize)]
#[serde(tag = "op")]
enum FoldVariant {
    FilesIntoCommit {
        original_commit_hash: String,
        files_count: usize,
        saved_staged: String,
    },
    CommitIntoCommit {
        source_hash: String,
        target_hash: String,
    },
    CommitToBranch {
        commit_hash: String,
        branch_name: String,
    },
    CommitToUnstaged {
        commit_hash: String,
        diff: String,
    },
}

/// Temporary branch used to track a commit's new OID through a rebase.
const TRACK_BRANCH: &str = "_loom-track";
const COMMAND: &str = "fold";

/// Fold source(s) into a target.
///
/// Dispatches to the appropriate operation based on argument types:
/// - File(s) + Commit → amend files into the commit
/// - Commit + Commit  → fixup source into target (source disappears)
/// - Commit + Branch   → move commit to the branch
///
/// With `--create` (`-c`): create a new branch and move the source commit into it.
pub fn run(create: bool, patch: bool, args: Vec<String>, theme: &graph::Theme) -> Result<()> {
    if args.is_empty() {
        bail!(
            "At least one argument required\n\
             Usage: git-loom fold [<source>...] <target>"
        );
    }

    let repo = repo::open_repo()?;

    if create {
        return run_create(&repo, &args);
    }

    if patch {
        return run_patch_fold(&repo, &args, theme);
    }

    // Single argument: fold staged files into the target commit
    if args.len() == 1 {
        return run_staged(&repo, &args[0]);
    }

    // Last argument is the target, everything else is a source
    let (source_args, target_arg) = args.split_at(args.len() - 1);
    let target_arg = &target_arg[0];

    // If any source is "zz", expand to all changed files (zz takes precedence)
    let source_args = if source_args.iter().any(|s| s == "zz") {
        let files = collect_changed_files(&repo)?;
        if files.is_empty() {
            bail!("No changes to fold — working tree is clean");
        }
        files
    } else {
        source_args.to_vec()
    };

    // Resolve all arguments
    let resolved_sources: Vec<Target> = source_args
        .iter()
        .map(|s| {
            repo::resolve_arg(
                &repo,
                s,
                &[
                    TargetKind::Commit,
                    TargetKind::CommitFile,
                    TargetKind::File,
                    TargetKind::Unstaged,
                ],
            )
        })
        .collect::<Result<Vec<_>, _>>()?;
    let resolved_target = repo::resolve_arg(
        &repo,
        target_arg,
        &[
            TargetKind::Branch,
            TargetKind::Commit,
            TargetKind::CommitFile,
            TargetKind::File,
            TargetKind::Unstaged,
        ],
    )?;

    // Classify and dispatch
    match classify(&resolved_sources, &resolved_target)? {
        FoldOp::FilesIntoCommit { files, commit } => {
            fold_files_into_commit(&repo, &files, &commit, false)
        }
        FoldOp::CommitIntoCommit { source, target } => {
            fold_commit_into_commit(&repo, &source, &target)
        }
        FoldOp::CommitToBranch { commit, branch } => fold_commit_to_branch(&repo, &commit, &branch),
        FoldOp::CommitToUnstaged { commit } => fold_commit_to_unstaged(&repo, &commit),
        FoldOp::CommitFileToUnstaged { commit, path } => {
            fold_commit_file_to_unstaged(&repo, &commit, &path)
        }
        FoldOp::CommitFileToCommit {
            source_commit,
            path,
            target_commit,
        } => fold_commit_file_to_commit(&repo, &source_commit, &path, &target_commit),
    }
}

/// Create a new branch and move the source commit(s) into it.
///
/// `args` must be `[<commit>..., <new-branch-name>]` — one or more commits
/// followed by the new branch name. The branch is created at the merge-base,
/// then the commits are moved to it using the same Weave machinery as the
/// normal commit-to-branch fold.
fn run_create(repo: &Repository, args: &[String]) -> Result<()> {
    if args.len() < 2 {
        bail!(
            "fold --create requires at least one commit and one new branch name\n\
             Usage: loom fold -c <commit>... <new-branch>"
        );
    }

    let (source_args, branch_name) = args.split_at(args.len() - 1);
    let branch_name = &branch_name[0];
    let workdir = repo::require_workdir(repo, COMMAND)?;

    // Resolve sources — all must be commits
    let mut commit_hashes = Vec::new();
    for source_arg in source_args {
        let source = repo::resolve_arg(repo, source_arg, &[TargetKind::Commit])?;
        match source {
            Target::Commit(hash) => commit_hashes.push(hash),
            _ => unreachable!(),
        }
    }

    // Order oldest-first so the commits land on the branch in history order.
    let commit_hashes = sort_commits_oldest_first(repo, commit_hashes)?;

    git::branch_validate_name(workdir, branch_name)?;

    // If the branch already exists, warn and fall through to a normal move.
    let branch_exists = repo
        .find_branch(branch_name, git2::BranchType::Local)
        .is_ok();
    if branch_exists {
        msg::warn(&format!(
            "Branch `{}` already exists — moving commit(s) to it",
            branch_name
        ));
        // A single commit keeps the resumable commit-to-branch path.
        if commit_hashes.len() == 1 {
            return fold_commit_to_branch(repo, &commit_hashes[0], branch_name);
        }
        return move_commits_and_report(workdir, repo, &commit_hashes, branch_name, None);
    }

    // Create the branch at the merge-base so it has no commits of its own yet;
    // move_commits_to_branch will add a section for it in the Weave graph.
    let info = repo::gather_repo_info(repo, false, 1).ok();
    let base_hash = match &info {
        Some(info) => info.upstream.merge_base_oid.to_string(),
        None => bail!(
            "Cannot create branch: no upstream tracking branch configured\n\
             Use 'loom branch <name> -t <commit>' instead"
        ),
    };

    move_commits_and_report(workdir, repo, &commit_hashes, branch_name, Some(&base_hash))
}

/// Sort commit hashes oldest-first (ancestors before descendants), removing
/// duplicates. Unrelated commits are ordered by committer time.
fn sort_commits_oldest_first(repo: &Repository, hashes: Vec<String>) -> Result<Vec<String>> {
    let mut oids: Vec<git2::Oid> = Vec::new();
    for h in &hashes {
        let oid = git2::Oid::from_str(h)?;
        if !oids.contains(&oid) {
            oids.push(oid);
        }
    }

    oids.sort_by(|a, b| {
        if a == b {
            return std::cmp::Ordering::Equal;
        }
        if repo.graph_descendant_of(*a, *b).unwrap_or(false) {
            std::cmp::Ordering::Greater // a is newer → later
        } else if repo.graph_descendant_of(*b, *a).unwrap_or(false) {
            std::cmp::Ordering::Less // a is older → earlier
        } else {
            // Unrelated commits: fall back to committer time.
            let ta = repo
                .find_commit(*a)
                .map(|c| c.time().seconds())
                .unwrap_or(0);
            let tb = repo
                .find_commit(*b)
                .map(|c| c.time().seconds())
                .unwrap_or(0);
            ta.cmp(&tb)
        }
    });

    Ok(oids.iter().map(|o| o.to_string()).collect())
}

/// Move `commit_hashes` to `branch_name` and report the result.
///
/// When `base_hash` is `Some`, the branch is created at that base first (and
/// deleted again on failure). On conflict the rebase is aborted — this path is
/// not resumable.
fn move_commits_and_report(
    workdir: &Path,
    repo: &Repository,
    commit_hashes: &[String],
    branch_name: &str,
    base_hash: Option<&str>,
) -> Result<()> {
    let created = base_hash.is_some();
    if let Some(base) = base_hash {
        git::branch_create(workdir, branch_name, base)?;
    }

    match move_commits_to_branch(repo, commit_hashes, branch_name) {
        Ok(RebaseOutcome::Completed) => {}
        Ok(RebaseOutcome::Conflicted) => {
            let _ = git::rebase_abort(workdir);
            if created {
                let _ = git::branch_delete(workdir, branch_name);
            }
            bail!("Rebase failed with conflicts — aborted");
        }
        Err(e) => {
            if created {
                let _ = git::branch_delete(workdir, branch_name);
            }
            return Err(e);
        }
    }

    let new_hash = git::rev_parse(workdir, branch_name)?;
    if created {
        msg::success(&format!(
            "Created branch `{}` and moved {} commit(s) to it (now `{}`)",
            branch_name,
            commit_hashes.len(),
            git::short_hash(&new_hash)
        ));
    } else {
        msg::success(&format!(
            "Moved {} commit(s) to branch `{}` (now `{}`)",
            commit_hashes.len(),
            branch_name,
            git::short_hash(&new_hash)
        ));
    }

    Ok(())
}

/// Fold interactively-selected hunks into a target commit, or move/uncommit
/// hunks from a source commit.
///
/// Forms:
/// - `fold -p [<files>...] <commit>` — pick working-tree hunks, fold into commit
/// - `fold -p <commit1> <commit2>` — pick hunks from commit1 to move into commit2
/// - `fold -p <commit> zz` — pick hunks from commit to uncommit to working tree
fn run_patch_fold(repo: &Repository, args: &[String], theme: &graph::Theme) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    let (target_arg, source_args) = args.split_last().expect("args is non-empty");

    // Detect commit-source forms: fold -p <commit> <commit|zz>
    if source_args.len() == 1 {
        let source_arg = &source_args[0];
        if let Ok(Target::Commit(source_hash)) =
            repo::resolve_arg(repo, source_arg, &[TargetKind::Commit])
        {
            if target_arg == "zz" {
                return run_patch_fold_commit_to_unstaged(repo, workdir, &source_hash, theme);
            }
            if let Ok(Target::Commit(target_hash)) =
                repo::resolve_arg(repo, target_arg, &[TargetKind::Commit])
            {
                return run_patch_fold_commit_to_commit(
                    repo,
                    workdir,
                    &source_hash,
                    &target_hash,
                    theme,
                );
            }
        }
    }

    // Working-tree hunk fold: validate sources are files/zz (not commits/branches).
    for arg in source_args {
        if arg == "zz" {
            continue;
        }
        match repo::resolve_arg(
            repo,
            arg,
            &[TargetKind::File, TargetKind::Commit, TargetKind::Branch],
        ) {
            Ok(Target::Commit(_)) | Ok(Target::Branch(_)) => bail!(
                "fold -p does not support commit or branch sources\n\
                 Use file paths, short IDs, or 'zz' to filter the hunk picker"
            ),
            Ok(_) => {}
            Err(e) => return Err(e),
        }
    }

    let resolved = repo::resolve_arg(repo, target_arg, &[TargetKind::Commit])?;
    let commit_hash = match resolved {
        Target::Commit(hash) => hash,
        _ => unreachable!(),
    };

    let confirmed = staging::run_hunk_picker(repo, workdir, source_args, theme)?;
    if !confirmed {
        bail!("Cancelled");
    }

    let staged = repo::get_staged_files(repo)?;
    if staged.is_empty() {
        bail!("Nothing to commit");
    }
    fold_files_into_commit(repo, &staged, &commit_hash, true)
}

/// Build a unified diff patch from the selected text hunks across all files.
fn build_selected_patch(selections: &[FileEntry]) -> String {
    let mut patch = String::new();
    for file in selections {
        if file.binary {
            continue;
        }
        let selected: Vec<_> = file
            .hunks
            .iter()
            .filter(|h| h.selected)
            .map(|h| &h.hunk)
            .collect();
        if !selected.is_empty() {
            patch.push_str(&diff::build_hunk_patch(&file.path, &selected));
        }
    }
    patch
}

/// At a rebase edit pause: apply (or reverse-apply) a single-file patch, stage the path, amend.
fn apply_and_amend_path(workdir: &Path, patch: &str, path: &str, reverse: bool) -> Result<()> {
    if reverse {
        git::apply_patch_reverse(workdir, patch)?;
    } else {
        git::apply_patch(workdir, patch)?;
    }
    git::stage_path(workdir, path)?;
    git::commit_amend_no_edit(workdir)
}

/// At a rebase edit pause: apply (or reverse-apply) patch, stage affected files, amend.
fn apply_and_amend(
    workdir: &Path,
    selections: &[FileEntry],
    patch: &str,
    reverse: bool,
) -> Result<()> {
    if reverse {
        git::apply_patch_reverse(workdir, patch)?;
    } else {
        git::apply_patch(workdir, patch)?;
    }
    for file in selections {
        if file.hunks.iter().any(|h| h.selected) {
            git::stage_path(workdir, &file.path)?;
        }
    }
    git::commit_amend_no_edit(workdir)
}

/// Pick hunks from `source_hash` to move into `target_hash`.
///
/// Selected hunks are removed from source and added to target via a two-phase
/// edit+continue rebase. Requires source to be newer than target.
fn run_patch_fold_commit_to_commit(
    repo: &Repository,
    workdir: &Path,
    source_hash: &str,
    target_hash: &str,
    theme: &graph::Theme,
) -> Result<()> {
    let source_oid = git2::Oid::from_str(source_hash)?;
    let target_oid = git2::Oid::from_str(target_hash)?;

    if source_oid == target_oid {
        bail!("Source and target are the same commit");
    }
    if !repo.graph_descendant_of(source_oid, target_oid)? {
        bail!("Source commit must be newer than target commit");
    }

    let selections = staging::run_commit_hunk_picker(workdir, source_hash, &[], theme)?
        .ok_or_else(|| anyhow::anyhow!("Cancelled"))?;

    if !selections
        .iter()
        .any(|f| f.hunks.iter().any(|h| h.selected))
    {
        bail!("No hunks selected");
    }

    let selected_patch = build_selected_patch(&selections);
    if selected_patch.is_empty() {
        bail!("No text hunks selected — binary and deleted files are not supported with -p");
    }

    let saved_head = repo::head_oid(repo)?.to_string();
    let saved_refs = repo::snapshot_branch_refs(repo)?;

    // Save and unstage any pre-existing staged changes so they don't accidentally
    // get included in the amend operations below.
    let saved_staged = staging::save_and_unstage_staged(repo, workdir)?;

    // Phase 1: edit source, remove selected hunks.
    let mut graph = Weave::from_repo(repo)?;
    graph.edit_commit(source_oid);
    let todo = graph.to_todo();
    git::branch_force_create(workdir, TRACK_BRANCH, target_hash)?;

    if let Err(e) = weave::run_rebase_or_abort(workdir, Some(&graph.base_oid.to_string()), &todo) {
        let _ = git::branch_delete(workdir, TRACK_BRANCH);
        let _ = git::restore_staged_patch(workdir, &saved_staged);
        return Err(e);
    }

    if let Err(e) = apply_and_amend(workdir, &selections, &selected_patch, true) {
        let _ = git::rebase_abort(workdir);
        let _ = git::branch_delete(workdir, TRACK_BRANCH);
        let _ = git::restore_staged_patch(workdir, &saved_staged);
        return Err(e);
    }

    let new_source_hash = git::rev_parse(workdir, "HEAD")?;

    if let Err(e) = git::continue_rebase_or_abort(workdir) {
        let _ = git::branch_delete(workdir, TRACK_BRANCH);
        let _ = git::restore_staged_patch(workdir, &saved_staged);
        return Err(e);
    }

    // Phase 2: edit target (new OID tracked via TRACK_BRANCH), add selected hunks.
    let phase2_target_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
    let _ = git::branch_delete(workdir, TRACK_BRANCH);
    let phase2_target_oid = git2::Oid::from_str(&phase2_target_hash)?;

    // Re-open repo after phase 1 rebase (OIDs changed)
    let repo2 = Repository::open(workdir)?;
    let mut graph2 = Weave::from_repo(&repo2)?;
    graph2.edit_commit(phase2_target_oid);
    let todo2 = graph2.to_todo();

    let rollback = |saved_head: &str, saved_refs: &std::collections::HashMap<String, git2::Oid>| {
        let _ = git::reset_hard(workdir, saved_head);
        if let Err(re) = repo::restore_branch_refs(workdir, saved_refs) {
            msg::warn(&format!("failed to restore branch refs: {re}"));
        }
    };

    if let Err(e) = weave::run_rebase_or_abort(workdir, Some(&graph2.base_oid.to_string()), &todo2)
    {
        rollback(&saved_head, &saved_refs);
        let _ = git::restore_staged_patch(workdir, &saved_staged);
        return Err(e);
    }

    if let Err(e) = apply_and_amend(workdir, &selections, &selected_patch, false) {
        let _ = git::rebase_abort(workdir);
        rollback(&saved_head, &saved_refs);
        let _ = git::restore_staged_patch(workdir, &saved_staged);
        return Err(e);
    }

    let new_target_hash = git::rev_parse(workdir, "HEAD")?;

    if let Err(e) = git::continue_rebase_or_abort(workdir) {
        rollback(&saved_head, &saved_refs);
        let _ = git::restore_staged_patch(workdir, &saved_staged);
        return Err(e);
    }

    git::restore_staged_patch(workdir, &saved_staged)?;

    msg::success(&format!(
        "Moved hunk(s) from `{}` (now `{}`) into `{}` (now `{}`)",
        git::short_hash(source_hash),
        git::short_hash(&new_source_hash),
        git::short_hash(target_hash),
        git::short_hash(&new_target_hash)
    ));

    Ok(())
}

/// Pick hunks from `commit_hash` to uncommit back into the working tree.
///
/// Selected hunks are removed from the commit and left unstaged.
fn run_patch_fold_commit_to_unstaged(
    repo: &Repository,
    workdir: &Path,
    commit_hash: &str,
    theme: &graph::Theme,
) -> Result<()> {
    let selections = staging::run_commit_hunk_picker(workdir, commit_hash, &[], theme)?
        .ok_or_else(|| anyhow::anyhow!("Cancelled"))?;

    if !selections
        .iter()
        .any(|f| f.hunks.iter().any(|h| h.selected))
    {
        bail!("No hunks selected");
    }

    let selected_patch = build_selected_patch(&selections);
    if selected_patch.is_empty() {
        bail!("No text hunks selected — binary and deleted files are not supported with -p");
    }

    let head_oid = repo::head_oid(repo)?;
    let target_oid = git2::Oid::from_str(commit_hash)?;
    let is_head = head_oid == target_oid;

    // Save and unstage any pre-existing staged changes so they don't accidentally
    // get included in the amend operation below.
    let saved_staged = staging::save_and_unstage_staged(repo, workdir)?;

    let new_hash;

    if is_head {
        let pre_amend_hash = head_oid.to_string();
        git::apply_patch_reverse(workdir, &selected_patch)?;
        for file in &selections {
            if file.hunks.iter().any(|h| h.selected) {
                git::stage_path(workdir, &file.path)?;
            }
        }
        git::commit_amend_no_edit(workdir)?;
        new_hash = git::rev_parse(workdir, "HEAD")?;
        if let Err(e) = git::apply_patch(workdir, &selected_patch) {
            let _ = git::reset_hard(workdir, &pre_amend_hash);
            let _ = git::restore_staged_patch(workdir, &saved_staged);
            return Err(e)
                .context("Failed to restore hunks to working directory, operation rolled back");
        }
    } else {
        let saved_head = head_oid.to_string();
        let saved_refs = repo::snapshot_branch_refs(repo)?;

        let mut graph = Weave::from_repo(repo)?;
        graph.edit_commit(target_oid);
        let todo = graph.to_todo();
        if let Err(e) =
            weave::run_rebase_or_abort(workdir, Some(&graph.base_oid.to_string()), &todo)
        {
            let _ = git::restore_staged_patch(workdir, &saved_staged);
            return Err(e);
        }

        if let Err(e) = apply_and_amend(workdir, &selections, &selected_patch, true) {
            let _ = git::rebase_abort(workdir);
            let _ = git::restore_staged_patch(workdir, &saved_staged);
            return Err(e);
        }

        new_hash = git::rev_parse(workdir, "HEAD")?;
        git::continue_rebase_or_abort(workdir)?;

        if let Err(e) = git::apply_patch(workdir, &selected_patch) {
            let _ = git::reset_hard(workdir, &saved_head);
            if let Err(re) = repo::restore_branch_refs(workdir, &saved_refs) {
                msg::warn(&format!("failed to restore branch refs: {re}"));
            }
            let _ = git::restore_staged_patch(workdir, &saved_staged);
            return Err(e)
                .context("Failed to apply changes to working directory, operation rolled back");
        }
    }

    git::restore_staged_patch(workdir, &saved_staged)?;

    msg::success(&format!(
        "Uncommitted hunk(s) from `{}` (now `{}`) to working directory",
        git::short_hash(commit_hash),
        git::short_hash(&new_hash)
    ));

    Ok(())
}

/// Fold currently staged files into a target commit.
///
/// Single-argument form: `loom fold <target>`. The target must resolve to a
/// commit. If nothing is staged, bails with the same message as `loom commit`.
fn run_staged(repo: &Repository, target_arg: &str) -> Result<()> {
    let resolved = repo::resolve_arg(repo, target_arg, &[TargetKind::Commit])?;
    let commit_hash = match resolved {
        Target::Commit(hash) => hash,
        _ => unreachable!(),
    };

    let staged = repo::get_staged_files(repo)?;
    if staged.is_empty() {
        bail!("Nothing to commit");
    }
    fold_files_into_commit(repo, &staged, &commit_hash, true)
}

/// The classified fold operation.
#[derive(Debug)]
enum FoldOp {
    FilesIntoCommit {
        files: Vec<String>,
        commit: String,
    },
    CommitIntoCommit {
        source: String,
        target: String,
    },
    CommitToBranch {
        commit: String,
        branch: String,
    },
    CommitToUnstaged {
        commit: String,
    },
    /// Uncommit a single file from a commit to the working directory.
    CommitFileToUnstaged {
        commit: String,
        path: String,
    },
    /// Move a file's changes from one commit to another.
    CommitFileToCommit {
        source_commit: String,
        path: String,
        target_commit: String,
    },
}

/// Classify resolved arguments into a specific fold operation.
fn classify(sources: &[Target], target: &Target) -> Result<FoldOp> {
    // Check for invalid source types
    for source in sources {
        if matches!(source, Target::Branch(_)) {
            bail!("Cannot fold a branch\nUse `git loom branch` for branch operations");
        }
    }

    // Reject CommitFile as target
    if matches!(target, Target::CommitFile { .. }) {
        bail!("Target must be a commit, branch, or unstaged (zz), not a commit file");
    }

    let has_files = sources.iter().any(|s| matches!(s, Target::File(_)));
    let has_commits = sources.iter().any(|s| matches!(s, Target::Commit(_)));
    let has_commit_files = sources
        .iter()
        .any(|s| matches!(s, Target::CommitFile { .. }));

    // Reject mixed source types
    if [has_files, has_commits, has_commit_files]
        .iter()
        .filter(|&&x| x)
        .count()
        > 1
    {
        bail!("Cannot mix different source types (files, commits, commit files)");
    }

    // Handle CommitFile sources (file within a commit)
    if has_commit_files {
        if sources.len() > 1 {
            bail!("Only one commit file source is allowed");
        }
        let (commit, path) = match &sources[0] {
            Target::CommitFile { commit, path } => (commit.clone(), path.clone()),
            _ => unreachable!(),
        };

        return match target {
            Target::Unstaged => Ok(FoldOp::CommitFileToUnstaged { commit, path }),
            Target::Commit(hash) => Ok(FoldOp::CommitFileToCommit {
                source_commit: commit,
                path,
                target_commit: hash.clone(),
            }),
            Target::Branch(_) => {
                bail!(
                    "Cannot fold a commit file into a branch\n\
                     Target a specific commit or use `zz` to uncommit"
                )
            }
            Target::File(_) => bail!("Target must be a commit or unstaged (zz), not a file"),
            Target::CommitFile { .. } => unreachable!(),
        };
    }

    // Handle Unstaged target
    if matches!(target, Target::Unstaged) {
        if has_files {
            bail!("Cannot fold files into unstaged — files are already in the working directory");
        }

        if sources.len() > 1 {
            bail!("Only one commit source is allowed");
        }

        let source_hash = match &sources[0] {
            Target::Commit(hash) => hash.clone(),
            _ => unreachable!(),
        };

        return Ok(FoldOp::CommitToUnstaged {
            commit: source_hash,
        });
    }

    if has_files {
        // File(s) + target
        let files: Vec<String> = sources
            .iter()
            .map(|s| match s {
                Target::File(path) => path.clone(),
                _ => unreachable!(),
            })
            .collect();

        match target {
            Target::Commit(hash) => Ok(FoldOp::FilesIntoCommit {
                files,
                commit: hash.clone(),
            }),
            Target::Branch(_) => {
                bail!("Cannot fold files into a branch\nTarget a specific commit")
            }
            Target::File(_) => bail!("Target must be a commit or branch, not a file"),
            _ => unreachable!(),
        }
    } else {
        // Commit(s) + target
        if sources.len() > 1 {
            bail!("Only one commit source is allowed");
        }

        let source_hash = match &sources[0] {
            Target::Commit(hash) => hash.clone(),
            _ => unreachable!(),
        };

        match target {
            Target::Commit(hash) => Ok(FoldOp::CommitIntoCommit {
                source: source_hash,
                target: hash.clone(),
            }),
            Target::Branch(name) => Ok(FoldOp::CommitToBranch {
                commit: source_hash,
                branch: name.clone(),
            }),
            Target::File(_) => bail!("Target must be a commit or branch, not a file"),
            _ => unreachable!(),
        }
    }
}

/// Collect all file paths with staged or unstaged changes.
fn collect_changed_files(repo: &Repository) -> Result<Vec<String>> {
    let mut opts = StatusOptions::new();
    opts.include_untracked(true).recurse_untracked_dirs(true);
    let statuses = repo.statuses(Some(&mut opts))?;
    let mut paths = Vec::new();
    for entry in statuses.iter() {
        if let Some(path) = entry.path() {
            paths.push(path.to_string());
        }
    }
    Ok(paths)
}

/// Fold file changes into a commit (Case 1: File(s) + Commit).
///
/// When `skip_staging` is true the caller has already staged exactly the right
/// content (e.g. from a hunk picker), so the file-level `git add` is skipped.
fn fold_files_into_commit(
    repo: &Repository,
    files: &[String],
    commit_hash: &str,
    skip_staging: bool,
) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    if !skip_staging {
        for file in files {
            if !repo::path_has_changes(repo, file)? {
                bail!("File '{}' has no changes to fold", file);
            }
        }
    }

    let head_oid = repo::head_oid(repo)?;
    let target_oid = git2::Oid::from_str(commit_hash)?;
    let is_head = head_oid == target_oid;

    let file_refs: Vec<&str> = files.iter().map(|s| s.as_str()).collect();

    // Save and unstage any pre-existing staged files not in our target list,
    // so they don't accidentally end up in this commit/amend.
    let saved_staged = staging::save_and_unstage_other_staged(repo, workdir, &file_refs)?;

    let new_hash;

    if is_head {
        if !skip_staging {
            git::stage_files(workdir, &file_refs)?;
        }
        if let Err(e) = git::commit_amend_no_edit(workdir) {
            if !skip_staging {
                let _ = git::unstage_files(workdir, &file_refs);
            }
            let _ = git::restore_staged_patch(workdir, &saved_staged);
            return Err(e);
        }
        git::restore_staged_patch(workdir, &saved_staged)?;
        new_hash = git::rev_parse(workdir, "HEAD")?;
    } else {
        // Create a fixup commit on HEAD with only the changed files, then
        // use the weave machinery to squash it into the target commit.
        // This avoids fragile file-restoration that can fail on Windows
        // (os error 5) when files are locked by editors or indexers.
        let target_commit = repo.find_commit(target_oid)?;
        let subject = target_commit.summary().unwrap_or("fixup");
        let message = format!("fixup! {}", subject);

        if !skip_staging {
            git::stage_files(workdir, &file_refs)?;
        }
        if let Err(e) = git::commit(workdir, &message) {
            if !skip_staging {
                let _ = git::unstage_files(workdir, &file_refs);
            }
            let _ = git::restore_staged_patch(workdir, &saved_staged);
            return Err(e);
        }

        let fixup_hash = git::rev_parse(workdir, "HEAD")?;
        let fixup_oid = git2::Oid::from_str(&fixup_hash)?;

        // Re-open repo after creating the fixup commit (OIDs changed)
        let repo2 = Repository::open(workdir)?;
        let mut graph = Weave::from_repo(&repo2)?;
        graph.fixup_commit(fixup_oid, target_oid)?;

        // Track target commit through the rebase via a temp branch.
        // The branch must exist before the rebase AND have an update-ref
        // line in the todo so git keeps it in sync.
        git::branch_force_create(workdir, TRACK_BRANCH, commit_hash)?;
        graph.track_commit(target_oid, TRACK_BRANCH);

        let git_dir = repo.path().to_path_buf();
        let fold_ctx = serde_json::to_value(FoldVariant::FilesIntoCommit {
            original_commit_hash: commit_hash.to_string(),
            files_count: files.len(),
            saved_staged: saved_staged.clone(),
        })?;
        // saved_staged is stored in both rollback (for `loom abort`) and context
        // (for `loom continue` → after_continue). Both paths are required.
        let loom_state = LoomState {
            command: COMMAND.to_string(),
            rollback: Rollback {
                saved_staged_patch: saved_staged.clone(),
                delete_branches: vec![TRACK_BRANCH.to_string()],
                ..Default::default()
            },
            context: fold_ctx,
        };
        transaction::save(&git_dir, &loom_state)?;

        let todo = graph.to_todo();
        match weave::run_rebase(workdir, Some(&graph.base_oid.to_string()), &todo)? {
            RebaseOutcome::Completed => {
                transaction::delete(&git_dir)?;
                git::restore_staged_patch(workdir, &saved_staged)?;
                new_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
                let _ = git::branch_delete(workdir, TRACK_BRANCH);
            }
            RebaseOutcome::Conflicted => {
                transaction::warn_conflict_paused(COMMAND);
                return Ok(());
            }
        }
    }

    msg::success(&format!(
        "Folded {} file(s) into `{}` (now `{}`)",
        files.len(),
        git::short_hash(commit_hash),
        git::short_hash(&new_hash)
    ));

    Ok(())
}

/// Fold a commit into another commit (Case 2: Commit + Commit → Fixup).
fn fold_commit_into_commit(repo: &Repository, source_hash: &str, target_hash: &str) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    let source_oid = git2::Oid::from_str(source_hash)?;
    let target_oid = git2::Oid::from_str(target_hash)?;

    if source_oid == target_oid {
        bail!("Source and target are the same commit");
    }

    if !repo.graph_descendant_of(source_oid, target_oid)? {
        bail!("Source commit must be newer than target commit");
    }

    let mut graph = Weave::from_repo(repo)?;
    graph.fixup_commit(source_oid, target_oid)?;

    // Track target commit through the rebase via a temp branch.
    git::branch_force_create(workdir, TRACK_BRANCH, target_hash)?;
    graph.track_commit(target_oid, TRACK_BRANCH);

    let git_dir = repo.path().to_path_buf();
    let fold_ctx = serde_json::to_value(FoldVariant::CommitIntoCommit {
        source_hash: source_hash.to_string(),
        target_hash: target_hash.to_string(),
    })?;
    let loom_state = LoomState {
        command: COMMAND.to_string(),
        rollback: Rollback {
            delete_branches: vec![TRACK_BRANCH.to_string()],
            ..Default::default()
        },
        context: fold_ctx,
    };
    transaction::save(&git_dir, &loom_state)?;

    let todo = graph.to_todo();
    match weave::run_rebase(workdir, Some(&graph.base_oid.to_string()), &todo)? {
        RebaseOutcome::Completed => {
            transaction::delete(&git_dir)?;
            let new_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
            let _ = git::branch_delete(workdir, TRACK_BRANCH);
            msg::success(&format!(
                "Folded `{}` into `{}` (now `{}`)",
                git::short_hash(source_hash),
                git::short_hash(target_hash),
                git::short_hash(&new_hash)
            ));
        }
        RebaseOutcome::Conflicted => {
            transaction::warn_conflict_paused(COMMAND);
        }
    }

    Ok(())
}

/// Move a commit to a branch (Case 3: Commit + Branch → Move).
fn fold_commit_to_branch(repo: &Repository, commit_hash: &str, branch_name: &str) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;
    let git_dir = repo.path().to_path_buf();

    let ctx = serde_json::to_value(FoldVariant::CommitToBranch {
        commit_hash: commit_hash.to_string(),
        branch_name: branch_name.to_string(),
    })?;
    let state = LoomState {
        command: COMMAND.to_string(),
        rollback: Rollback::default(),
        context: ctx,
    };
    transaction::save(&git_dir, &state)?;

    match move_commit_to_branch(repo, commit_hash, branch_name)? {
        RebaseOutcome::Completed => {
            transaction::delete(&git_dir)?;
            let new_hash = git::rev_parse(workdir, branch_name)?;
            msg::success(&format!(
                "Moved `{}` to branch `{}` (now `{}`)",
                git::short_hash(commit_hash),
                branch_name,
                git::short_hash(&new_hash)
            ));
        }
        RebaseOutcome::Conflicted => {
            transaction::warn_conflict_paused(COMMAND);
        }
    }

    Ok(())
}

/// Move a commit to the tip of a branch using Weave.
///
/// Returns `RebaseOutcome` — callers are responsible for building and saving
/// their own `LoomState` before calling this function.
pub fn move_commit_to_branch(
    repo: &Repository,
    commit_hash: &str,
    branch_name: &str,
) -> Result<RebaseOutcome> {
    move_commits_to_branch(
        repo,
        std::slice::from_ref(&commit_hash.to_string()),
        branch_name,
    )
}

/// Move one or more commits to the tip of a branch using Weave.
///
/// Commits are appended in the order given, so callers that care about the
/// resulting history order should pass them oldest-first. Returns
/// `RebaseOutcome` — callers build and save their own `LoomState`.
pub fn move_commits_to_branch(
    repo: &Repository,
    commit_hashes: &[String],
    branch_name: &str,
) -> Result<RebaseOutcome> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    let mut graph = Weave::from_repo(repo)?;

    // If the target branch has no section in the Weave graph, create one.
    // This happens when the branch is at the merge-base (no commits of its
    // own) — either it was never woven, or a previous rebase dropped the
    // degenerate merge (merging two identical commits is a no-op for git).
    // Same pattern as commit.rs for empty branches.
    let has_section = graph
        .branch_sections
        .iter()
        .any(|s| s.label == branch_name || s.branch_names.contains(&branch_name.to_string()));
    if !has_section {
        // Only allow creating a synthetic section for branches that are
        // at the merge-base (empty) or don't exist yet. Reject branches
        // that have diverged — they are out of scope.
        if let Ok(branch) = repo.find_branch(branch_name, git2::BranchType::Local) {
            let branch_oid = branch
                .get()
                .peel_to_commit()
                .map(|c| c.id())
                .unwrap_or(git2::Oid::zero());
            if branch_oid != graph.base_oid {
                bail!(
                    "Branch '{}' exists but is not part of the current integration scope.\n\
                     Use `loom branch merge {}` to weave it first.",
                    branch_name,
                    branch_name
                );
            }
        }
        graph.add_branch_section(
            branch_name.to_string(),
            vec![branch_name.to_string()],
            vec![],
            "onto".to_string(),
        );
        graph.add_merge(branch_name.to_string(), None, None);
    }

    for commit_hash in commit_hashes {
        let commit_oid = git2::Oid::from_str(commit_hash)?;
        graph.move_commit(commit_oid, branch_name)?;
    }

    let todo = graph.to_todo();
    weave::run_rebase(workdir, Some(&graph.base_oid.to_string()), &todo)
}

/// Uncommit a single file from a commit to the working directory.
///
/// Removes the file's changes from the commit and places them in the working
/// directory as unstaged modifications. The commit itself is preserved (minus
/// the file's changes).
fn fold_commit_file_to_unstaged(repo: &Repository, commit_hash: &str, path: &str) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    let head_oid = repo::head_oid(repo)?;
    let target_oid = git2::Oid::from_str(commit_hash)?;
    let is_head = head_oid == target_oid;

    let file_diff = git::diff_commit_file(workdir, commit_hash, path)?;
    if file_diff.is_empty() {
        bail!(
            "File '{}' has no changes in commit {}",
            path,
            git::short_hash(commit_hash)
        );
    }

    let new_hash;

    if is_head {
        let saved_head = head_oid.to_string();
        apply_and_amend_path(workdir, &file_diff, path, true)?;
        new_hash = git::rev_parse(workdir, "HEAD")?;
        if let Err(e) = git::apply_patch(workdir, &file_diff) {
            let _ = git::reset_hard(workdir, &saved_head);
            return Err(e).context("Failed to uncommit file, operation rolled back");
        }
    } else {
        // Non-HEAD: edit+continue pattern with save-head rollback
        let saved_head = head_oid.to_string();
        let saved_refs = repo::snapshot_branch_refs(repo)?;

        let mut graph = Weave::from_repo(repo)?;
        graph.edit_commit(target_oid);

        let todo = graph.to_todo();
        weave::run_rebase_or_abort(workdir, Some(&graph.base_oid.to_string()), &todo)?;

        if let Err(e) = apply_and_amend_path(workdir, &file_diff, path, true) {
            let _ = git::rebase_abort(workdir);
            return Err(e);
        }

        new_hash = git::rev_parse(workdir, "HEAD")?;

        git::continue_rebase_or_abort(workdir)?;

        // Re-apply changes to working tree
        if let Err(e) = git::apply_patch(workdir, &file_diff) {
            let _ = git::reset_hard(workdir, &saved_head);
            if let Err(re) = repo::restore_branch_refs(workdir, &saved_refs) {
                msg::warn(&format!("failed to restore branch refs: {re}"));
            }
            return Err(e).context("Failed to uncommit file, operation rolled back");
        }
    }

    msg::success(&format!(
        "Uncommitted `{}` from `{}` (now `{}`) to working directory",
        path,
        git::short_hash(commit_hash),
        git::short_hash(&new_hash)
    ));

    Ok(())
}

/// Move a file's changes from one commit to another.
///
/// Removes the file's changes from the source commit and adds them to the
/// target commit. Both commits are rewritten.
fn fold_commit_file_to_commit(
    repo: &Repository,
    source_hash: &str,
    path: &str,
    target_hash: &str,
) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    let source_oid = git2::Oid::from_str(source_hash)?;
    let target_oid = git2::Oid::from_str(target_hash)?;

    if source_oid == target_oid {
        bail!("Source and target are the same commit");
    }

    let file_diff = git::diff_commit_file(workdir, source_hash, path)?;
    if file_diff.is_empty() {
        bail!(
            "File '{}' has no changes in commit {}",
            path,
            git::short_hash(source_hash)
        );
    }

    let source_is_newer = repo.graph_descendant_of(source_oid, target_oid)?;

    let new_source_hash;
    let new_target_hash;

    if source_is_newer {
        // Two-phase approach with edit+continue and rollback.
        // When source is newer than target, a single rebase can't do both
        // edits: adding the file to target (older, picked first) would
        // conflict when source (newer) is replayed — source still has the file.
        //   Phase 1: Remove the file from source via edit+continue.
        //   Phase 2: Add the file to target via edit+continue.
        // On phase 2 failure, roll back to pre-phase-1 state.
        let saved_head = repo::head_oid(repo)?.to_string();
        let saved_refs = repo::snapshot_branch_refs(repo)?;

        let rollback =
            |saved_head: &str, saved_refs: &std::collections::HashMap<String, git2::Oid>| {
                let _ = git::branch_delete(workdir, TRACK_BRANCH);
                let _ = git::reset_hard(workdir, saved_head);
                if let Err(re) = repo::restore_branch_refs(workdir, saved_refs) {
                    msg::warn(&format!("failed to restore branch refs: {re}"));
                }
            };

        // Phase 1: edit at source, remove file, continue.
        // Create temp branch AFTER from_repo to avoid polluting the Weave graph,
        // but before the rebase so git's --update-refs tracks the target's new OID.
        let mut graph = Weave::from_repo(repo)?;
        graph.edit_commit(source_oid);
        let todo = graph.to_todo();
        git::branch_force_create(workdir, TRACK_BRANCH, target_hash)?;

        if let Err(e) =
            weave::run_rebase_or_abort(workdir, Some(&graph.base_oid.to_string()), &todo)
        {
            let _ = git::branch_delete(workdir, TRACK_BRANCH);
            return Err(e);
        }

        if let Err(e) = apply_and_amend_path(workdir, &file_diff, path, true) {
            let _ = git::rebase_abort(workdir);
            let _ = git::branch_delete(workdir, TRACK_BRANCH);
            return Err(e);
        }

        // Capture source's new hash before continue moves HEAD;
        // it will be tracked through phase 2 via a temp branch.
        let phase1_source_hash = git::rev_parse(workdir, "HEAD")?;

        if let Err(e) = git::continue_rebase_or_abort(workdir) {
            let _ = git::branch_delete(workdir, TRACK_BRANCH);
            return Err(e);
        }

        // Phase 2: resolve the target's new OID via the temp branch.
        let phase2_target_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
        let _ = git::branch_delete(workdir, TRACK_BRANCH);
        let phase2_target_oid = git2::Oid::from_str(&phase2_target_hash)?;

        // Re-open repo after phase 1 rebase (OIDs changed)
        let repo2 = Repository::open(workdir)?;
        let mut graph2 = Weave::from_repo(&repo2)?;
        graph2.edit_commit(phase2_target_oid);

        // Track source through phase 2 — it will be rewritten when the
        // graph is replayed from base_oid.
        let phase1_source_oid = git2::Oid::from_str(&phase1_source_hash)?;
        git::branch_force_create(workdir, TRACK_BRANCH, &phase1_source_hash)?;
        graph2.track_commit(phase1_source_oid, TRACK_BRANCH);

        let todo2 = graph2.to_todo();

        if let Err(e) =
            weave::run_rebase_or_abort(workdir, Some(&graph2.base_oid.to_string()), &todo2)
        {
            rollback(&saved_head, &saved_refs);
            return Err(e);
        }

        if let Err(e) = apply_and_amend_path(workdir, &file_diff, path, false) {
            let _ = git::rebase_abort(workdir);
            rollback(&saved_head, &saved_refs);
            return Err(e);
        }

        new_target_hash = git::rev_parse(workdir, "HEAD")?;

        if let Err(e) = git::continue_rebase_or_abort(workdir) {
            rollback(&saved_head, &saved_refs);
            return Err(e);
        }

        new_source_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
        let _ = git::branch_delete(workdir, TRACK_BRANCH);
    } else {
        // Source is older than target: single rebase with two edit pauses.
        // Source is picked first (older), target second (newer). Removing
        // the file from source before target is replayed avoids conflicts.
        let saved_head = repo::head_oid(repo)?.to_string();
        let saved_refs = repo::snapshot_branch_refs(repo)?;

        let mut graph = Weave::from_repo(repo)?;
        graph.edit_commit(source_oid);
        graph.edit_commit(target_oid);

        let todo = graph.to_todo();
        weave::run_rebase_or_abort(workdir, Some(&graph.base_oid.to_string()), &todo)?;

        if let Err(e) = apply_and_amend_path(workdir, &file_diff, path, true) {
            let _ = git::rebase_abort(workdir);
            return Err(e);
        }

        new_source_hash = git::rev_parse(workdir, "HEAD")?;

        git::continue_rebase_or_abort(workdir)?;

        if let Err(e) = apply_and_amend_path(workdir, &file_diff, path, false) {
            let _ = git::rebase_abort(workdir);
            let _ = git::reset_hard(workdir, &saved_head);
            if let Err(re) = repo::restore_branch_refs(workdir, &saved_refs) {
                msg::warn(&format!("failed to restore branch refs: {re}"));
            }
            return Err(e);
        }

        new_target_hash = git::rev_parse(workdir, "HEAD")?;

        git::continue_rebase_or_abort(workdir)?;
    }

    msg::success(&format!(
        "Moved `{}` from `{}` (now `{}`) to `{}` (now `{}`)",
        path,
        git::short_hash(source_hash),
        git::short_hash(&new_source_hash),
        git::short_hash(target_hash),
        git::short_hash(&new_target_hash)
    ));

    Ok(())
}

/// Uncommit a commit to the working directory (Case 4: Commit + Unstaged).
///
/// Removes the commit from history and places its changes in the working
/// directory as unstaged modifications.
fn fold_commit_to_unstaged(repo: &Repository, commit_hash: &str) -> Result<()> {
    let workdir = repo::require_workdir(repo, COMMAND)?;

    let head_oid = repo::head_oid(repo)?;
    let target_oid = git2::Oid::from_str(commit_hash)?;
    let is_head = head_oid == target_oid;

    if is_head {
        git::reset_mixed(workdir, "HEAD~1")?;
    } else {
        // Non-HEAD: capture the diff, drop the commit, then apply the diff
        let diff = git::diff_commit(workdir, commit_hash)?;
        let saved_head = head_oid.to_string();
        let saved_refs = repo::snapshot_branch_refs(repo)?;

        let mut graph = Weave::from_repo(repo)?;
        if !graph.drop_commit(target_oid) {
            bail!(
                "Commit `{}` is not in the local commits (upstream..HEAD)\n\
                 If history was rewritten, the SHA may be stale — run `loom` to see the current commits",
                git::short_hash(commit_hash)
            );
        }

        let git_dir = repo.path().to_path_buf();
        let fold_ctx = serde_json::to_value(FoldVariant::CommitToUnstaged {
            commit_hash: commit_hash.to_string(),
            diff: diff.clone(),
        })?;
        let loom_state = LoomState {
            command: COMMAND.to_string(),
            rollback: Rollback::default(),
            context: fold_ctx,
        };
        transaction::save(&git_dir, &loom_state)?;

        let todo = graph.to_todo();
        match weave::run_rebase(workdir, Some(&graph.base_oid.to_string()), &todo)? {
            RebaseOutcome::Completed => {
                transaction::delete(&git_dir)?;
                if !diff.is_empty()
                    && let Err(e) = git::apply_patch(workdir, &diff)
                {
                    let _ = git::reset_hard(workdir, &saved_head);
                    if let Err(re) = repo::restore_branch_refs(workdir, &saved_refs) {
                        msg::warn(&format!("failed to restore branch refs: {re}"));
                    }
                    return Err(e).context(
                        "Failed to apply changes to working directory, operation rolled back",
                    );
                }
            }
            RebaseOutcome::Conflicted => {
                transaction::warn_conflict_paused(COMMAND);
                return Ok(());
            }
        }
    }

    msg::success(&format!(
        "Uncommitted `{}` to working directory",
        git::short_hash(commit_hash)
    ));

    Ok(())
}

/// Resume a `fold` operation after a conflict has been resolved.
pub fn after_continue(workdir: &Path, context: &serde_json::Value) -> Result<()> {
    let variant: FoldVariant =
        serde_json::from_value(context.clone()).context("Failed to parse fold resume context")?;

    match variant {
        FoldVariant::FilesIntoCommit {
            original_commit_hash,
            files_count,
            saved_staged,
        } => {
            let new_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
            let _ = git::branch_delete(workdir, TRACK_BRANCH);
            git::restore_staged_patch(workdir, &saved_staged)?;
            msg::success(&format!(
                "Folded {} file(s) into `{}` (now `{}`)",
                files_count,
                git::short_hash(&original_commit_hash),
                git::short_hash(&new_hash)
            ));
        }
        FoldVariant::CommitIntoCommit {
            source_hash,
            target_hash,
        } => {
            let new_hash = git::rev_parse(workdir, TRACK_BRANCH)?;
            let _ = git::branch_delete(workdir, TRACK_BRANCH);
            msg::success(&format!(
                "Folded `{}` into `{}` (now `{}`)",
                git::short_hash(&source_hash),
                git::short_hash(&target_hash),
                git::short_hash(&new_hash)
            ));
        }
        FoldVariant::CommitToBranch {
            commit_hash,
            branch_name,
        } => {
            let new_hash = git::rev_parse(workdir, &branch_name)?;
            msg::success(&format!(
                "Moved `{}` to branch `{}` (now `{}`)",
                git::short_hash(&commit_hash),
                branch_name,
                git::short_hash(&new_hash)
            ));
        }
        FoldVariant::CommitToUnstaged { commit_hash, diff } => {
            if !diff.is_empty()
                && let Err(e) = git::apply_patch(workdir, &diff)
            {
                // The rebase succeeded (commit is gone) but the diff can't be
                // re-applied — typically because conflict resolution changed
                // the surrounding context. Save the diff to a file so the user
                // can recover it manually.
                let patch_path = workdir.join(".git/loom/unapplied.patch");
                if let Some(parent) = patch_path.parent() {
                    let _ = std::fs::create_dir_all(parent);
                }
                let _ = std::fs::write(&patch_path, &diff);
                msg::warn(&format!(
                    "Could not re-apply changes to working directory: {}\n\
                     The diff has been saved to {}",
                    e,
                    patch_path.display()
                ));
            }
            msg::success(&format!(
                "Uncommitted `{}` to working directory",
                git::short_hash(&commit_hash)
            ));
        }
    }

    Ok(())
}

#[cfg(test)]
#[path = "fold_test.rs"]
mod tests;