use std::path::{Path, PathBuf};

use proto::client::Intercepted;
use proto::kenshell::common::v1::PageRequest;
use proto::kenshell::v1 as pb;
use proto::kenshell::v1::commit_service_client::CommitServiceClient;
use proto::kenshell::v1::diff_service_client::DiffServiceClient;
use proto::kenshell::v1::ref_service_client::RefServiceClient;
use proto::kenshell::v1::tree_service_client::TreeServiceClient;

use crate::rpcgit::GitBaby;
use crate::rpcgit::archive::types::{
    ArchiveFormat, BundleRequest, CreateArchiveRequest, GetArchiveRequest,
};
use crate::rpcgit::blame::types::{BlameHunk, BlameOptions};
use crate::rpcgit::blob::types::{
    BlobContent, BlobInfo, GetBlobOptions, LFSPointer, ListLFSPointersOptions,
};
use crate::rpcgit::branch::types::{BranchInfo, ListBranchesOptions};
use crate::rpcgit::commit::types::{
    CommitInfo, CommitShortStat, CommitStats, ListCommitsOptions, Signature, TreeEntry,
    TreeEntryMode,
};
use crate::rpcgit::conflict::types::ListConflictOptions;
use crate::rpcgit::diff::types::{
    ChangedPath, ChangedPathDiff, ChangedPathRequest, DiffOptions, DiffRequest, DiffStatus,
    NumStat, RangeDiffSpec, ShortStat,
};
use crate::rpcgit::error::BabyError;
use crate::rpcgit::oid::ObjectId;
use crate::rpcgit::refs::types::{ListRefsOptions, RefInfo, RefType};
use crate::rpcgit::setup::types::ObjectFormat;
use crate::rpcgit::tags::types::{
    CreateTagOptions, ListTagsOptions, TagInfo, TagType, TagVerifyResult,
};
use crate::rpcgit::tree::types::{
    DiffTreesOptions, TreeDiff, TreeDiffStatus, TreeEntryWithLatest, WalkTreeOptions,
};

fn unsupported(what: &str) -> BabyError {
    BabyError::Custom(format!("{what} is not provided by KenShell"))
}

fn oid(text: &str) -> Result<ObjectId, BabyError> {
    ObjectId::parse(text).map_err(|_| BabyError::RevisionInvalid(text.to_string()))
}

fn oid_opt(text: &str) -> Option<ObjectId> {
    if text.trim().is_empty() {
        None
    } else {
        ObjectId::parse(text).ok()
    }
}

fn signature(person: Option<pb::CommitPerson>) -> Signature {
    let person = person.unwrap_or_default();
    Signature {
        name: person.name,
        email: person.email,
        time: person
            .at
            .and_then(|at| time::OffsetDateTime::from_unix_timestamp(at.seconds).ok())
            .unwrap_or(time::OffsetDateTime::UNIX_EPOCH),
    }
}

/// 仓库概览，字段全部来自 KenShell。
#[derive(Debug, Clone, Default)]
pub struct RepositoryOverviewInfo {
    pub default_branch: String,
    pub primary_language: Option<String>,
    pub object_format: String,
    pub size_bytes: i64,
    pub branch_count: i32,
    pub tag_count: i32,
}

fn mode_of(text: &str) -> TreeEntryMode {
    TreeEntryMode::from_octal_str(text).unwrap_or(TreeEntryMode::Blob)
}

/// `google.protobuf.Timestamp` → `OffsetDateTime`；非法值当作缺失。
fn at(value: Option<prost_types::Timestamp>) -> Option<time::OffsetDateTime> {
    value.and_then(|at| time::OffsetDateTime::from_unix_timestamp(at.seconds).ok())
}

fn entry_from_view(view: pb::TreeEntryView) -> TreeEntry {
    let name = if view.name_bytes.is_empty() {
        view.name
    } else {
        String::from_utf8_lossy(&view.name_bytes).into_owned()
    };
    let mode =
        match pb::TreeEntryType::try_from(view.r#type).unwrap_or(pb::TreeEntryType::Unspecified) {
            pb::TreeEntryType::Submodule => TreeEntryMode::Submodule,
            pb::TreeEntryType::Symlink => TreeEntryMode::Symlink,
            _ => mode_of(&view.mode),
        };
    TreeEntry {
        oid: oid(&view.oid).unwrap_or_else(|_| {
            oid_opt("4b825dc642cb6eb9a060e54bf8d69288fbee4904").expect("empty tree")
        }),
        name,
        mode,
        size: Some(view.size_bytes),
    }
}

fn entry_from_view_path(view: pb::TreeEntryView) -> TreeEntry {
    let mut entry = entry_from_view(view.clone());
    if !view.path.is_empty() {
        entry.name = view.path;
    }
    entry
}

fn commit_from_view(view: pb::CommitView) -> CommitInfo {
    CommitInfo {
        id: oid(&view.id)
            .unwrap_or_else(|_| oid_opt("0000000000000000000000000000000000000000").expect("zero")),
        tree_id: oid(&view.tree_id).unwrap_or_else(|_| {
            oid_opt("4b825dc642cb6eb9a060e54bf8d69288fbee4904").expect("empty tree")
        }),
        parents: view
            .parent_ids
            .iter()
            .filter_map(|p| ObjectId::parse(p).ok())
            .collect(),
        author: signature(view.author),
        committer: signature(view.committer),
        message: view.message,
        gpg_signature: None,
    }
}

fn ref_type(value: i32) -> RefType {
    match pb::RefType::try_from(value).unwrap_or(pb::RefType::Unspecified) {
        pb::RefType::Branch => RefType::Branch,
        pb::RefType::Tag => RefType::Tag,
        pb::RefType::RemoteBranch => RefType::Remote,
        _ => RefType::Other,
    }
}

fn path_or_empty(path: Option<PathBuf>) -> String {
    path.map(|p| p.to_string_lossy().into_owned())
        .unwrap_or_default()
}

fn page_request(page_size: u32, token: String) -> PageRequest {
    PageRequest {
        page_size,
        page_token: token,
    }
}

