gitkraft 1.2.4

//! Async command helpers for commit operations.
//!
//! Each function spawns blocking work on a background thread via the
//! `git_task!` macro, performs the git operation, and maps the result into a
//! [`Message`].

use std::path::PathBuf;

use iced::Task;

use crate::macros::StringErr;
use crate::message::Message;

/// Load just the file list (paths + statuses) for a commit — no line parsing.
pub(crate) fn load_commit_file_list(path: PathBuf, oid: String) -> Task<Message> {
    git_task!(
        Message::CommitFileListLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::diff::get_commit_file_list(&repo, &oid).str_err()
        })()
    )
}

/// Load the full diff for a single file in a commit.
pub(crate) fn load_single_file_diff(
    path: PathBuf,
    oid: String,
    file_path: String,
) -> Task<Message> {
    git_task!(
        Message::SingleFileDiffLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::diff::get_single_file_diff(&repo, &oid, &file_path).str_err()
        })()
    )
}

/// Search commits by query string (searches message, author, SHA).
pub(crate) fn search_commits(path: PathBuf, query: String) -> Task<Message> {
    git_task!(
        Message::SearchResultsLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::log::search_commits(&repo, &query, 100).str_err()
        })()
    )
}

/// Load the file list of changes between a commit and the current working tree.
pub(crate) fn search_diff_file_list(path: PathBuf, oid: String) -> Task<Message> {
    git_task!(
        Message::SearchDiffFilesLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::diff::file_list_commit_vs_workdir(&repo, &oid).str_err()
        })()
    )
}

/// Diff a single file from a specific commit against the current working tree (for search overlay).
pub(crate) fn search_diff_file(path: PathBuf, oid: String, file_path: String) -> Task<Message> {
    git_task!(
        Message::SearchFileDiffLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::diff::diff_file_commit_vs_workdir(&repo, &oid, &file_path)
                .str_err()
        })()
    )
}

/// Diff multiple files from a specific commit against the current working tree.
pub(crate) fn search_diff_multi_files(
    path: PathBuf,
    oid: String,
    file_paths: Vec<String>,
) -> Task<Message> {
    git_task!(
        Message::SearchMultiDiffLoaded,
        (|| {
            let repo = open_repo!(&path);
            let mut diffs = Vec::with_capacity(file_paths.len());
            for fp in &file_paths {
                match gitkraft_core::features::diff::diff_file_commit_vs_workdir(&repo, &oid, fp) {
                    Ok(diff) => diffs.push(diff),
                    Err(e) => {
                        return Err(format!("{fp}: {e}"));
                    }
                }
            }
            Ok(diffs)
        })()
    )
}

/// Diff a file from a specific commit against the current working tree.
pub(crate) fn diff_file_with_working_tree(
    path: PathBuf,
    oid: String,
    file_path: String,
) -> Task<Message> {
    git_task!(
        Message::DiffWithWorkingTreeLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::diff::diff_file_commit_vs_workdir(&repo, &oid, &file_path)
                .str_err()
        })()
    )
}

/// Load diffs for multiple files in a commit and return them all together.
pub(crate) fn load_commit_multi_diffs(
    path: PathBuf,
    oid: String,
    file_paths: Vec<String>,
) -> Task<Message> {
    git_task!(
        Message::CommitMultiDiffLoaded,
        (|| {
            let repo = open_repo!(&path);
            let mut diffs = Vec::with_capacity(file_paths.len());
            for fp in &file_paths {
                match gitkraft_core::features::diff::get_single_file_diff(&repo, &oid, fp) {
                    Ok(diff) => diffs.push(diff),
                    Err(e) => return Err(format!("{fp}: {e}")),
                }
            }
            Ok(diffs)
        })()
    )
}

/// Diff multiple files from a specific commit against the current working tree.
pub(crate) fn load_multi_file_commit_vs_workdir(
    path: PathBuf,
    oid: String,
    file_paths: Vec<String>,
) -> Task<Message> {
    git_task!(
        Message::CommitMultiDiffLoaded,
        (|| {
            let repo = open_repo!(&path);
            let mut diffs = Vec::with_capacity(file_paths.len());
            for fp in &file_paths {
                match gitkraft_core::features::diff::diff_file_commit_vs_workdir(&repo, &oid, fp) {
                    Ok(diff) => diffs.push(diff),
                    Err(e) => return Err(format!("{fp}: {e}")),
                }
            }
            Ok(diffs)
        })()
    )
}

/// Create a new commit with the currently staged changes.
pub(crate) fn create_commit(path: PathBuf, message: String) -> Task<Message> {
    git_task!(
        Message::CommitCreated,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::commits::create_commit(&repo, &message)
                .map(|_| ())
                .str_err()
        })()
    )
}

/// Restore a single file from a commit to the working directory.
pub(crate) fn checkout_file_at_commit(
    path: PathBuf,
    oid: String,
    file_path: String,
) -> Task<Message> {
    git_repo_then_reload!(path, |repo| {
        gitkraft_core::features::diff::checkout_file_at_commit(&repo, &oid, &file_path)
    })
}

/// Cherry-pick a sequence of commits onto the current branch.
pub(crate) fn cherry_pick_commits(path: PathBuf, oids: Vec<String>) -> Task<Message> {
    git_task!(
        Message::GitOperationResult,
        (|| {
            for oid in &oids {
                gitkraft_core::features::commits::cherry_pick_commit(&path, oid)
                    .map_err(|e| format!("{oid}: {e}"))?;
            }
            crate::features::repo::commands::load_repo_blocking(&path)
        })()
    )
}

/// Revert a sequence of commits in order.
pub(crate) fn revert_commits(path: PathBuf, oids: Vec<String>) -> Task<Message> {
    git_task!(
        Message::GitOperationResult,
        (|| {
            for oid in &oids {
                gitkraft_core::features::repo::revert_commit(&path, oid)
                    .map_err(|e| format!("{oid}: {e}"))?;
            }
            crate::features::repo::commands::load_repo_blocking(&path)
        })()
    )
}

/// Load the combined diff across a range of commits.
pub(crate) fn load_commit_range_diff(
    path: PathBuf,
    oldest_oid: String,
    newest_oid: String,
) -> Task<Message> {
    git_task!(
        Message::CommitRangeDiffLoaded,
        (|| {
            let repo = open_repo!(&path);
            gitkraft_core::features::diff::get_commit_range_diff(&repo, &oldest_oid, &newest_oid)
                .str_err()
        })()
    )
}

/// Restore multiple files from a commit to the working directory.
pub(crate) fn checkout_multi_files_at_commit(
    path: PathBuf,
    oid: String,
    file_paths: Vec<String>,
) -> Task<Message> {
    git_task!(
        Message::GitOperationResult,
        (|| {
            let repo = open_repo!(&path);
            for fp in &file_paths {
                gitkraft_core::features::diff::checkout_file_at_commit(&repo, &oid, fp)
                    .map_err(|e| format!("{fp}: {e}"))?;
            }
            crate::features::repo::commands::load_repo_blocking(&path)
        })()
    )
}