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

impl RepoService {
    pub async fn git_get_commit_diff(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        revision: &str,
    ) -> Result<crate::pb::repo::GetDiffResponse, 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)?.diff;
        let resp = svc
            .get_commit_diff(tonic::Request::new(crate::pb::repo::GetCommitDiffRequest {
                repository: Some(header),
                commit: Some(crate::pb::repo::ObjectSelector {
                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                        crate::pb::repo::ObjectName {
                            revision: revision.to_string(),
                        },
                    )),
                }),
                options: None,
                pagination: None,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_get_patch(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        old_revision: &str,
        new_revision: &str,
    ) -> Result<Vec<u8>, 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)?.diff;
        let mut stream = svc
            .get_patch(tonic::Request::new(crate::pb::repo::GetPatchRequest {
                repository: Some(header),
                base: Some(crate::pb::repo::ObjectSelector {
                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                        crate::pb::repo::ObjectName {
                            revision: old_revision.to_string(),
                        },
                    )),
                }),
                head: Some(crate::pb::repo::ObjectSelector {
                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                        crate::pb::repo::ObjectName {
                            revision: new_revision.to_string(),
                        },
                    )),
                }),
                options: None,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?
            .into_inner();

        let mut data = Vec::new();
        while let Some(Ok(chunk)) = stream.next().await {
            data.extend_from_slice(&chunk.data);
        }
        Ok(data)
    }

    pub async fn git_raw_diff(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        old_revision: &str,
        new_revision: &str,
    ) -> Result<Vec<u8>, 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)?.diff;
        let mut stream = svc
            .raw_diff(tonic::Request::new(crate::pb::repo::RawDiffRequest {
                repository: Some(header),
                base: old_revision.to_string(),
                head: new_revision.to_string(),
                options: None,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?
            .into_inner();

        let mut data = Vec::new();
        while let Some(Ok(chunk)) = stream.next().await {
            data.extend_from_slice(&chunk.data);
        }
        Ok(data)
    }

    pub async fn git_find_changed_paths(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        old_revision: &str,
        new_revision: &str,
    ) -> Result<crate::pb::repo::FindChangedPathsResponse, 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)?.diff;
        let resp = svc
            .find_changed_paths(tonic::Request::new(
                crate::pb::repo::FindChangedPathsRequest {
                    repository: Some(header),
                    base: old_revision.to_string(),
                    head: new_revision.to_string(),
                    paths: vec![],
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_stream_blame(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        path: &str,
        revision: &str,
    ) -> Result<tonic::Streaming<crate::pb::repo::BlameHunk>, 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)?.blame;
        let resp = svc
            .stream_blame(tonic::Request::new(crate::pb::repo::BlameRequest {
                repository: Some(header),
                path: path.to_string(),
                revision: Some(crate::pb::repo::ObjectSelector {
                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                        crate::pb::repo::ObjectName {
                            revision: revision.to_string(),
                        },
                    )),
                }),
                range: None,
                options: None,
                pagination: None,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_resolve_merge_conflicts(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        target_branch: &str,
        source_revision: &str,
        message: &str,
    ) -> Result<crate::pb::repo::MergeResult, 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)?.merge;
        let resp = svc
            .resolve_merge_conflicts(tonic::Request::new(
                crate::pb::repo::ResolveMergeConflictsRequest {
                    repository: Some(header),
                    target_branch: target_branch.to_string(),
                    source: Some(crate::pb::repo::ObjectSelector {
                        selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                            crate::pb::repo::ObjectName {
                                revision: source_revision.to_string(),
                            },
                        )),
                    }),
                    resolutions: vec![],
                    committer: None,
                    message: message.to_string(),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }
}