use crate::error::AppError;
use crate::service::RepoService;
use crate::session::Session;

impl RepoService {
    pub async fn git_list_branches(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        pattern: Option<String>,
        page_size: u32,
        page_token: Option<String>,
    ) -> Result<crate::pb::repo::ListBranchesResponse, 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)?.branch;
        let resp = svc
            .list_branches(tonic::Request::new(crate::pb::repo::ListBranchesRequest {
                repository: Some(header),
                pattern: pattern.unwrap_or_default(),
                merged_into_head: false,
                not_merged_into_head: false,
                pagination: Some(crate::pb::repo::Pagination {
                    page_size,
                    page_token: page_token.unwrap_or_default(),
                }),
                sort_direction: crate::pb::repo::SortDirection::Desc as i32,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_get_branch(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        branch_name: &str,
    ) -> Result<crate::pb::repo::Branch, 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)?.branch;
        let resp = svc
            .get_branch(tonic::Request::new(crate::pb::repo::GetBranchRequest {
                repository: Some(header),
                name: branch_name.to_string(),
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_create_branch(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        branch_name: &str,
        start_point: &str,
    ) -> Result<crate::pb::repo::Branch, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Member)
            .await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.branch;
        let resp = svc
            .create_branch(tonic::Request::new(crate::pb::repo::CreateBranchRequest {
                repository: Some(header),
                name: branch_name.to_string(),
                start_point: Some(crate::pb::repo::ObjectSelector {
                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                        crate::pb::repo::ObjectName {
                            revision: start_point.to_string(),
                        },
                    )),
                }),
                force: false,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_delete_branch(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        branch_name: &str,
    ) -> Result<(), AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Admin)
            .await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.branch;
        svc.delete_branch(tonic::Request::new(crate::pb::repo::DeleteBranchRequest {
            repository: Some(header),
            name: branch_name.to_string(),
            force: false,
        }))
        .await
        .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(())
    }

    pub async fn git_compare_branches(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        source_branch: &str,
        target_branch: &str,
    ) -> Result<crate::pb::repo::CompareBranchResponse, 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)?.branch;
        let resp = svc
            .compare_branch(tonic::Request::new(crate::pb::repo::CompareBranchRequest {
                repository: Some(header),
                source_branch: source_branch.to_string(),
                target_branch: target_branch.to_string(),
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }
}