fn changed_path(view: pb::ChangedPathView) -> ChangedPath {
    ChangedPath {
        old_path: if view.old_path.is_empty() {
            None
        } else {
            Some(PathBuf::from(view.old_path))
        },
        new_path: PathBuf::from(view.new_path),
        old_mode: view.old_mode,
        new_mode: view.new_mode,
        old_oid: oid_opt(&view.old_oid),
        new_oid: oid_opt(&view.new_oid),
        status: {
            let __inline = |text: &str| -> DiffStatus {
                match text {
                    "A" | "added" | "Added" => DiffStatus::Added,
                    "D" | "deleted" | "Deleted" => DiffStatus::Deleted,
                    "T" | "type_changed" | "TypeChanged" => DiffStatus::TypeChanged,
                    "R" | "renamed" | "Renamed" => DiffStatus::Renamed,
                    "C" | "copied" | "Copied" => DiffStatus::Copied,
                    _ => DiffStatus::Modified,
                }
            };
            __inline(&view.status)
        },
    }
}

impl GitBaby {
    fn common_ref(&self) -> proto::kenshell::common::v1::RepositoryRef {
        self.context().repository_ref()
    }

    fn refs_client(&self) -> RefServiceClient<Intercepted> {
        self.context().ks.refs()
    }

    fn commit_client(&self) -> CommitServiceClient<Intercepted> {
        self.context().ks.commit()
    }

    fn tree_client(&self) -> TreeServiceClient<Intercepted> {
        self.context().ks.tree()
    }

    fn diff_client(&self) -> DiffServiceClient<Intercepted> {
        self.context().ks.diff()
    }

    fn repository_ref_some(&self) -> Option<proto::kenshell::common::v1::RepositoryRef> {
        Some(self.common_ref())
    }

