use crate::models::common::DEFAULT_REVISION;
use crate::error::AppError;
use crate::service::RepoService;
use crate::session::Session;

impl RepoService {
    pub async fn git_find_commit(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        revision: &str,
    ) -> Result<crate::pb::repo::Commit, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .find_commit(tonic::Request::new(crate::pb::repo::FindCommitRequest {
                repository: Some(header),
                revision: Some(crate::pb::repo::ObjectSelector {
                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                        crate::pb::repo::ObjectName {
                            revision: revision.to_string(),
                        },
                    )),
                }),
                include_stats: false,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_list_commits_by_oid(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        oids: Vec<Vec<u8>>,
    ) -> Result<crate::pb::repo::ListCommitsByOidResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .list_commits_by_oid(tonic::Request::new(
                crate::pb::repo::ListCommitsByOidRequest {
                    repository: Some(header),
                    oids,
                    include_stats: false,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_commit_is_ancestor(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        ancestor: &str,
        descendant: &str,
    ) -> Result<bool, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .commit_is_ancestor(tonic::Request::new(
                crate::pb::repo::CommitIsAncestorRequest {
                    repository: Some(header),
                    ancestor_oid: ancestor.to_string(),
                    descendant_oid: descendant.to_string(),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner().is_ancestor)
    }

    pub async fn git_get_commit_ancestors(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        revision: &str,
        max_count: u32,
    ) -> Result<crate::pb::repo::GetCommitAncestorsResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .get_commit_ancestors(tonic::Request::new(
                crate::pb::repo::GetCommitAncestorsRequest {
                    repository: Some(header),
                    revision: Some(crate::pb::repo::ObjectSelector {
                        selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                            crate::pb::repo::ObjectName {
                                revision: revision.to_string(),
                            },
                        )),
                    }),
                    first_parent: false,
                    pagination: Some(crate::pb::repo::Pagination {
                        page_size: max_count,
                        page_token: String::new(),
                    }),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_last_commit_for_path(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        path: &str,
        revision: Option<&str>,
    ) -> Result<crate::pb::repo::LastCommitForPathResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .last_commit_for_path(tonic::Request::new(
                crate::pb::repo::LastCommitForPathRequest {
                    repository: Some(header),
                    path: path.to_string(),
                    revision: revision.unwrap_or(DEFAULT_REVISION).to_string(),
                    literal_pathspec: true,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_commits_by_message(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        query: &str,
        revision: Option<&str>,
        limit: u32,
    ) -> Result<crate::pb::repo::CommitsByMessageResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .commits_by_message(tonic::Request::new(
                crate::pb::repo::CommitsByMessageRequest {
                    repository: Some(header),
                    query: query.to_string(),
                    revision: revision.unwrap_or(DEFAULT_REVISION).to_string(),
                    limit,
                    offset: 0,
                    case_insensitive: true,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }
}