//! Local Git operations adapted from the v2 gix plugin, without RPC or host imports.
#![allow(dead_code)]
mod branches;
mod changes;
mod checkout;
mod http;
mod ssh;
mod merge;
mod network;
mod output;
mod push;
mod rebase;
mod remotes;
mod repo;
mod staging;
mod worktrees;
use gix::bstr::ByteSlice;
use repo::error;
#[derive(Debug)]
pub struct Error {
    pub message: String,
}
impl Error {
    pub fn new(_: i32, message: String) -> Self {
        Self { message }
    }
}
impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.message)
    }
}
impl std::error::Error for Error {}
pub type Result<T> = std::result::Result<T, Error>;
#[derive(serde::Serialize, serde::Deserialize)]
pub struct HeadInfo {
    detached: bool,
    unborn: bool,
    branch: Option<String>,
    id: Option<String>,
}
include!("head.inc");
struct Identity {
    name: Option<String>,
    email: Option<String>,
}
fn identity(name: Option<String>, email: Option<String>) -> Result<Identity> {
    let repo = gix::discover(".").map_err(|e| error("identity", e))?;
    let config = repo.config_snapshot();
    Ok(Identity {
        name: name
            .or_else(|| std::env::var("GIT_AUTHOR_NAME").ok())
            .or_else(|| config.string("user.name").map(|s| s.to_string())),
        email: email
            .or_else(|| std::env::var("GIT_AUTHOR_EMAIL").ok())
            .or_else(|| config.string("user.email").map(|s| s.to_string())),
    })
}
mod cherry_pick;
mod history;
mod local;
mod plumbing;
mod stash;
use clap::{Parser, Subcommand};
#[derive(Parser)]
#[command(name = "git", disable_help_subcommand = true)]
pub struct Cli {
    #[arg(short = 'C', global = true)]
    directory: Option<std::path::PathBuf>,
    #[arg(short = 'c', global = true)]
    config: Vec<String>,
    #[arg(short = 'q', long, global = true)]
    quiet: bool,
    #[command(subcommand)]
    command: Command,
}
#[derive(Subcommand)]
enum Command {
    Show {
        #[arg(long)]
        stat: bool,
        revision: Option<String>,
    },
    Clone {
        url: String,
        path: Option<String>,
    },
    Fetch {
        #[arg(default_value = "origin")]
        remote: String,
        revision: Option<String>,
    },
    MergeBase {
        #[arg(long)]
        is_ancestor: bool,
        a: String,
        b: String,
    },
    RevList {
        #[arg(long)]
        count: bool,
        revisions: Vec<String>,
    },
    SymbolicRef {
        #[arg(long)]
        short: bool,
        name: String,
    },
    UpdateRef {
        name: String,
        new: String,
        old: Option<String>,
    },
    Clean {
        #[arg(short = 'f')]
        force: bool,
        #[arg(short = 'd')]
        directories: bool,
    },
    CheckIgnore {
        #[arg(long)]
        no_index: bool,
        paths: Vec<String>,
    },
    Push {
        #[arg(short = 'u', long)]
        set_upstream: bool,
        #[arg(short = 'f', long)]
        force: bool,
        #[arg(default_value = "origin")]
        remote: String,
        refspec: Option<String>,
    },
    Init {
        #[arg(long)]
        bare: bool,
        #[arg(short = 'b', default_value = "main")]
        initial_branch: String,
        path: Option<String>,
    },
    Config {
        #[arg(long)]
        local: bool,
        #[arg(long)]
        get: bool,
        key: String,
        value: Option<String>,
    },
    RevParse {
        #[arg(long)]
        verify: bool,
        #[arg(long)]
        show_toplevel: bool,
        #[arg(long)]
        git_dir: bool,
        #[arg(long)]
        abbrev_ref: bool,
        #[arg(long)]
        short: bool,
        revisions: Vec<String>,
    },
    Status {
        #[arg(long, default_value = "normal")]
        untracked_files: String,
        #[arg(short = 'z')]
        nul: bool,
        #[arg(short, long)]
        short: bool,
        #[arg(long, num_args = 0..=1, default_missing_value = "v1", require_equals = true)]
        porcelain: Option<String>,
        #[arg(short = 'b', long)]
        branch: bool,
    },
    Add {
        #[arg(short = 'A', long)]
        all: bool,
        paths: Vec<String>,
    },
    Rm {
        #[arg(long)]
        cached: bool,
        paths: Vec<String>,
    },
    Commit {
        #[arg(short = 'm')]
        message: Option<String>,
        #[arg(short = 'F', conflicts_with = "message")]
        file: Option<String>,
        #[arg(long)]
        amend: bool,
        #[arg(long)]
        no_edit: bool,
        #[arg(short, long)]
        all: bool,
        #[arg(long)]
        allow_empty: bool,
        /// Accepted for compatibility. This git never signs commits.
        #[arg(long)]
        no_gpg_sign: bool,
    },
    Log {
        #[arg(long)]
        name_only: bool,
        #[arg(long)]
        no_renames: bool,
        #[arg(long)]
        diff_merges: Option<String>,
        #[arg(long)]
        oneline: bool,
        #[arg(short = 'n')]
        limit: Option<usize>,
        #[arg(long)]
        format: Option<String>,
        #[arg(long)]
        pretty: Option<String>,
        #[arg(short = 'p')]
        patch: bool,
        #[arg(long)]
        stat: bool,
        revision: Option<String>,
        #[arg(last = true)]
        paths: Vec<String>,
    },
    Diff {
        #[arg(long)]
        numstat: bool,
        #[arg(long)]
        no_renames: bool,
        #[arg(long)]
        diff_filter: Option<String>,
        #[arg(short = 'z')]
        nul: bool,
        #[arg(long, alias = "staged")]
        cached: bool,
        #[arg(long)]
        stat: bool,
        #[arg(long)]
        name_only: bool,
        #[arg(long)]
        name_status: bool,
        revisions: Vec<String>,
        #[arg(last = true)]
        paths: Vec<String>,
    },
    Branch {
        #[arg(long)]
        list: bool,
        #[arg(long)]
        show_current: bool,
        #[arg(short = 'a')]
        all: bool,
        #[arg(short = 'd')]
        delete: bool,
        #[arg(short = 'D')]
        force_delete: bool,
        #[arg(short = 'm')]
        rename: bool,
        name: Option<String>,
        start: Option<String>,
    },
    Switch {
        #[arg(short = 'c')]
        create: bool,
        target: String,
    },
    Checkout {
        #[arg(long)]
        detach: bool,
        #[arg(long, short = 'f')]
        force: bool,
        #[arg(short = 'b')]
        create: bool,
        target: Option<String>,
        paths: Vec<String>,
    },
    Merge {
        #[arg(long)]
        no_edit: bool,
        #[arg(long)]
        ff_only: bool,
        #[arg(long)]
        no_ff: bool,
        #[arg(long)]
        no_commit: bool,
        #[arg(long)]
        abort: bool,
        #[arg(short = 'm')]
        message: Option<String>,
        revision: Option<String>,
    },
    Rebase {
        #[arg(long)]
        abort: bool,
        #[arg(long = "continue")]
        resume: bool,
        #[arg(long)]
        skip: bool,
        upstream: Option<String>,
    },
    Worktree {
        #[command(subcommand)]
        command: Worktree,
    },
    LsFiles {
        #[arg(long)]
        others: bool,
        #[arg(long)]
        exclude_standard: bool,
        #[arg(short = 'z')]
        nul: bool,
    },
    Reset {
        #[arg(long, conflicts_with_all = ["hard", "mixed"])]
        soft: bool,
        #[arg(long, conflicts_with = "mixed")]
        hard: bool,
        #[arg(long)]
        mixed: bool,
        revision: Option<String>,
        paths: Vec<String>,
    },
    Restore {
        #[arg(long)]
        staged: bool,
        paths: Vec<String>,
    },
    Stash {
        #[arg(short = 'm', long)]
        message: Option<String>,
        command: Option<String>,
        entry: Option<String>,
    },
    Tag {
        #[arg(short = 'a')]
        annotated: bool,
        #[arg(short = 'm')]
        message: Option<String>,
        #[arg(short = 'l', long)]
        list: bool,
        #[arg(short = 'd')]
        delete: bool,
        name: Option<String>,
        revision: Option<String>,
    },
    Remote {
        #[arg(short = 'v', long)]
        verbose: bool,
        command: Option<String>,
        name: Option<String>,
        url: Option<String>,
    },
    CherryPick {
        #[arg(long = "continue")]
        resume: bool,
        #[arg(long)]
        abort: bool,
        revision: Option<String>,
    },
}
#[derive(Subcommand)]
enum Worktree {
    Prune,
    List {
        #[arg(long)]
        porcelain: bool,
    },
    Add {
        #[arg(long)]
        detach: bool,
        #[arg(short = 'b')]
        branch: Option<String>,
        path: String,
        revision: Option<String>,
    },
    Remove {
        #[arg(long)]
        force: bool,
        path: String,
    },
}
fn required(value: Option<String>, what: &str) -> Result<String> {
    value.ok_or_else(|| error(what, "argument required"))
}
pub fn run(cli: Cli) -> Result<i32> {
    let quiet = cli.quiet;
    let count = std::env::var("GIT_CONFIG_COUNT")
        .ok()
        .and_then(|s| s.parse::<usize>().ok())
        .unwrap_or(0);
    for (i, value) in cli.config.iter().enumerate() {
        let (key, value) = value.split_once('=').unwrap_or((value, "true"));
        // WASI has one thread. Supply Git's per-command configuration before discovery.
        unsafe {
            std::env::set_var(format!("GIT_CONFIG_KEY_{}", count + i), key);
            std::env::set_var(format!("GIT_CONFIG_VALUE_{}", count + i), value);
        }
    }
    if !cli.config.is_empty() {
        unsafe {
            std::env::set_var("GIT_CONFIG_COUNT", (count + cli.config.len()).to_string());
        }
    }
    if let Some(dir) = cli.directory {
        std::env::set_current_dir(dir).map_err(|e| error("chdir", e))?;
    }
    if let Command::Init {
        bare,
        initial_branch,
        path,
    } = cli.command
    {
        let path = path.unwrap_or_else(|| ".".into());
        let existing = std::path::Path::new(&path)
            .join(if bare { "HEAD" } else { ".git/HEAD" })
            .exists();
        let repo = if existing {
            repo::open(&path)
        } else {
            let repo = if bare {
                gix::init_bare(&path)
            } else {
                gix::init(&path)
            }
            .map_err(|e| error("init", e))?;
            std::fs::write(
                repo.git_dir().join("HEAD"),
                format!("ref: refs/heads/{initial_branch}\n"),
            )
            .map_err(|e| error("init HEAD", e))?;
            Ok(repo)
        }?;
        if !quiet {
            println!(
                "{} Git repository in {}/",
                if existing {
                    "Reinitialized existing"
                } else {
                    "Initialized empty"
                },
                repo.git_dir()
                    .canonicalize()
                    .map_err(|e| error("init", e))?
                    .display()
            );
        }
        return Ok(0);
    }
    if let Command::Clone { url, path } = cli.command {
        let path = path.unwrap_or_else(|| {
            url.trim_end_matches('/')
                .rsplit('/')
                .next()
                .unwrap_or("repo")
                .trim_end_matches(".git")
                .to_owned()
        });
        network::clone(&url, &path)?;
        return Ok(0);
    }
    let discovered = gix::discover(".").map_err(|e| error("repository", e))?;
    let root = discovered
        .workdir()
        .unwrap_or(discovered.git_dir())
        .to_owned();
    std::env::set_current_dir(&root).map_err(|e| error("chdir", e))?;
    let path = root.to_string_lossy().into_owned();
    let repository = repo::open(&path)?;
    match cli.command {
        Command::Reset {
            soft,
            hard,
            revision,
            paths,
            ..
        } => local::reset(
            &repository,
            revision.as_deref().unwrap_or("HEAD"),
            &paths,
            soft,
            hard,
            quiet,
        )?,
        Command::Restore { staged, paths } => local::restore(
            &repository,
            if staged { Some("HEAD") } else { None },
            &paths,
            staged,
        )?,
        Command::Stash {
            command,
            message,
            entry,
        } => {
            return stash::run(
                &repository,
                command.as_deref().unwrap_or("push"),
                message,
                entry,
                quiet,
            );
        }
        Command::Tag {
            annotated,
            message,
            delete,
            name,
            revision,
            ..
        } => local::tag(&repository, name, revision, annotated, message, delete)?,
        Command::Remote {
            verbose,
            command,
            name,
            url,
        } => match command.as_deref() {
            Some("add") | Some("set-url") => {
                remotes::set(
                    &repository,
                    &required(name, "remote name")?,
                    &required(url, "remote URL")?,
                    command.as_deref() == Some("add"),
                )?;
            }
            Some("remove") => remotes::remove(&repository, &required(name, "remote name")?)?,
            Some("get-url") => {
                let name = required(name, "remote name")?;
                let remote = remotes::list(&repository)?
                    .into_iter()
                    .find(|r| r.name == name)
                    .ok_or_else(|| error("remote", "remote does not exist"))?;
                println!("{}", remote.url.unwrap_or_default());
            }
            None => {
                for remote in remotes::list(&repository)? {
                    if verbose {
                        let url = remote.url.unwrap_or_default();
                        println!(
                            "{}\t{} (fetch)\n{}\t{} (push)",
                            remote.name, url, remote.name, url
                        );
                    } else {
                        println!("{}", remote.name);
                    }
                }
            }
            _ => {
                eprintln!("usage: git remote [add|remove|set-url|get-url]");
                return Ok(129);
            }
        },
        Command::CherryPick {
            resume,
            abort,
            revision,
        } => return cherry_pick::run(&repository, revision, resume, abort, quiet),
        Command::MergeBase { a, b, is_ancestor } => {
            return plumbing::merge_base(&repository, &a, &b, is_ancestor);
        }
        Command::RevList { count, revisions } => {
            let mut included = std::collections::BTreeSet::new();
            let mut excluded = std::collections::BTreeSet::new();
            for revision in revisions {
                let (tip, hidden) = plumbing::range(&repository, &revision)?;
                included.extend(plumbing::ancestors(&repository, tip)?);
                excluded.extend(hidden);
            }
            included.retain(|id| !excluded.contains(id));
            if count {
                println!("{}", included.len());
            } else {
                for id in included {
                    println!("{id}");
                }
            }
        }
        Command::SymbolicRef { short, name } => {
            let reference = repository
                .find_reference(name.as_str())
                .map_err(|e| error("symbolic-ref", e))?;
            if let gix::refs::TargetRef::Symbolic(target) = reference.target() {
                println!(
                    "{}",
                    if short {
                        target.shorten().to_string()
                    } else {
                        target.as_bstr().to_string()
                    }
                );
            } else {
                if !quiet {
                    eprintln!("fatal: ref {name} is not a symbolic ref");
                }
                return Ok(if quiet { 1 } else { 128 });
            }
        }
        Command::UpdateRef { name, new, old } => {
            plumbing::update_ref(&repository, &name, &new, old.as_deref())?
        }
        Command::CheckIgnore { no_index, paths } => {
            return plumbing::check_ignore(&repository, &paths, no_index);
        }
        Command::Clean { force, directories } => {
            if !force {
                return Err(error("clean", "requires -f"));
            }
            plumbing::clean(&repository, directories, quiet)?;
        }
        Command::LsFiles {
            others,
            exclude_standard: _,
            nul,
        } => {
            if others {
                for path in changes::status(&repository)?.untracked {
                    print!("{path}{}", if nul { "\0" } else { "\n" });
                }
                return Ok(0);
            }
            let index = repository
                .index_or_empty()
                .map_err(|e| error("ls-files", e))?;
            for entry in index.entries() {
                print!("{}{}", entry.path(&index), if nul { "\0" } else { "\n" });
            }
        }
        Command::Config { key, value, .. } => {
            let file = repository.common_dir().join("config");
            if let Some(value) = value {
                let mut config = gix::config::File::from_path_no_includes(
                    file.clone(),
                    gix::config::Source::Local,
                )
                .map_err(|e| error("config", e))?;
                config
                    .set_raw_value(&key, value.as_bytes().as_bstr())
                    .map_err(|e| error("config", e))?;
                let mut output = std::fs::File::create(file).map_err(|e| error("config", e))?;
                config
                    .write_to(&mut output)
                    .map_err(|e| error("config", e))?;
            } else if let Some(value) = repository.config_snapshot().string(&key) {
                println!("{value}");
            } else {
                return Ok(1);
            }
        }
        Command::RevParse {
            verify,
            show_toplevel,
            git_dir,
            abbrev_ref,
            short,
            revisions,
        } => {
            if show_toplevel {
                println!("{}", root.display());
            } else if git_dir {
                println!(".git");
            } else if abbrev_ref {
                println!(
                    "{}",
                    head_info(&repository)?
                        .branch
                        .unwrap_or_else(|| "HEAD".into())
                        .trim_start_matches("refs/heads/")
                );
            } else {
                for revision in revisions {
                    let id = match repository.rev_parse_single(revision.as_str()) {
                        Ok(id) => id.to_string(),
                        Err(_) if verify && quiet => return Ok(1),
                        Err(e) => return Err(error("revision", e)),
                    };
                    println!("{}", if short { &id[..7] } else { &id });
                }
            }
        }
        Command::Add { all, mut paths } => {
            let all = all || paths.iter().any(|p| p == ".");
            paths.retain(|p| p != ".");
            staging::add(
                &repository,
                staging::AddParams {
                    repo: path,
                    paths,
                    all: Some(all),
                },
            )?;
        }
        Command::Rm { cached, paths } => {
            let result = staging::rm(
                &repository,
                staging::RmParams {
                    repo: path,
                    paths,
                    keep_file: Some(cached),
                },
            )?;
            for path in result.paths {
                println!("rm '{path}'");
            }
        }
        Command::Commit {
            message,
            file,
            amend,
            no_edit,
            all,
            allow_empty,
            ..
        } => {
            let before = head_info(&repository)?;
            let message = if let Some(file) = file {
                std::fs::read_to_string(file).map_err(|e| error("commit message", e))?
            } else if let Some(message) = message {
                message
            } else if amend && no_edit {
                repository
                    .head_commit()
                    .map_err(|e| error("amend", e))?
                    .decode()
                    .map_err(|e| error("amend message", e))?
                    .message
                    .to_str_lossy()
                    .into_owned()
            } else {
                eprintln!("usage: git commit -m <message> | -F <file> | --amend --no-edit");
                return Ok(129);
            };
            let message = plumbing::trailer(&message);
            if !amend && !allow_empty && merge::pending_parent(&repository)?.is_none() {
                let status = changes::status(&repository)?;
                if status.staged.is_empty()
                    && (!all || status.unstaged.is_empty())
                    && status.conflicted.is_empty()
                {
                    output::long_status(&status);
                    return Ok(1);
                }
            }
            let result = staging::commit(
                &repository,
                staging::CommitParams {
                    repo: path.clone(),
                    message: format!("{message}\n"),
                    author_name: None,
                    author_email: None,
                    all: Some(all),
                    amend: Some(amend),
                    allow_empty: Some(allow_empty),
                },
            )?;
            if quiet {
                return Ok(0);
            }
            println!(
                "[{}{} {}] {}",
                before
                    .branch
                    .unwrap_or_else(|| "HEAD".into())
                    .trim_start_matches("refs/heads/"),
                if before.unborn { " (root-commit)" } else { "" },
                &result.id[..7],
                message.lines().next().unwrap_or("")
            );
            if amend {
                output::author_date(
                    &repository
                        .find_commit(
                            gix::ObjectId::from_hex(result.id.as_bytes())
                                .map_err(|e| error("amend", e))?,
                        )
                        .map_err(|e| error("amend", e))?,
                )?;
            }
            let old = match if amend {
                repository
                    .find_commit(
                        gix::ObjectId::from_hex(result.id.as_bytes())
                            .map_err(|e| error("amend", e))?,
                    )
                    .map_err(|e| error("amend", e))?
                    .parent_ids()
                    .next()
                    .map(|id| id.to_string())
            } else {
                before.id
            } {
                Some(id) => id,
                None => repository
                    .write_object(&gix::objs::Tree { entries: vec![] })
                    .map_err(|e| error("commit summary", e))?
                    .to_string(),
            };
            output::commit_stat(&changes::diff(changes::DiffParams {
                repo: path,
                from: Some(old),
                to: Some(result.id),
                staged: None,
                path: None,
                context: None,
            })?);
        }
        Command::Status {
            untracked_files,
            nul,
            short,
            porcelain,
            branch,
        } => {
            let mut status = changes::refresh_status(&repository)?;
            let index = repository
                .index_or_empty()
                .map_err(|e| error("status index", e))?;
            let tracked: Vec<_> = index
                .entries()
                .iter()
                .map(|e| e.path(&index).to_str_lossy().into_owned())
                .collect();
            let mut untracked = std::collections::BTreeSet::new();
            for path in status.untracked {
                if untracked_files == "no" {
                    continue;
                }
                if untracked_files == "all" {
                    untracked.insert(path);
                    continue;
                }
                let collapsed = path
                    .match_indices('/')
                    .map(|(i, _)| &path[..=i])
                    .find(|prefix| !tracked.iter().any(|t| t.starts_with(*prefix)))
                    .unwrap_or(&path);
                untracked.insert(collapsed.to_owned());
            }
            status.untracked = untracked.into_iter().collect();
            if !short && porcelain.is_none() {
                output::long_status(&status);
                return Ok(0);
            }
            if branch {
                println!(
                    "## {}",
                    if status.head.detached {
                        "HEAD (no branch)".into()
                    } else {
                        let name = status
                            .head
                            .branch
                            .as_deref()
                            .unwrap_or("HEAD")
                            .trim_start_matches("refs/heads/");
                        if status.head.unborn {
                            format!("No commits yet on {name}")
                        } else {
                            name.to_owned()
                        }
                    }
                );
            }
            let mut rows = std::collections::BTreeMap::new();
            let mut sources = std::collections::BTreeMap::new();
            for c in status.staged {
                if let Some(source) = c.old_path {
                    sources.insert(c.path.clone(), source);
                }
                rows.entry(c.path).or_insert([' '; 2])[0] = code(&c.status);
            }
            for c in status.unstaged {
                rows.entry(c.path).or_insert([' '; 2])[1] = code(&c.status);
            }
            for p in status.untracked {
                rows.insert(p, ['?', '?']);
            }
            for p in status.conflicted {
                rows.insert(p, ['U', 'U']);
            }
            for untracked in [false, true] {
                for (p, c) in &rows {
                    if (c == &['?', '?']) == untracked {
                        if let Some(source) = sources.get(p) {
                            if nul {
                                print!("{}{} {p}\0{source}\0", c[0], c[1]);
                            } else {
                                println!("{}{} {source} -> {p}", c[0], c[1]);
                            }
                        } else {
                            print!("{}{} {p}{}", c[0], c[1], if nul { "\0" } else { "\n" });
                        }
                    }
                }
            }
        }
        Command::Diff {
            numstat,
            no_renames,
            diff_filter,
            nul,
            cached,
            stat,
            name_only,
            name_status,
            revisions,
            paths,
        } => {
            let (from, to) = if revisions.len() == 1 && revisions[0].contains("..") {
                let (a, b) = revisions[0].split_once("..").unwrap();
                (Some(a.into()), Some(b.into()))
            } else {
                (revisions.first().cloned(), revisions.get(1).cloned())
            };
            if diff_filter.as_deref() == Some("U") {
                for p in changes::status(&repository)?.conflicted {
                    print!("{p}{}", if nul { "\0" } else { "\n" });
                }
                return Ok(0);
            }
            let diffs = changes::diff_with_renames(
                changes::DiffParams {
                    repo: path,
                    from,
                    to,
                    staged: Some(cached),
                    path: paths.first().cloned(),
                    context: None,
                },
                !no_renames,
            )?;
            if name_only || name_status {
                for diff in diffs {
                    if name_status {
                        print!(
                            "{}{}{}{}",
                            code(&diff.status),
                            if nul { "\0" } else { "\t" },
                            diff.path,
                            if nul { "\0" } else { "\n" }
                        );
                    } else {
                        print!("{}{}", diff.path, if nul { "\0" } else { "\n" });
                    }
                }
            } else if numstat {
                for diff in &diffs {
                    output::numstat(diff, nul);
                }
            } else if stat {
                output::stat(&diffs, false);
            } else {
                for diff in diffs {
                    print!("{}", diff.patch);
                }
            }
        }
        Command::Log {
            name_only,
            no_renames,
            diff_merges,
            oneline,
            limit,
            format,
            pretty,
            patch,
            stat,
            revision,
            paths,
        } => {
            let limit = limit.unwrap_or(usize::MAX);
            let (tip, excluded) =
                plumbing::range(&repository, revision.as_deref().unwrap_or("HEAD"))?;
            let commit = repository.find_commit(tip).map_err(|e| error("log", e))?;
            let ids = if let Some(path) = paths.first() {
                history::paths(&repository, commit.id, path)?
            } else {
                commit
                    .ancestors()
                    .use_commit_graph(false)
                    .sorting(gix::revision::walk::Sorting::ByCommitTime(
                        Default::default(),
                    ))
                    .all()
                    .map_err(|e| error("log", e))?
                    .filter(|info| {
                        info.as_ref()
                            .map_or(true, |info| !excluded.contains(&info.id))
                    })
                    .take(limit)
                    .map(|info| info.map(|info| info.id).map_err(|e| error("log", e)))
                    .collect::<Result<Vec<_>>>()?
            };
            let mut first = true;
            for id in ids
                .into_iter()
                .filter(|id| !excluded.contains(id))
                .take(limit)
            {
                let c = repository.find_commit(id).map_err(|e| error("log", e))?;
                let decoded = c.decode().map_err(|e| error("log", e))?;
                let message = decoded.message.to_str_lossy();
                let diffs = if (patch || stat || name_only || !paths.is_empty())
                    && (decoded.parents.len() <= 1
                        || diff_merges.as_deref() == Some("first-parent")
                        || !name_only)
                {
                    let old = match decoded.parents.first() {
                        Some(id) => id.to_string(),
                        None => repository
                            .write_object(&gix::objs::Tree { entries: vec![] })
                            .map_err(|e| error("log tree", e))?
                            .to_string(),
                    };
                    changes::diff_with_renames(
                        changes::DiffParams {
                            repo: path.clone(),
                            from: Some(old),
                            to: Some(c.id.to_string()),
                            staged: None,
                            path: paths.first().cloned(),
                            context: None,
                        },
                        !no_renames,
                    )?
                } else {
                    Vec::new()
                };
                if let Some(template) = format.as_deref().or(pretty
                    .as_deref()
                    .map(|s| s.strip_prefix("format:").unwrap_or(s)))
                {
                    let author = c.author().map_err(|e| error("log author", e))?;
                    let date = author
                        .time()
                        .map_err(|e| error("log date", e))?
                        .format_or_unix(gix::date::time::format::DEFAULT);
                    let mut labels = Vec::new();
                    for reference in repository
                        .references()
                        .map_err(|e| error("log refs", e))?
                        .all()
                        .map_err(|e| error("log refs", e))?
                    {
                        let reference = reference.map_err(|e| error("log refs", e))?;
                        let name = reference.name().as_bstr().to_str_lossy();
                        if repository
                            .rev_parse_single(name.as_ref())
                            .map(|id| id.to_string() == c.id.to_string())
                            .unwrap_or(false)
                        {
                            let short = reference.name().shorten().to_string();
                            labels.push(
                                if head_info(&repository)?.branch.as_deref() == Some(name.as_ref())
                                {
                                    format!("HEAD -> {short}")
                                } else {
                                    short
                                },
                            );
                        }
                    }
                    let decorations = if labels.is_empty() {
                        String::new()
                    } else {
                        format!(" ({})", labels.join(", "))
                    };
                    let text = plumbing::format(template, &message)
                        .replace("%H", &c.id.to_string())
                        .replace("%h", &c.id.to_string()[..7])
                        .replace("%s", message.lines().next().unwrap_or(""))
                        .replace("%an", &author.name.to_string())
                        .replace("%ae", &author.email.to_string())
                        .replace("%ad", &date)
                        .replace("%d", &decorations);
                    if pretty.is_some() {
                        if !first {
                            println!();
                        }
                        print!("{text}");
                    } else {
                        println!("{text}");
                    }
                    first = false;
                } else if oneline {
                    println!(
                        "{} {}",
                        &c.id.to_string()[..7],
                        message.lines().next().unwrap_or("")
                    );
                } else {
                    if !first {
                        println!();
                    }
                    output::commit(&c)?;
                    first = false;
                }
                if name_only && !diffs.is_empty() {
                    println!();
                    for diff in &diffs {
                        println!("{}", diff.path);
                    }
                }
                if patch || stat {
                    println!();
                    if stat {
                        output::stat(&diffs, false);
                    }
                    if patch {
                        for diff in diffs {
                            print!("{}", diff.patch);
                        }
                    }
                }
            }
        }
        Command::Branch {
            list,
            delete,
            force_delete,
            show_current,
            all,
            rename,
            name,
            start,
        } => {
            if rename {
                let new = required(start.clone().or(name.clone()), "new branch name")?;
                local::rename_branch(
                    &repository,
                    if start.is_some() {
                        name.as_deref()
                    } else {
                        None
                    },
                    &new,
                )?;
                return Ok(0);
            }
            if show_current {
                if let Some(branch) = head_info(&repository)?.branch {
                    println!("{}", branch.trim_start_matches("refs/heads/"));
                }
                return Ok(0);
            }
            if let Some(name) = name.as_ref().filter(|_| !list) {
                let name = name.clone();
                if delete || force_delete {
                    let id = branches::resolve(&repository, &name)?.to_string();
                    branches::delete(
                        &repository,
                        branches::BranchDeleteParams {
                            repo: path,
                            name: name.clone(),
                            force: Some(force_delete),
                        },
                    )?;
                    if !quiet {
                        println!("Deleted branch {name} (was {}).", &id[..7]);
                    }
                } else {
                    branches::create(
                        &repository,
                        branches::BranchCreateParams {
                            repo: path,
                            name,
                            from: start,
                            checkout: Some(false),
                        },
                    )?;
                }
            } else {
                let pattern = name.as_deref();
                let head = head_info(&repository)?;
                for branch in repository
                    .references()
                    .map_err(|e| error("branch", e))?
                    .all()
                    .map_err(|e| error("branch", e))?
                {
                    let branch = branch.map_err(|e| error("branch", e))?;
                    let name = branch.name().as_bstr().to_str_lossy();
                    if !name.starts_with("refs/heads/")
                        && !(all && name.starts_with("refs/remotes/"))
                    {
                        continue;
                    }
                    if list
                        && pattern
                            .is_some_and(|pattern| branch.name().shorten().to_string() != pattern)
                    {
                        continue;
                    }
                    println!(
                        "{} {}",
                        if head.branch.as_deref()
                            == Some(branch.name().as_bstr().to_str_lossy().as_ref())
                        {
                            "*"
                        } else {
                            " "
                        },
                        if name.starts_with("refs/remotes/") {
                            format!("remotes/{}", name.trim_start_matches("refs/remotes/"))
                        } else {
                            branch.name().shorten().to_string()
                        }
                    );
                }
            }
        }
        Command::Checkout {
            detach,
            force,
            create,
            target,
            mut paths,
        } => {
            if !create
                && (!paths.is_empty()
                    || target.as_ref().is_some_and(|t| {
                        root.join(t).is_file()
                            && repository
                                .try_find_reference(format!("refs/heads/{t}").as_str())
                                .ok()
                                .flatten()
                                .is_none()
                    }))
            {
                if let Some(target) = target {
                    paths.insert(0, target);
                }
                local::restore(&repository, None, &paths, false)?;
            } else {
                branches::checkout(
                    &repository,
                    branches::CheckoutParams {
                        repo: path,
                        target: if detach {
                            branches::resolve(&repository, &required(target, "checkout target")?)?
                                .to_string()
                        } else {
                            required(target, "checkout target")?
                        },
                        create: Some(create),
                        force: Some(force),
                    },
                )?;
            }
        }
        Command::Switch { create, target } => {
            branches::checkout(
                &repository,
                branches::CheckoutParams {
                    repo: path,
                    target,
                    create: Some(create),
                    force: None,
                },
            )?;
        }
        Command::Merge {
            no_edit: _,
            ff_only,
            no_ff,
            no_commit,
            abort,
            message,
            revision,
        } => {
            let old = head_info(&repository)?.id;
            let message =
                message.or_else(|| revision.as_ref().map(|r| format!("Merge branch '{r}'\n")));
            let r = if abort {
                merge::abort(&repository)?
            } else {
                merge::merge(
                    &repository,
                    merge::MergeParams {
                        repo: path.clone(),
                        rev: required(revision, "merge")?,
                        message: message.map(|m| format!("{}\n", m.trim_end())),
                        ff: Some(if ff_only {
                            merge::FastForward::Only
                        } else if no_ff {
                            merge::FastForward::Never
                        } else {
                            merge::FastForward::Allow
                        }),
                        no_commit: Some(no_commit),
                    },
                )?
            };
            if r.already_up_to_date && !quiet {
                println!("Already up to date.");
            }
            output::conflicts(&r.conflicts, true);
            if quiet {
                return Ok(if r.conflicts.is_empty() { 0 } else { 1 });
            }
            if !r.conflicts.is_empty() {
                return Ok(1);
            }
            if !abort && !r.already_up_to_date && !r.pending {
                let new = head_info(&repo::open(&path)?)?.id.unwrap();
                if let Some(old) = old {
                    if r.fast_forward {
                        println!("Updating {}..{}\nFast-forward", &old[..7], &new[..7]);
                    } else {
                        println!("Merge made by the 'ort' strategy.");
                    }
                    output::stat(
                        &changes::diff(changes::DiffParams {
                            repo: path,
                            from: Some(old),
                            to: Some(new),
                            staged: None,
                            path: None,
                            context: None,
                        })?,
                        true,
                    );
                }
            }
        }
        Command::Rebase {
            abort,
            resume,
            skip,
            upstream,
        } => {
            let r = if abort {
                rebase::abort(&repository)?
            } else if resume || skip {
                rebase::resume(&repository, skip)?
            } else {
                rebase::start(
                    &repository,
                    rebase::RebaseParams {
                        repo: path.clone(),
                        onto: Some(required(upstream, "rebase")?),
                        branch: None,
                    },
                )?
            };
            if quiet {
                output::conflicts(&r.conflicts, false);
                return Ok(if r.conflicts.is_empty() { 0 } else { 1 });
            }
            if let Some(id) = &r.resolved {
                let commit = repository
                    .find_commit(
                        gix::ObjectId::from_hex(id.as_bytes())
                            .map_err(|e| error("rebase output", e))?,
                    )
                    .map_err(|e| error("rebase output", e))?;
                let decoded = commit.decode().map_err(|e| error("rebase output", e))?;
                println!(
                    "[detached HEAD {}] {}",
                    &id[..7],
                    decoded.message.to_str_lossy().lines().next().unwrap_or("")
                );
                output::commit_stat(&changes::diff(changes::DiffParams {
                    repo: path,
                    from: Some(decoded.parents[0].to_string()),
                    to: Some(id.clone()),
                    staged: None,
                    path: None,
                    context: None,
                })?);
            }
            output::conflicts(&r.conflicts, false);
            if !r.conflicts.is_empty() {
                return Ok(1);
            }
        }
        Command::Worktree { command } => match command {
            Worktree::Prune => worktrees::prune(&repository)?,
            Worktree::List { porcelain } => {
                let common = repository
                    .common_dir()
                    .canonicalize()
                    .map_err(|e| error("worktree list", e))?;
                let mut paths = vec![
                    common
                        .parent()
                        .ok_or_else(|| error("worktree list", "no worktree"))?
                        .to_owned(),
                ];
                if let Ok(admins) = std::fs::read_dir(common.join("worktrees")) {
                    let mut linked = Vec::new();
                    for admin in admins {
                        let admin = admin.map_err(|e| error("worktree list", e))?;
                        let gitfile = std::fs::read_to_string(admin.path().join("gitdir"))
                            .map_err(|e| error("worktree list", e))?;
                        if let Some(parent) = std::path::Path::new(gitfile.trim()).parent() {
                            linked.push(parent.to_owned());
                        }
                    }
                    linked.sort();
                    paths.extend(linked);
                }
                let width = paths
                    .iter()
                    .map(|p| p.to_string_lossy().len())
                    .max()
                    .unwrap_or(0)
                    + 2;
                for p in paths {
                    let p = p
                        .canonicalize()
                        .map_err(|e| error("worktree list path", e))?;
                    let linked = repo::open(&p.to_string_lossy())?;
                    let head = head_info(&linked)?;
                    let id = head.id.unwrap_or_else(|| "0".repeat(40));
                    if porcelain {
                        println!("worktree {}\nHEAD {}", p.display(), id);
                        if let Some(branch) = head.branch {
                            println!("branch {branch}");
                        } else {
                            println!("detached");
                        }
                        println!();
                    } else {
                        let branch = head
                            .branch
                            .map(|b| format!("[{}]", b.trim_start_matches("refs/heads/")))
                            .unwrap_or_else(|| "(detached HEAD)".into());
                        println!("{:width$}{} {}", p.display().to_string(), &id[..7], branch);
                    }
                }
            }
            Worktree::Add {
                detach,
                branch,
                path: target,
                revision,
            } => {
                let branch = branch.unwrap_or_else(|| {
                    std::path::Path::new(&target)
                        .file_name()
                        .unwrap()
                        .to_string_lossy()
                        .into_owned()
                });
                let info = worktrees::add(
                    &repository,
                    worktrees::AddParams {
                        repo: path,
                        path: std::path::absolute(target)
                            .map_err(|e| error("worktree path", e))?
                            .to_string_lossy()
                            .into_owned(),
                        branch,
                        detached: Some(detach),
                        from: revision,
                        adopt: None,
                    },
                )?;
                let linked = repo::open(&info.path)?;
                let commit = linked
                    .head_commit()
                    .map_err(|e| error("worktree HEAD", e))?;
                let decoded = commit.decode().map_err(|e| error("worktree HEAD", e))?;
                println!(
                    "HEAD is now at {} {}",
                    &commit.id.to_string()[..7],
                    decoded.message.to_str_lossy().lines().next().unwrap_or("")
                );
            }
            Worktree::Remove { force, path } => {
                let target = std::path::absolute(path)
                    .map_err(|e| error("worktree remove", e))?
                    .to_string_lossy()
                    .into_owned();
                worktrees::remove(
                    &repo::open(&target)?,
                    worktrees::RemoveParams {
                        repo: target,
                        force: Some(force),
                    },
                )?;
            }
        },
        Command::Show { revision, stat } => {
            let object = repository
                .rev_parse_single(revision.as_deref().unwrap_or("HEAD"))
                .map_err(|e| error("show", e))?
                .object()
                .map_err(|e| error("show", e))?;
            if object.kind == gix::objs::Kind::Blob {
                use std::io::Write;
                std::io::stdout()
                    .write_all(&object.data)
                    .map_err(|e| error("show", e))?;
            } else {
                let commit = object.peel_to_commit().map_err(|e| error("show", e))?;
                let merge_commit = commit.parent_ids().count() > 1;
                if merge_commit && !stat {
                    let mut common: Option<std::collections::BTreeSet<String>> = None;
                    for parent in commit.parent_ids() {
                        let names = changes::diff(changes::DiffParams {
                            repo: path.clone(),
                            from: Some(parent.to_string()),
                            to: Some(commit.id.to_string()),
                            staged: None,
                            path: None,
                            context: None,
                        })?
                        .into_iter()
                        .map(|d| d.path)
                        .collect::<std::collections::BTreeSet<_>>();
                        common = Some(match common {
                            None => names,
                            Some(paths) => paths.intersection(&names).cloned().collect(),
                        });
                    }
                    if common.is_some_and(|paths| !paths.is_empty()) {
                        eprintln!(
                            "usage: git show: combined merge diffs are not supported (see README.md)"
                        );
                        return Ok(129);
                    }
                }
                output::commit(&commit)?;
                println!();
                if merge_commit && !stat {
                    return Ok(0);
                }
                let old = match commit.parent_ids().next() {
                    Some(id) => id.to_string(),
                    None => repository
                        .write_object(&gix::objs::Tree { entries: vec![] })
                        .map_err(|e| error("show", e))?
                        .to_string(),
                };
                let diffs = changes::diff(changes::DiffParams {
                    repo: path,
                    from: Some(old),
                    to: Some(commit.id.to_string()),
                    staged: None,
                    path: None,
                    context: None,
                })?;
                if stat {
                    output::stat(&diffs, false);
                } else {
                    for diff in diffs {
                        print!("{}", diff.patch);
                    }
                }
            }
        }
        Command::Fetch { remote, revision } => network::fetch(&path, &remote, revision.as_deref())?,
        Command::Push {
            set_upstream,
            force,
            remote,
            refspec,
        } => {
            push::push(push::PushParams {
                repo: path,
                remote: Some(remote),
                branch: None,
                refspec,
                force: Some(force),
                set_upstream: Some(set_upstream),
                delete: None,
            })?;
        }
        Command::Init { .. } | Command::Clone { .. } => unreachable!(),
    }
    Ok(0)
}
fn code(k: &changes::Kind) -> char {
    match k {
        changes::Kind::Added => 'A',
        changes::Kind::Modified => 'M',
        changes::Kind::Deleted => 'D',
        changes::Kind::Renamed => 'R',
    }
}