    pub async fn rev_parse(&self, revision: &str) -> Result<ObjectId, BabyError> {
        let mut client = self.commit_client();
        let response = client
            .rev_parse(pb::RevParseRequest {
                repository: self.repository_ref_some(),
                revision: revision.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        oid(&response.oid)
    }

    pub async fn resolve_revision(&self, revision: &str) -> Result<ObjectId, BabyError> {
        self.rev_parse(revision).await
    }

    pub async fn is_ancestor(&self, ancestor: &str, descendant: &str) -> Result<bool, BabyError> {
        let mut client = self.commit_client();
        let response = client
            .is_ancestor(pb::IsAncestorRequest {
                repository: self.repository_ref_some(),
                ancestor: ancestor.to_string(),
                descendant: descendant.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.is_ancestor)
    }

    pub async fn get_commit(&self, revision: &str) -> Result<CommitInfo, BabyError> {
        let mut client = self.commit_client();
        let response = client
            .get_commit(pb::GetCommitRequest {
                repository: self.repository_ref_some(),
                commit_id: revision.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        response
            .commit
            .map(commit_from_view)
            .ok_or_else(|| BabyError::RevisionNotFound(revision.to_string()))
    }

    pub async fn list_commits(
        &self,
        opts: ListCommitsOptions,
    ) -> Result<Vec<CommitInfo>, BabyError> {
        let limit = opts.max_count.unwrap_or(50).max(1);
        let skip = opts.skip.unwrap_or(0);
        let mut out = Vec::new();
        let mut token = String::new();
        let mut seen = 0u32;
        loop {
            let mut client = self.commit_client();
            let response = client
                .list_commits(pb::ListCommitsRequest {
                    repository: self.repository_ref_some(),
                    revision: opts.revision.clone(),
                    path: path_or_empty(opts.path.clone()),
                    query: String::new(),
                    first_parent: opts.first_parent,
                    page: Some(page_request(limit.min(200), token.clone())),
                    since: opts.since.clone().unwrap_or_default(),
                    until: opts.until.clone().unwrap_or_default(),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            for commit in response.commits {
                if seen >= skip {
                    out.push(commit_from_view(commit));
                }
                seen += 1;
            }
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if out.len() >= limit as usize || next.is_empty() {
                break;
            }
            token = next;
        }
        out.truncate(limit as usize);
        Ok(out)
    }

    pub async fn count_commits(&self, opts: ListCommitsOptions) -> Result<u64, BabyError> {
        let mut client = self.commit_client();
        let response = client
            .list_commits(pb::ListCommitsRequest {
                repository: self.repository_ref_some(),
                revision: opts.revision,
                path: path_or_empty(opts.path),
                query: String::new(),
                first_parent: opts.first_parent,
                page: Some(page_request(1, String::new())),
                since: opts.since.unwrap_or_default(),
                until: opts.until.unwrap_or_default(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response
            .total
            .or_else(|| response.page.as_ref().and_then(|p| p.total_size))
            .unwrap_or(0))
    }

    pub async fn commit_stats(
        &self,
        revision: &str,
        path: Option<&Path>,
    ) -> Result<CommitStats, BabyError> {
        let mut client = self.commit_client();
        let response = client
            .get_commit_stats(pb::GetCommitStatsRequest {
                repository: self.repository_ref_some(),
                commit_id: revision.to_string(),
                path: path
                    .map(|p| p.to_string_lossy().into_owned())
                    .unwrap_or_default(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let stats = response.stats.unwrap_or_default();
        Ok(CommitStats {
            additions: stats.additions as u64,
            deletions: stats.deletions as u64,
        })
    }

    pub async fn commit_short_stats(
        &self,
        revision: &str,
    ) -> Result<Vec<CommitShortStat>, BabyError> {
        let commits = self
            .list_commits(ListCommitsOptions {
                revision: revision.to_string(),
                max_count: Some(200),
                ..Default::default()
            })
            .await?;
        let mut out = Vec::with_capacity(commits.len());
        for commit in commits {
            let stats = self
                .commit_stats(&commit.id.to_string(), None)
                .await
                .unwrap_or_default();
            out.push(CommitShortStat {
                oid: commit.id,
                author_name: commit.author.name,
                author_email: commit.author.email,
                additions: stats.additions,
                deletions: stats.deletions,
            });
        }
        Ok(out)
    }

    pub async fn blame_all(&self, opts: BlameOptions) -> Result<Vec<BlameHunk>, BabyError> {
        let mut client = self.commit_client();
        let mut token = String::new();
        let mut hunks: Vec<BlameHunk> = Vec::new();
        loop {
            let response = client
                .list_blame(pb::ListBlameRequest {
                    repository: self.repository_ref_some(),
                    revision: opts.revision.clone(),
                    path: opts.path.to_string_lossy().into_owned(),
                    page: Some(page_request(500, token.clone())),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            for line in response.lines {
                let sha = ObjectId::parse(&line.commit_id).unwrap_or_else(|_| {
                    ObjectId::parse("0000000000000000000000000000000000000000").expect("zero")
                });
                match hunks.last_mut() {
                    Some(last) if last.sha == sha => {
                        last.lines.push(line.content);
                        last.final_line_count += 1;
                    }
                    _ => hunks.push(BlameHunk {
                        sha,
                        previous_sha: None,
                        previous_path: None,
                        lines: vec![line.content],
                        final_start_line: line.line_number,
                        final_line_count: 1,
                        orig_start_line: 0,
                    }),
                }
            }
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if next.is_empty() {
                break;
            }
            token = next;
        }
        Ok(hunks)
    }

    pub async fn get_tree_entries(
        &self,
        revision: &str,
        path: &Path,
    ) -> Result<Vec<TreeEntry>, BabyError> {
        let mut client = self.tree_client();
        let response = client
            .get_tree(pb::GetTreeRequest {
                repository: self.repository_ref_some(),
                revision: revision.to_string(),
                path: path.to_string_lossy().into_owned(),
                page: None,
                path_bytes: Vec::new(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.entries.into_iter().map(entry_from_view).collect())
    }

    pub async fn tree_entry_at(
        &self,
        revision: &str,
        path: &Path,
    ) -> Result<Option<TreeEntry>, BabyError> {
        let mut client = self.tree_client();
        let response = client
            .resolve_tree_path(pb::ResolveTreePathRequest {
                repository: self.repository_ref_some(),
                revision: revision.to_string(),
                path: path.to_string_lossy().into_owned(),
                path_bytes: Vec::new(),
            })
            .await;
        match response {
            Ok(response) => Ok(response.into_inner().entry.map(entry_from_view)),
            Err(status) if status.code() == tonic::Code::NotFound => Ok(None),
            Err(status) => Err(BabyError::from(status)),
        }
    }

    pub async fn walk_tree(
        &self,
        revision: &str,
        path: &Path,
        opts: WalkTreeOptions,
    ) -> Result<Vec<TreeEntry>, BabyError> {
        let mut client = self.tree_client();
        let mut token = String::new();
        let mut out = Vec::new();
        loop {
            let response = client
                .list_files(pb::ListFilesRequest {
                    repository: self.repository_ref_some(),
                    revision: revision.to_string(),
                    path: path.to_string_lossy().into_owned(),
                    recursive: opts.recurse,
                    page: Some(page_request(200, token.clone())),
                    include_directories: opts.show_trees,
                    path_bytes: Vec::new(),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            out.extend(response.files.into_iter().map(entry_from_view_path));
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if next.is_empty() {
                break;
            }
            token = next;
        }
        Ok(out)
    }

    pub async fn list_dir(
        &self,
        revision: &str,
        path: Option<&str>,
    ) -> Result<Vec<TreeEntry>, BabyError> {
        let mut client = self.tree_client();
        let response = client
            .get_tree(pb::GetTreeRequest {
                repository: self.repository_ref_some(),
                revision: revision.to_string(),
                path: path.unwrap_or("").to_string(),
                page: None,
                path_bytes: Vec::new(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.entries.into_iter().map(entry_from_view).collect())
    }

    async fn entries_with_latest(
        &self,
        revision: &str,
        path: Option<&str>,
        recursive: bool,
    ) -> Result<Vec<TreeEntryWithLatest>, BabyError> {
        let mut client = self.tree_client();
        let mut token = String::new();
        let mut out = Vec::new();
        loop {
            let response = client
                .get_tree(pb::GetTreeRequest {
                    repository: self.repository_ref_some(),
                    revision: revision.to_string(),
                    path: path.unwrap_or("").to_string(),
                    page: Some(page_request(200, token.clone())),
                    path_bytes: Vec::new(),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            for entry in response.entries {
                let latest = entry
                    .latest_commit
                    .clone()
                    .map(commit_from_view)
                    .unwrap_or_else(|| commit_from_view(pb::CommitView::default()));
                out.push(TreeEntryWithLatest {
                    entry: entry_from_view(entry),
                    latest,
                });
            }
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if next.is_empty() {
                break;
            }
            token = next;
        }
        if recursive {
            let mut full = Vec::new();
            for item in out {
                if item.entry.mode == TreeEntryMode::Tree {
                    continue;
                }
                full.push(item);
            }
            return Ok(full);
        }
        Ok(out)
    }

    pub async fn tree_entries_with_latest(
        &self,
        revision: &str,
        path: Option<&str>,
    ) -> Result<Vec<TreeEntryWithLatest>, BabyError> {
        self.entries_with_latest(revision, path, false).await
    }

    pub async fn tree_dir_entries_with_latest(
        &self,
        revision: &str,
        path: Option<&str>,
    ) -> Result<Vec<TreeEntryWithLatest>, BabyError> {
        self.entries_with_latest(revision, path, false).await
    }

    pub async fn get_blob(
        &self,
        oid_value: ObjectId,
        opts: GetBlobOptions,
    ) -> Result<BlobContent, BabyError> {
        let mut client = self.context().ks.blob();
        let response = client
            .get_blob_content(pb::GetBlobContentRequest {
                repository: self.repository_ref_some(),
                oid: oid_value.to_string(),
                max_bytes: opts.limit.unwrap_or(0).max(0) as u64,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let content = response.content.unwrap_or_default();
        let size = content.size;
        Ok(BlobContent {
            info: BlobInfo {
                oid: oid_opt(&content.oid).unwrap_or(oid_value),
                size,
                data: Some(content.data.clone()),
            },
            data: content.data,
        })
    }

    pub async fn get_blob_size(&self, oid_value: ObjectId) -> Result<i64, BabyError> {
        let mut client = self.context().ks.blob();
        let response = client
            .get_blob_metadata(pb::GetBlobMetadataRequest {
                repository: self.repository_ref_some(),
                oid: oid_value.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.metadata.map(|m| m.size).unwrap_or(0))
    }

    pub async fn list_lfs_pointers(
        &self,
        opts: ListLFSPointersOptions,
    ) -> Result<Vec<LFSPointer>, BabyError> {
        let mut client = self.context().ks.blob();
        let response = client
            .list_lfs_pointers(pb::ListLfsPointersRequest {
                repository: self.repository_ref_some(),
                revision: opts.revisions.first().cloned().unwrap_or_default(),
                limit: opts.limit.unwrap_or(100),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response
            .pointers
            .into_iter()
            .map(|p| LFSPointer {
                oid: oid_opt(&p.oid).unwrap_or_else(|| {
                    oid_opt("0000000000000000000000000000000000000000").expect("zero")
                }),
                size: p.size,
                file_oid: oid_opt("0000000000000000000000000000000000000000").expect("zero"),
                file_size: p.size,
                content: Vec::new(),
            })
            .collect())
    }

    pub async fn list_refs(&self, opts: ListRefsOptions) -> Result<Vec<RefInfo>, BabyError> {
        let mut client = self.refs_client();
        let mut out = Vec::new();
        let mut token = String::new();
        let prefix = opts.patterns.first().cloned().unwrap_or_default();
        let limit = opts.limit.unwrap_or(500);
        loop {
            let response = client
                .list_refs(pb::ListRefsRequest {
                    repository: self.repository_ref_some(),
                    prefix: prefix.clone(),
                    page: Some(page_request(limit.min(200), token.clone())),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            for item in response.refs {
                out.push(RefInfo {
                    name: item.name,
                    ref_type: ref_type(item.r#type),
                    sha: oid(&item.sha).unwrap_or_else(|_| {
                        oid_opt("0000000000000000000000000000000000000000").expect("zero")
                    }),
                    peeled: None,
                });
            }
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if next.is_empty() || out.len() >= limit as usize {
                break;
            }
            token = next;
        }
        if !opts.patterns.is_empty() {
            out.retain(|r| opts.patterns.iter().any(|p| r.name.contains(p.as_str())));
        }
        if !opts.exclude_patterns.is_empty() {
            out.retain(|r| {
                !opts
                    .exclude_patterns
                    .iter()
                    .any(|p| r.name.contains(p.as_str()))
            });
        }
        Ok(out)
    }

    pub async fn find_refs_by_oid(&self, target: ObjectId) -> Result<Vec<RefInfo>, BabyError> {
        let refs = self.list_refs(ListRefsOptions::default()).await?;
        Ok(refs.into_iter().filter(|r| r.sha == target).collect())
    }

    pub async fn update_ref(
        &self,
        name: &str,
        new_sha: ObjectId,
        old_sha: Option<ObjectId>,
    ) -> Result<(), BabyError> {
        let branch = name
            .strip_prefix("refs/heads/")
            .ok_or_else(|| unsupported("updating non-branch refs"))?;
        let mut client = self.context().ks.command();
        client
            .update_branch(pb::UpdateBranchRequest {
                repository: self.repository_ref_some(),
                name: branch.to_string(),
                new_sha: new_sha.to_string(),
                expected_old_sha: old_sha.map(|o| o.to_string()).unwrap_or_default(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn delete_ref(&self, name: &str) -> Result<(), BabyError> {
        let branch = name
            .strip_prefix("refs/heads/")
            .ok_or_else(|| unsupported("deleting non-branch refs"))?;
        let mut client = self.context().ks.command();
        client
            .delete_branch(pb::DeleteBranchRequest {
                repository: self.repository_ref_some(),
                name: branch.to_string(),
                expected_sha: String::new(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
                force: true,
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn set_default_branch(&self, name: &str) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .set_default_branch(pb::SetDefaultBranchRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn get_default_branch(&self) -> Result<String, BabyError> {
        let mut client = self.refs_client();
        let response = client
            .get_default_branch(pb::GetDefaultBranchRequest {
                repository: self.repository_ref_some(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        if response.name.is_empty() {
            Err(BabyError::RevisionNotFound("HEAD".into()))
        } else {
            Ok(response.name)
        }
    }

    pub async fn list_branches(
        &self,
        opts: ListBranchesOptions,
    ) -> Result<Vec<BranchInfo>, BabyError> {
        let mut client = self.refs_client();
        let mut token = String::new();
        let mut out = Vec::new();
        loop {
            let response = client
                .list_branches(pb::ListBranchesRequest {
                    repository: self.repository_ref_some(),
                    query: opts.patterns.first().cloned().unwrap_or_default(),
                    sort: pb::BranchSort::NameAsc as i32,
                    page: Some(page_request(200, token.clone())),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            for branch in response.branches {
                out.push(BranchInfo {
                    name: branch.name,
                    sha: oid(&branch.sha).unwrap_or_else(|_| {
                        oid_opt("0000000000000000000000000000000000000000").expect("zero")
                    }),
                    is_protected: branch.is_protected,
                    is_deleted: branch.is_deleted,
                    deleted_at: at(branch.deleted_at),
                    created_at: at(branch.created_at),
                    updated_at: at(branch.updated_at),
                });
            }
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if next.is_empty() {
                break;
            }
            token = next;
        }
        Ok(out)
    }

    pub async fn find_branch(&self, name: &str) -> Result<BranchInfo, BabyError> {
        let mut client = self.refs_client();
        let response = client
            .get_branch(pb::GetBranchRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let branch = response
            .branch
            .ok_or_else(|| BabyError::BranchNotFound(name.to_string()))?;
        Ok(BranchInfo {
            name: branch.name,
            sha: oid(&branch.sha).unwrap_or_else(|_| {
                oid_opt("0000000000000000000000000000000000000000").expect("zero")
            }),
            is_protected: branch.is_protected,
            is_deleted: branch.is_deleted,
            deleted_at: at(branch.deleted_at),
            created_at: at(branch.created_at),
            updated_at: at(branch.updated_at),
        })
    }

    pub async fn create_branch(
        &self,
        name: &str,
        start_point: Option<&str>,
    ) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .create_branch(pb::CreateBranchRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
                start_point: start_point.unwrap_or("").to_string(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn delete_branch(&self, name: &str, force: bool) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .delete_branch(pb::DeleteBranchRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
                expected_sha: String::new(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
                force,
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn rename_branch(&self, from: &str, to: &str) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .rename_branch(pb::RenameBranchRequest {
                repository: self.repository_ref_some(),
                name: from.to_string(),
                new_name: to.to_string(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn list_tags(&self, opts: ListTagsOptions) -> Result<Vec<TagInfo>, BabyError> {
        let mut client = self.refs_client();
        let mut token = String::new();
        let mut out = Vec::new();
        loop {
            let response = client
                .list_tags(pb::ListTagsRequest {
                    repository: self.repository_ref_some(),
                    query: opts.patterns.first().cloned().unwrap_or_default(),
                    sort: pb::TagSort::NameAsc as i32,
                    page: Some(page_request(200, token.clone())),
                })
                .await
                .map_err(BabyError::from)?
                .into_inner();
            for tag in response.tags {
                out.push(tag_from_view(tag));
            }
            let next = response
                .page
                .as_ref()
                .map(|p| p.next_page_token.clone())
                .unwrap_or_default();
            if next.is_empty() {
                break;
            }
            token = next;
        }
        Ok(out)
    }

    pub async fn find_tag(&self, name: &str) -> Result<TagInfo, BabyError> {
        let mut client = self.refs_client();
        let response = client
            .get_tag(pb::GetTagRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        response
            .tag
            .map(tag_from_view)
            .ok_or_else(|| BabyError::TagNotFound(name.to_string()))
    }

    pub async fn create_lightweight_tag(&self, opts: CreateTagOptions) -> Result<(), BabyError> {
        self.create_tag(opts, false).await
    }

    pub async fn create_annotated_tag(&self, opts: CreateTagOptions) -> Result<(), BabyError> {
        self.create_tag(opts, true).await
    }

    async fn create_tag(&self, opts: CreateTagOptions, annotated: bool) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .create_tag(pb::CreateTagRequest {
                repository: self.repository_ref_some(),
                name: opts.name,
                target_sha: opts.target,
                message: opts.message.unwrap_or_default(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
                annotated,
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn delete_tag(&self, name: &str) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .delete_tag(pb::DeleteTagRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
                expected_sha: String::new(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn raw_diff(
        &self,
        req: &DiffRequest,
        _opts: Option<&DiffOptions>,
    ) -> Result<String, BabyError> {
        let mut client = self.diff_client();
        let mut stream = client
            .get_raw_diff(pb::GetRawDiffRequest {
                repository: self.repository_ref_some(),
                base_revision: req.left.to_string(),
                head_revision: req.right.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let mut out = Vec::new();
        while let Some(chunk) = stream.message().await.map_err(BabyError::from)? {
            out.extend_from_slice(&chunk.data);
        }
        Ok(String::from_utf8_lossy(&out).into_owned())
    }

    pub async fn range_diff(
        &self,
        spec: &RangeDiffSpec,
        _opts: &DiffOptions,
        _hex_len: Option<u8>,
    ) -> Result<String, BabyError> {
        let (from, to, base) = match spec {
            RangeDiffSpec::Range(a, b) => (a.clone(), b.clone(), String::new()),
            RangeDiffSpec::RevisionRange(a, b) => (a.clone(), b.clone(), String::new()),
            RangeDiffSpec::BaseWithRevisions(base, a, b) => (a.clone(), b.clone(), base.clone()),
        };
        let mut client = self.diff_client();
        let mut stream = client
            .get_range_diff(pb::GetRangeDiffRequest {
                repository: self.repository_ref_some(),
                from,
                to,
                base,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let mut out = Vec::new();
        while let Some(chunk) = stream.message().await.map_err(BabyError::from)? {
            out.extend_from_slice(&chunk.data);
        }
        Ok(String::from_utf8_lossy(&out).into_owned())
    }

    pub async fn shortstat(
        &self,
        req: &DiffRequest,
        _opts: &DiffOptions,
    ) -> Result<ShortStat, BabyError> {
        let mut client = self.diff_client();
        let response = client
            .get_diff_short_stat(pb::GetDiffShortStatRequest {
                repository: self.repository_ref_some(),
                base_revision: req.left.to_string(),
                head_revision: req.right.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let stats = response.stats.unwrap_or_default();
        Ok(ShortStat {
            files_changed: stats.files_changed,
            additions: stats.additions,
            deletions: stats.deletions,
        })
    }

    pub async fn diff_stats(
        &self,
        req: &DiffRequest,
        opts: &DiffOptions,
    ) -> Result<Vec<NumStat>, BabyError> {
        let mut client = self.diff_client();
        let response = client
            .list_diff_num_stats(pb::ListDiffNumStatsRequest {
                repository: self.repository_ref_some(),
                base_revision: req.left.to_string(),
                head_revision: req.right.to_string(),
                paths: opts
                    .paths
                    .as_ref()
                    .map(|paths| {
                        paths
                            .iter()
                            .map(|p| p.to_string_lossy().into_owned())
                            .collect()
                    })
                    .unwrap_or_default(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response
            .stats
            .into_iter()
            .map(|stat| NumStat {
                additions: stat.additions,
                deletions: stat.deletions,
                path: PathBuf::from(stat.path),
                old_path: None,
            })
            .collect())
    }

    pub async fn find_changed_paths(
        &self,
        requests: Vec<ChangedPathRequest>,
        _filter_status: Option<char>,
        _detect_renames: Option<u8>,
        _merge_parents: bool,
    ) -> Result<Vec<ChangedPath>, BabyError> {
        let mut client = self.diff_client();
        let (base, head, commit) = match requests.first() {
            Some(ChangedPathRequest::Commit(oid_value)) => {
                (String::new(), String::new(), oid_value.to_string())
            }
            Some(ChangedPathRequest::TreePair(left, right)) => {
                (left.to_string(), right.to_string(), String::new())
            }
            None => return Ok(Vec::new()),
        };
        let response = client
            .list_changed_paths(pb::ListChangedPathsRequest {
                repository: self.repository_ref_some(),
                base_revision: base,
                head_revision: head,
                commit_id: commit,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.paths.into_iter().map(changed_path).collect())
    }

    pub async fn commit_diff(
        &self,
        req: &DiffRequest,
        _opts: &DiffOptions,
        _hex_len: Option<u8>,
    ) -> Result<Vec<ChangedPathDiff>, BabyError> {
        let mut client = self.diff_client();
        let response = client
            .compare_commits(pb::CompareCommitsRequest {
                repository: self.repository_ref_some(),
                base_revision: req.left.to_string(),
                head_revision: req.right.to_string(),
                merge_base: false,
                path: String::new(),
                page: None,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.files.into_iter().map(changed_path_diff).collect())
    }

    pub async fn diff_trees(
        &self,
        base: &str,
        head: &str,
        _path: &Path,
        _opts: DiffTreesOptions,
    ) -> Result<Vec<TreeDiff>, BabyError> {
        let mut client = self.diff_client();
        let response = client
            .list_diff_tree(pb::ListDiffTreeRequest {
                repository: self.repository_ref_some(),
                base_revision: base.to_string(),
                head_revision: head.to_string(),
                use_merge_base: false,
                paths: Vec::new(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response
            .records
            .into_iter()
            .map(|record| TreeDiff {
                old_path: if record.base_path.is_empty() {
                    None
                } else {
                    Some(PathBuf::from(record.base_path))
                },
                new_path: if record.head_path.is_empty() {
                    None
                } else {
                    Some(PathBuf::from(record.head_path))
                },
                old_mode: Some(mode_of(&format!("{:o}", record.base_mode))),
                new_mode: Some(mode_of(&format!("{:o}", record.head_mode))),
                old_oid: oid_opt(&record.base_blob_id),
                new_oid: oid_opt(&record.head_blob_id),
                status: {
                    let __inline = |text: &str| -> TreeDiffStatus {
                        match text {
                            "A" | "added" | "Added" => TreeDiffStatus::Added,
                            "D" | "deleted" | "Deleted" => TreeDiffStatus::Deleted,
                            "T" | "type_changed" | "TypeChanged" => TreeDiffStatus::TypeChanged,
                            "R" | "renamed" | "Renamed" => TreeDiffStatus::Renamed,
                            "C" | "copied" | "Copied" => TreeDiffStatus::Copied,
                            _ => TreeDiffStatus::Modified,
                        }
                    };
                    __inline(&record.status)
                },
            })
            .collect())
    }

    pub async fn list_conflict_files(
        &self,
        base: &str,
        head: &str,
        opts: &ListConflictOptions,
    ) -> Result<Vec<crate::rpcgit::conflict::types::ConflictFile>, BabyError> {
        let mut client = self.context().ks.conflict();
        let response = client
            .check_conflicts(pb::CheckConflictsRequest {
                repository: self.repository_ref_some(),
                base_revision: base.to_string(),
                head_revision: head.to_string(),
                ancestor_revision: String::new(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let our_commit_oid = oid(base)
            .unwrap_or_else(|_| oid_opt("0000000000000000000000000000000000000000").expect("zero"));
        let mut out = Vec::new();
        for path in response
            .status
            .map(|status| status.paths)
            .unwrap_or_default()
        {
            let content = if opts.skip_content {
                None
            } else {
                let mut client = self.context().ks.conflict();
                client
                    .get_conflict_detail(pb::GetConflictDetailRequest {
                        repository: self.repository_ref_some(),
                        base_revision: base.to_string(),
                        head_revision: head.to_string(),
                        path: path.clone(),
                    })
                    .await
                    .ok()
                    .map(|response| response.into_inner().content)
            };
            out.push(crate::rpcgit::conflict::types::ConflictFile {
                header: crate::rpcgit::conflict::types::ConflictFileHeader {
                    our_commit_oid: our_commit_oid.clone(),
                    their_path: Some(PathBuf::from(&path)),
                    our_path: Some(PathBuf::from(&path)),
                    ancestor_path: None,
                    our_mode: 0,
                },
                content,
            });
        }
        Ok(out)
    }

    pub async fn commit_ids_between_reverse(
        &self,
        start: &str,
        end: &str,
        _limit: Option<u32>,
        max_count: Option<u32>,
    ) -> Result<Vec<ObjectId>, BabyError> {
        let commits = self
            .list_commits(ListCommitsOptions {
                revision: format!("{start}..{end}"),
                max_count,
                ..Default::default()
            })
            .await?;
        let mut ids: Vec<ObjectId> = commits.into_iter().map(|commit| commit.id).collect();
        ids.reverse();
        Ok(ids)
    }

    pub async fn conflict_detail(
        &self,
        base: &str,
        head: &str,
        path: &str,
    ) -> Result<String, BabyError> {
        let mut client = self.context().ks.conflict();
        let response = client
            .get_conflict_detail(pb::GetConflictDetailRequest {
                repository: self.repository_ref_some(),
                base_revision: base.to_string(),
                head_revision: head.to_string(),
                path: path.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.content)
    }

    pub async fn list_remotes(&self) -> Result<Vec<(String, String)>, BabyError> {
        let mut client = self.context().ks.remote();
        let response = client
            .list_remotes(pb::ListRemotesRequest {
                repository: self.repository_ref_some(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response
            .remotes
            .into_iter()
            .map(|remote| (remote.name, remote.fetch_url))
            .collect())
    }

    pub async fn remove_remote(&self, name: &str) -> Result<(), BabyError> {
        let mut client = self.context().ks.remote();
        client
            .remove_remote(pb::RemoveRemoteRequest {
                repository: self.repository_ref_some(),
                name: name.to_string(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn create_archive(&self, req: CreateArchiveRequest) -> Result<(), BabyError> {
        let mut client = self.context().ks.archive();
        client
            .start_archive(pb::StartArchiveRequest {
                repository: self.repository_ref_some(),
                revision: req.commit,
                format: archive_format(req.format) as i32,
                path_filters: req.paths,
                actor: Some(self.context().actor()),
                idempotency_key: String::new(),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn get_archive(&self, req: GetArchiveRequest) -> Result<ArchiveArtifact, BabyError> {
        let mut client = self.context().ks.archive();
        let response = client
            .get_archive_artifact(pb::GetArchiveArtifactRequest {
                repository: self.repository_ref_some(),
                revision: req.commit,
                format: archive_format(req.format) as i32,
                path_filters: req.exclude,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let artifact = response
            .artifact
            .ok_or_else(|| BabyError::Custom("archive artifact missing".into()))?;
        Ok(ArchiveArtifact {
            format: artifact.format,
            size: artifact.size_bytes,
            storage_key: artifact.storage_key,
            download_url: artifact.download_url,
        })
    }

    pub async fn create_bundle(&self, _req: BundleRequest) -> Result<(), BabyError> {
        let mut client = self.context().ks.archive();
        client
            .start_archive_bundle(pb::StartArchiveBundleRequest {
                repository: self.repository_ref_some(),
                actor: Some(self.context().actor()),
                idempotency_key: String::new(),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn init_repository(
        &self,
        _path: &str,
        _bare: bool,
        _format: Option<ObjectFormat>,
    ) -> Result<(), BabyError> {
        let mut client = self.context().ks.command();
        client
            .create_repository(pb::CreateRepositoryRequest {
                repository: self.repository_ref_some(),
                // 默认分支由托管面决定；本地不再保存该字段。
                default_branch: String::new(),
                actor: Some(self.context().actor()),
                options: Some(self.context().write_options()),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    /// 仓库概览：默认分支、主语言、对象格式、体积与引用计数。
    ///
    /// 这些字段的真值都在 KenShell，本地库不再保存副本。
    pub async fn repository_overview(&self) -> Result<RepositoryOverviewInfo, BabyError> {
        let mut client = self.context().ks.repository();
        let response = client
            .get_repository(pb::GetRepositoryRequest {
                repository: self.repository_ref_some(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        let overview = response
            .repository
            .ok_or_else(|| BabyError::RefNotFound("repository".to_string()))?;
        let summary = overview.repository.unwrap_or_default();
        let branch = summary
            .default_branch
            .strip_prefix("refs/heads/")
            .unwrap_or(&summary.default_branch)
            .to_string();
        Ok(RepositoryOverviewInfo {
            default_branch: branch,
            primary_language: Some(summary.primary_language).filter(|v| !v.is_empty()),
            object_format: if overview.object_format.is_empty() {
                "sha1".to_string()
            } else {
                overview.object_format
            },
            size_bytes: overview.size_bytes as i64,
            branch_count: overview.branch_count as i32,
            tag_count: overview.tag_count as i32,
        })
    }

    /// 保护规则列表；`kind` 为 `branch` 或 `tag`。
    pub async fn list_ref_protections(
        &self,
        kind: &str,
    ) -> Result<Vec<pb::RefProtectionView>, BabyError> {
        let mut client = self.refs_client();
        let response = client
            .list_ref_protections(pb::ListRefProtectionsRequest {
                repository: self.repository_ref_some(),
                kind: if kind == "tag" {
                    pb::RefProtectionKind::Tag as i32
                } else {
                    pb::RefProtectionKind::Branch as i32
                },
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.protections)
    }

    pub async fn create_ref_protection(
        &self,
        kind: &str,
        pattern: &str,
        rules: pb::RefProtectionRules,
        whitelists: Vec<pb::RefProtectionWhitelist>,
    ) -> Result<pb::RefProtectionView, BabyError> {
        let mut client = self.refs_client();
        let response = client
            .create_ref_protection(pb::CreateRefProtectionRequest {
                repository: self.repository_ref_some(),
                kind: if kind == "tag" {
                    pb::RefProtectionKind::Tag as i32
                } else {
                    pb::RefProtectionKind::Branch as i32
                },
                pattern: pattern.to_string(),
                rules: Some(rules),
                whitelists,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        response
            .protection
            .ok_or_else(|| BabyError::RefNotFound(pattern.to_string()))
    }

    pub async fn update_ref_protection(
        &self,
        id: &str,
        pattern: &str,
        rules: pb::RefProtectionRules,
        whitelists: Vec<pb::RefProtectionWhitelist>,
    ) -> Result<pb::RefProtectionView, BabyError> {
        let mut client = self.refs_client();
        let response = client
            .update_ref_protection(pb::UpdateRefProtectionRequest {
                repository: self.repository_ref_some(),
                id: id.to_string(),
                pattern: pattern.to_string(),
                rules: Some(rules),
                whitelists,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        response
            .protection
            .ok_or_else(|| BabyError::RefNotFound(id.to_string()))
    }

    pub async fn delete_ref_protection(&self, id: &str) -> Result<(), BabyError> {
        let mut client = self.refs_client();
        client
            .delete_ref_protection(pb::DeleteRefProtectionRequest {
                repository: self.repository_ref_some(),
                id: id.to_string(),
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn list_code_comments(
        &self,
        commit_sha: &str,
        path: &str,
        resolved: Option<bool>,
    ) -> Result<Vec<pb::CodeCommentView>, BabyError> {
        let mut client = self.context().ks.comment();
        let response = client
            .list_code_comments(pb::ListCodeCommentsRequest {
                repository: self.repository_ref_some(),
                commit_sha: commit_sha.to_string(),
                path: path.to_string(),
                path_bytes: Vec::new(),
                line_number: None,
                resolved,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.comments)
    }

    pub async fn create_code_comment(
        &self,
        revision: &str,
        path: &str,
        line_number: u32,
        body: &str,
        user_id: i64,
        parent_id: &str,
    ) -> Result<pb::CodeCommentView, BabyError> {
        let mut client = self.context().ks.comment();
        let response = client
            .create_code_comment(pb::CreateCodeCommentRequest {
                repository: self.repository_ref_some(),
                revision: revision.to_string(),
                path: path.to_string(),
                line_number,
                body: body.to_string(),
                user_id,
                path_bytes: Vec::new(),
                parent_id: parent_id.to_string(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        response
            .comment
            .ok_or_else(|| BabyError::RefNotFound("code comment".to_string()))
    }

    pub async fn update_code_comment(
        &self,
        id: &str,
        user_id: i64,
        body: &str,
        resolved: Option<bool>,
    ) -> Result<pb::CodeCommentView, BabyError> {
        let mut client = self.context().ks.comment();
        let response = client
            .update_code_comment(pb::UpdateCodeCommentRequest {
                repository: self.repository_ref_some(),
                id: id.to_string(),
                user_id,
                body: body.to_string(),
                resolved,
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        response
            .comment
            .ok_or_else(|| BabyError::RefNotFound("code comment".to_string()))
    }

    pub async fn delete_code_comment(&self, id: &str, user_id: i64) -> Result<(), BabyError> {
        let mut client = self.context().ks.comment();
        client
            .delete_code_comment(pb::DeleteCodeCommentRequest {
                repository: self.repository_ref_some(),
                id: id.to_string(),
                user_id,
            })
            .await
            .map_err(BabyError::from)?;
        Ok(())
    }

    pub async fn repo_size(&self) -> Result<u64, BabyError> {
        let mut client = self.context().ks.repository();
        let response = client
            .get_repository_size(pb::GetRepositorySizeRequest {
                repository: self.repository_ref_some(),
            })
            .await
            .map_err(BabyError::from)?
            .into_inner();
        Ok(response.size_bytes)
    }

    pub async fn merge_base(&self, _one: &str, _two: &str) -> Result<ObjectId, BabyError> {
        Err(unsupported("merge base"))
    }

    pub async fn merge_tree(
        &self,
        _ours: &str,
        _theirs: &str,
        _base: Option<&str>,
        _force: bool,
    ) -> Result<crate::rpcgit::conflict::types::MergeTreeResult, BabyError> {
        Err(unsupported("merge tree"))
    }

    pub async fn verify_tag_signature(&self, _name: &str) -> Result<TagVerifyResult, BabyError> {
        Err(unsupported("tag signature verification"))
    }

    pub async fn list_submodules(
        &self,
        _commit: &str,
    ) -> Result<Vec<crate::rpcgit::submodule::types::SubModule>, BabyError> {
        Err(unsupported("submodules"))
    }

    pub async fn prune(&self) -> Result<(), BabyError> {
        Err(unsupported("prune"))
    }
}

#[derive(Debug, Clone)]
pub struct ArchiveArtifact {
    pub format: i32,
    pub size: u64,
    pub storage_key: String,
    pub download_url: String,
}

fn tag_from_view(tag: pb::TagView) -> TagInfo {
    let target = oid(&tag.target_sha)
        .unwrap_or_else(|_| oid_opt("0000000000000000000000000000000000000000").expect("zero"));
    TagInfo {
        name: tag.name,
        sha: target.clone(),
        target_sha: target,
        tag_type: if tag.annotated {
            TagType::Annotated
        } else {
            TagType::Lightweight
        },
        tagger: if tag.tagger_name.is_empty() && tag.tagger_email.is_empty() {
            None
        } else {
            Some(Signature {
                name: tag.tagger_name,
                email: tag.tagger_email,
                time: tag
                    .created_at
                    .and_then(|at| time::OffsetDateTime::from_unix_timestamp(at.seconds).ok())
                    .unwrap_or(time::OffsetDateTime::UNIX_EPOCH),
            })
        },
        message: if tag.message.is_empty() {
            None
        } else {
            Some(tag.message)
        },
        created_at: at(tag.created_at),
    }
}

fn changed_path_diff(file: pb::DiffFileView) -> ChangedPathDiff {
    let mut patch = String::new();
    for hunk in &file.hunks {
        patch.push_str(&hunk.header);
        patch.push('\n');
        for line in &hunk.lines {
            let prefix =
                match pb::DiffLineKind::try_from(line.kind).unwrap_or(pb::DiffLineKind::Context) {
                    pb::DiffLineKind::Addition => "+",
                    pb::DiffLineKind::Deletion => "-",
                    pb::DiffLineKind::NoNewline => "\\",
                    _ => " ",
                };
            patch.push_str(prefix);
            patch.push_str(&line.content);
            patch.push('\n');
        }
    }
    let status =
        match pb::DiffFileStatus::try_from(file.status).unwrap_or(pb::DiffFileStatus::Modified) {
            pb::DiffFileStatus::Added => DiffStatus::Added,
            pb::DiffFileStatus::Deleted => DiffStatus::Deleted,
            pb::DiffFileStatus::Renamed => DiffStatus::Renamed,
            pb::DiffFileStatus::Copied => DiffStatus::Copied,
            pb::DiffFileStatus::TypeChanged => DiffStatus::TypeChanged,
            _ => DiffStatus::Modified,
        };
    let old_path = if file.old_path.is_empty() {
        None
    } else {
        Some(PathBuf::from(file.old_path))
    };
    let new_path = if file.new_path.is_empty() {
        old_path.clone().unwrap_or_default()
    } else {
        PathBuf::from(file.new_path)
    };
    ChangedPathDiff {
        path: ChangedPath {
            old_path,
            new_path,
            old_mode: 0,
            new_mode: 0,
            old_oid: oid_opt(&file.old_oid),
            new_oid: oid_opt(&file.new_oid),
            status,
        },
        lines_added: file.additions as u64,
        lines_removed: file.deletions as u64,
        binary: file.binary,
        patch: if patch.is_empty() || file.binary {
            None
        } else {
            Some(patch.into_bytes())
        },
    }
}

fn archive_format(format: ArchiveFormat) -> pb::ArchiveFormat {
    match format {
        ArchiveFormat::Tar => pb::ArchiveFormat::Tar,
        ArchiveFormat::TarGz => pb::ArchiveFormat::TarGz,
        ArchiveFormat::TarBz2 => pb::ArchiveFormat::TarBz2,
        ArchiveFormat::Zip => pb::ArchiveFormat::Zip,
    }
}

impl From<tonic::Status> for BabyError {
    fn from(status: tonic::Status) -> Self {
        match status.code() {
            tonic::Code::NotFound => BabyError::RevisionNotFound(status.message().to_string()),
            tonic::Code::AlreadyExists => BabyError::Custom(status.message().to_string()),
            tonic::Code::Aborted | tonic::Code::FailedPrecondition => {
                BabyError::RefUpdateRejected(status.message().to_string())
            }
            tonic::Code::InvalidArgument => {
                BabyError::RevisionInvalid(status.message().to_string())
            }
            tonic::Code::Unauthenticated => BabyError::Custom("unauthenticated".to_string()),
            tonic::Code::PermissionDenied => BabyError::Custom("permission denied".to_string()),
            tonic::Code::Unimplemented => BabyError::Custom(status.message().to_string()),
            _ => BabyError::Custom(format!("{}: {}", status.code(), status.message())),
        }
    }
}