appks/service/repo/stats.rs

use uuid::Uuid;

use crate::error::AppError;
use crate::models::common::Role;
use crate::models::repos::RepoStats;
use crate::service::RepoService;
use crate::session::Session;

impl RepoService {
    pub async fn repo_stats(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<RepoStats, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        let repo_id = repo.id;
        self.ensure_repo_readable(user_uid, &repo).await?;
        self.ensure_repo_stats(repo_id).await
    }

    pub async fn repo_refresh_stats(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<RepoStats, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        let repo_id = repo.id;
        self.ensure_repo_role_at_least(user_uid, &repo, Role::Admin)
            .await?;

        let branches_count =
            sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM repo_branch WHERE repo_id = $1")
                .bind(repo_id)
                .fetch_one(self.ctx.db.reader())
                .await
                .map_err(AppError::Database)?;

        let tags_count =
            sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM repo_tag WHERE repo_id = $1")
                .bind(repo_id)
                .fetch_one(self.ctx.db.reader())
                .await
                .map_err(AppError::Database)?;

        let releases_count = sqlx::query_scalar::<_, i64>(
            "SELECT COUNT(*) FROM repo_release WHERE repo_id = $1 AND deleted_at IS NULL",
        )
        .bind(repo_id)
        .fetch_one(self.ctx.db.reader())
        .await
        .map_err(AppError::Database)?;

        let stars_count =
            sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM repo_star WHERE repo_id = $1")
                .bind(repo_id)
                .fetch_one(self.ctx.db.reader())
                .await
                .map_err(AppError::Database)?;

        let watchers_count =
            sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM repo_watch WHERE repo_id = $1")
                .bind(repo_id)
                .fetch_one(self.ctx.db.reader())
                .await
                .map_err(AppError::Database)?;

        let forks_count = sqlx::query_scalar::<_, i64>(
            "SELECT COUNT(*) FROM repo WHERE forked_from_repo_id = $1 AND deleted_at IS NULL",
        )
        .bind(repo_id)
        .fetch_one(self.ctx.db.reader())
        .await
        .map_err(AppError::Database)?;

        let open_issues_count: i64 = sqlx::query_scalar(
            "SELECT COUNT(*) FROM issue i \
             JOIN issue_repo_relation irr ON irr.issue_id = i.id \
             WHERE irr.repo_id = $1 AND i.deleted_at IS NULL AND i.state = 'open'",
        )
        .bind(repo_id)
        .fetch_one(self.ctx.db.reader())
        .await
        .map_err(AppError::Database)?;

        let open_prs_count = sqlx::query_scalar::<_, i64>(
            "SELECT COUNT(*) FROM pull_request WHERE repo_id = $1 AND deleted_at IS NULL AND state = 'open'",
        )
        .bind(repo_id)
        .fetch_one(self.ctx.db.reader())
        .await
        .map_err(AppError::Database)?;

        let now = chrono::Utc::now();

        // Try fetching git-derived stats via gRPC (best-effort)
        let (commits_count, size_bytes, last_push_at) = self
            .try_fetch_git_stats(ctx, wk_name, repo_name)
            .await
            .unwrap_or((0, 0, None));

        let result = sqlx::query_as::<_, RepoStats>(
            "UPDATE repo_stats SET stars_count = $1, watchers_count = $2, forks_count = $3, \
             branches_count = $4, tags_count = $5, releases_count = $6, \
             open_issues_count = $7, open_pull_requests_count = $8, \
             commits_count = $9, size_bytes = $10, last_push_at = $11, updated_at = $12 \
             WHERE repo_id = $13 RETURNING repo_id, stars_count, watchers_count, forks_count, branches_count, tags_count, commits_count, releases_count, open_issues_count, open_pull_requests_count, size_bytes, last_push_at, updated_at",
        )
        .bind(stars_count)
        .bind(watchers_count)
        .bind(forks_count)
        .bind(branches_count)
        .bind(tags_count)
        .bind(releases_count)
        .bind(open_issues_count)
        .bind(open_prs_count)
        .bind(commits_count)
        .bind(size_bytes)
        .bind(last_push_at)
        .bind(now)
        .bind(repo_id)
        .fetch_one(self.ctx.db.writer())
        .await
        .map_err(AppError::Database)?;

        Ok(result)
    }

    async fn try_fetch_git_stats(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Option<(i64, i64, Option<chrono::DateTime<chrono::Utc>>)> {
        let commits = self
            .git_count_commits(ctx, wk_name, repo_name, None, None, None, None)
            .await
            .ok()
            .map(|r| r.count as i64)
            .unwrap_or(0);

        let size = self
            .git_repo_stats(ctx, wk_name, repo_name)
            .await
            .ok()
            .map(|r| r.size_bytes as i64)
            .unwrap_or(0);

        let last_push = None; // Not available from current gRPC

        Some((commits, size, last_push))
    }

    async fn ensure_repo_stats(&self, repo_id: Uuid) -> Result<RepoStats, AppError> {
        if let Some(stats) = sqlx::query_as::<_, RepoStats>(
            "SELECT repo_id, stars_count, watchers_count, forks_count, branches_count, tags_count, commits_count, releases_count, open_issues_count, open_pull_requests_count, size_bytes, last_push_at, updated_at FROM repo_stats WHERE repo_id = $1",
        )
        .bind(repo_id)
        .fetch_optional(self.ctx.db.reader())
        .await
        .map_err(AppError::Database)?
        {
            return Ok(stats);
        }

        sqlx::query(
            "INSERT INTO repo_stats (repo_id, stars_count, watchers_count, forks_count, branches_count, \
             tags_count, commits_count, releases_count, open_issues_count, open_pull_requests_count, \
             size_bytes, updated_at) \
             VALUES ($1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, $2) ON CONFLICT (repo_id) DO NOTHING",
        )
        .bind(repo_id)
        .bind(chrono::Utc::now())
        .execute(self.ctx.db.writer())
        .await
        .map_err(AppError::Database)?;
        // Read from writer to avoid replication lag
        sqlx::query_as::<_, RepoStats>(
            "SELECT repo_id, stars_count, watchers_count, forks_count, branches_count, tags_count, commits_count, releases_count, open_issues_count, open_pull_requests_count, size_bytes, last_push_at, updated_at FROM repo_stats WHERE repo_id = $1",
        )
        .bind(repo_id)
        .fetch_optional(self.ctx.db.writer())
        .await
        .map_err(AppError::Database)?
        .ok_or(AppError::NotFound("repo stats not found".into()))
    }
}