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_license(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<crate::pb::repo::FindLicenseResponse, 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)?.repository;
        let resp = svc
            .find_license(tonic::Request::new(crate::pb::repo::FindLicenseRequest {
                repository: Some(header),
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_search_content(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        query: &str,
        revision: Option<&str>,
        max_results: u32,
        case_sensitive: bool,
    ) -> Result<crate::pb::repo::SearchFilesByContentResponse, 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)?.repository;
        let resp = svc
            .search_files_by_content(tonic::Request::new(
                crate::pb::repo::SearchFilesByContentRequest {
                    repository: Some(header),
                    query: query.to_string(),
                    revision: revision.unwrap_or(DEFAULT_REVISION).to_string(),
                    max_results,
                    case_sensitive,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_search_files(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        query: &str,
        revision: Option<&str>,
        max_results: u32,
        recursive: bool,
    ) -> Result<crate::pb::repo::SearchFilesByNameResponse, 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)?.repository;
        let resp = svc
            .search_files_by_name(tonic::Request::new(
                crate::pb::repo::SearchFilesByNameRequest {
                    repository: Some(header),
                    query: query.to_string(),
                    revision: revision.unwrap_or(DEFAULT_REVISION).to_string(),
                    max_results,
                    recursive,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }
}