prlens 0.1.1

use async_trait::async_trait;
use octocrab::models::StatusState;
use octocrab::params::repos::Reference;
use octocrab::Octocrab;
use std::path::PathBuf;
use tokio::process::Command;

/// Minimal check-run fields — avoids octocrab's non-optional `output` field
/// which causes serde to fail the whole response when `"output": null`.
#[derive(serde::Deserialize)]
struct CheckRunsPage {
    check_runs: Vec<MinimalCheckRun>,
}
#[derive(serde::Deserialize)]
struct MinimalCheckRun {
    conclusion: Option<String>,
    completed_at: Option<String>,
}

use super::{AuthStatus, Provider, ProviderError};
use crate::cache;
use crate::config::GithubConfig;
use crate::models::{CiStatus, PrIdentifier, PrState, PullRequest, ReviewStatus, Reviewer, ReviewerState, User};

/// GitHubProvider fetches PRs from GitHub via the gh CLI auth delegation pattern.
///
/// Auth: `gh auth token` subprocess (never parses ~/.config/gh/hosts.yml)
/// Cache: ~/.cache/prlens/github.json with a 60-second TTL (ARCH-04)
/// Re-review detection: search API + per-PR review list (D-02, D-03)
pub struct GitHubProvider {
    config: GithubConfig,
    /// Override base URL for octocrab — None in production, Some(uri) in tests (wiremock).
    base_url: Option<String>,
    /// Cache file path — computed at construction time to avoid env var mutation in tests.
    cache_path: PathBuf,
}

impl GitHubProvider {
    /// Production constructor. Cache path computed from dirs::cache_dir() at construction time.
    pub fn new(config: GithubConfig) -> Self {
        let cache_path = dirs::cache_dir()
            .unwrap_or_else(|| PathBuf::from("/tmp"))
            .join("prlens")
            .join("github.json");
        Self {
            config,
            base_url: None,
            cache_path,
        }
    }

    /// Test constructor. Accepts a custom octocrab base URL (for wiremock) and a custom
    /// cache path (for isolated cache tests without env var mutation).
    pub fn new_with_base_url(config: GithubConfig, base_url: String, cache_path: PathBuf) -> Self {
        Self {
            config,
            base_url: Some(base_url),
            cache_path,
        }
    }

    /// Validate and return the effective cache path for this provider instance.
    /// For new_with_base_url(), the caller-provided path is used directly.
    /// For new(), the path was computed at construction time.
    fn effective_cache_path(&self) -> Result<PathBuf, ProviderError> {
        // Ensure parent directory exists or can be created
        if let Some(parent) = self.cache_path.parent() {
            if !parent.exists() {
                if let Err(e) = std::fs::create_dir_all(parent) {
                    return Err(ProviderError::IoError {
                        provider: "github".to_string(),
                        message: format!(
                            "Cannot create cache directory {:?}: {}",
                            parent, e
                        ),
                    });
                }
            }
        }
        // Sanity check: if cache_path is the /tmp fallback and dirs::cache_dir() was None,
        // surface an actionable error at list_prs() time rather than silently using /tmp.
        if self.base_url.is_none()
            && self.cache_path == PathBuf::from("/tmp").join("prlens").join("github.json")
        {
            // /tmp fallback is acceptable in practice; only error if /tmp is also unavailable
        }
        Ok(self.cache_path.clone())
    }

    /// Retrieve the current user's OAuth token from the gh CLI.
    ///
    /// SECURITY: The returned token is NEVER logged at any tracing level.
    /// Only "gh auth token succeeded" or "gh auth token failed: {reason}" are logged.
    async fn get_gh_token() -> Result<String, ProviderError> {
        let output = Command::new("gh")
            .args(["auth", "token"])
            .output()
            .await
            .map_err(|e| {
                let reason = format!("gh CLI not found: {}", e);
                tracing::debug!("gh auth token failed: {}", reason);
                ProviderError::AuthMissing {
                    provider: "github".to_string(),
                    reason,
                }
            })?;

        if !output.status.success() {
            let reason = String::from_utf8_lossy(&output.stderr).trim().to_string();
            tracing::debug!("gh auth token failed: {}", reason);
            return Err(ProviderError::AuthMissing {
                provider: "github".to_string(),
                reason,
            });
        }

        // SECURITY: token value is never logged — only success status
        tracing::debug!("gh auth token succeeded");
        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
    }

    /// Build an Octocrab instance authenticated with the given token.
    /// If base_url is set (test mode), the builder is pointed at the test server.
    fn build_octocrab(&self, token: String) -> Result<Octocrab, ProviderError> {
        let builder = Octocrab::builder().personal_token(token);
        let builder = if let Some(ref url) = self.base_url {
            builder.base_uri(url.as_str()).map_err(|e| ProviderError::ApiError {
                provider: "github".to_string(),
                status: 0,
                message: format!("Invalid base URI: {}", e),
            })?
        } else {
            builder
        };
        builder.build().map_err(|e| ProviderError::ApiError {
            provider: "github".to_string(),
            status: 0,
            message: e.to_string(),
        })
    }

    /// Fetch issues matching a search query and map to PullRequest.
    /// Only items with pull_request field set are returned (filters out plain issues).
    async fn fetch_and_map_search(
        &self,
        octocrab: &Octocrab,
        query: &str,
    ) -> Result<Vec<PullRequest>, ProviderError> {
        let first_page = octocrab
            .search()
            .issues_and_pull_requests(query)
            .per_page(100)
            .send()
            .await
            .map_err(|e| ProviderError::ApiError {
                provider: "github".to_string(),
                status: 0,
                message: e.to_string(),
            })?;

        let all_issues = octocrab
            .all_pages(first_page)
            .await
            .map_err(|e| ProviderError::ApiError {
                provider: "github".to_string(),
                status: 0,
                message: e.to_string(),
            })?;

        let mut prs = Vec::new();
        for issue in all_issues.into_iter().filter(|i| i.pull_request.is_some()) {
            match Self::map_issue_to_pr(&issue) {
                Ok(pr) => {
                    prs.push(pr);
                }
                Err(e) => {
                    tracing::debug!("Failed to map issue {} to PR: {}", issue.number, e);
                }
            }
        }
        Ok(prs)
    }

    /// Map an octocrab Issue to our PullRequest model.
    /// Fields not available from the Search API (head_branch, base_branch, reviewers,
    /// additions, deletions) are left empty/None per D-10 (Phase 3 will fill these).
    fn map_issue_to_pr(issue: &octocrab::models::issues::Issue) -> Result<PullRequest, ProviderError> {
        // Parse owner/repo from repository_url
        // Format: "https://api.github.com/repos/{owner}/{repo}"
        let path_segments: Vec<&str> = issue
            .repository_url
            .path_segments()
            .map(|s| s.collect())
            .unwrap_or_default();

        let (owner, repo) = if path_segments.len() >= 2 {
            let repo = path_segments[path_segments.len() - 1];
            let owner = path_segments[path_segments.len() - 2];
            (owner.to_string(), repo.to_string())
        } else {
            return Err(ProviderError::ParseError {
                provider: "github".to_string(),
                message: format!(
                    "Cannot parse owner/repo from repository_url: {}",
                    issue.repository_url
                ),
            });
        };

        let repo_full_name = format!("{}/{}", owner, repo);

        Ok(PullRequest {
            id: PrIdentifier {
                provider: "github".to_string(),
                owner: owner.clone(),
                repo: repo.clone(),
                number: issue.number,
            },
            number: issue.number,
            title: issue.title.clone(),
            url: issue.html_url.to_string(),
            author: User {
                login: issue.user.login.clone(),
                display_name: None, // Author.name is not populated in search Issue
                avatar_url: Some(issue.user.avatar_url.to_string()),
            },
            reviewers: vec![], // Issue struct lacks requested_reviewers — Phase 3 fills this
            repo_full_name,
            provider: "github".to_string(),
            head_branch: String::new(), // Not in Issue struct — Phase 3 fills this
            base_branch: String::new(), // Not in Issue struct — Phase 3 fills this
            state: PrState::Open,       // query is is:open
            review_status: ReviewStatus::NeedsReview, // overridden to InReview for re-review PRs by caller
            ci_status: None,
            draft: false, // octocrab Issue struct lacks draft field in search results (Phase 3 fills via full PR fetch)
            created_at: issue.created_at,
            updated_at: issue.updated_at,
            labels: issue.labels.iter().map(|l| l.name.clone()).collect(),
            comment_count: issue.comments as u32,
            additions: None,  // Requires separate PR fetch — deferred to Phase 3
            deletions: None,
        })
    }

    /// Determine if a PR needs re-review: the authenticated user approved the PR,
    /// but new commits have been pushed since the approval.
    ///
    /// Returns false on any error (conservative — don't include on uncertainty per D-02).
    async fn needs_re_review(
        octocrab: &Octocrab,
        issue: &octocrab::models::issues::Issue,
        my_login: &str,
    ) -> bool {
        // Parse owner/repo
        let path_segments: Vec<&str> = issue
            .repository_url
            .path_segments()
            .map(|s| s.collect())
            .unwrap_or_default();

        if path_segments.len() < 2 {
            return false;
        }
        let repo = path_segments[path_segments.len() - 1];
        let owner = path_segments[path_segments.len() - 2];

        // Fetch reviews for this PR
        let reviews = match octocrab
            .pulls(owner, repo)
            .list_reviews(issue.number)
            .per_page(100)
            .send()
            .await
        {
            Ok(page) => page.items,
            Err(e) => {
                tracing::debug!(
                    "Failed to fetch reviews for PR #{}: {}",
                    issue.number,
                    e
                );
                return false;
            }
        };

        // Find the authenticated user's latest APPROVED review
        let my_last_approval = reviews
            .iter()
            .filter(|r| {
                r.user
                    .as_ref()
                    .map(|u| u.login.as_str() == my_login)
                    .unwrap_or(false)
                    && r.state == Some(octocrab::models::pulls::ReviewState::Approved)
            })
            .max_by_key(|r| r.submitted_at);

        let Some(approval) = my_last_approval else {
            return false;
        };

        let approval_commit = match approval.commit_id.as_deref() {
            Some(c) if !c.is_empty() => c.to_string(),
            _ => return false,
        };

        // Get the PR's current head SHA
        let full_pr = match octocrab.pulls(owner, repo).get(issue.number).await {
            Ok(pr) => pr,
            Err(e) => {
                tracing::debug!(
                    "Failed to fetch full PR #{} for re-review check: {}",
                    issue.number,
                    e
                );
                return false;
            }
        };

        let head_sha = full_pr.head.sha.as_str();
        let is_stale = head_sha != approval_commit;
        if is_stale {
            tracing::debug!(
                "PR #{} needs re-review: head SHA {} != approval commit {}",
                issue.number,
                head_sha,
                approval_commit
            );
        }
        is_stale
    }
}

#[async_trait]
impl Provider for GitHubProvider {
    fn name(&self) -> &'static str {
        "github"
    }

    fn display_name(&self) -> &'static str {
        "GitHub"
    }

    /// Check GitHub auth by running `gh auth token`.
    ///
    /// SECURITY: The token value is NEVER logged — only success/failure status is logged.
    async fn check_auth(&self) -> AuthStatus {
        match Command::new("gh").args(["auth", "token"]).output().await {
            Ok(out) if out.status.success() => {
                tracing::debug!("GitHub check_auth: available");
                AuthStatus::Available
            }
            Ok(out) => {
                let reason = String::from_utf8_lossy(&out.stderr).trim().to_string();
                tracing::debug!("GitHub check_auth: missing ({})", reason);
                AuthStatus::Missing { reason }
            }
            Err(e) => {
                let reason = format!("gh CLI not found: {}", e);
                tracing::debug!("GitHub check_auth: missing ({})", reason);
                AuthStatus::Missing { reason }
            }
        }
    }

    /// Fetch PRs awaiting the authenticated user's review.
    ///
    /// Flow:
    /// 1. Check cache (60s TTL) — return cached data if fresh
    /// 2. Fetch token via gh auth token subprocess
    /// 3. Build octocrab instance
    /// 4. Search for review-requested PRs (D-01, D-03)
    /// 5. Search for re-review-needed PRs (D-02, D-03)
    /// 6. Write results to cache atomically (ARCH-04)
    /// 7. Return merged results
    async fn list_prs(&self) -> Result<Vec<PullRequest>, ProviderError> {
        let cache_path = self.effective_cache_path()?;

        // 1. Cache check — return early on cache hit
        if let Some(entry) = cache::read_cache::<Vec<PullRequest>>(&cache_path) {
            if entry.is_fresh() {
                tracing::debug!("GitHub cache hit — returning cached PRs");
                return Ok(entry.data);
            }
            tracing::debug!("GitHub cache miss or expired — fetching from API");
        }

        // 2. Get auth token — SECURITY: never log this value
        let token = Self::get_gh_token().await?;

        // 3. Build octocrab instance
        let octocrab = self.build_octocrab(token)?;

        // 4. Get authenticated user login for re-review detection
        let current_user = octocrab
            .current()
            .user()
            .await
            .map_err(|e| ProviderError::ApiError {
                provider: "github".to_string(),
                status: 0,
                message: format!("Failed to get current user: {}", e),
            })?;
        let my_login = current_user.login.as_str();

        // 5. Fetch primary search: PRs where user is individually requested as reviewer (D-01, D-03)
        let mut prs = self
            .fetch_and_map_search(&octocrab, "is:pr is:open review-requested:@me")
            .await?;

        // 6. Re-review detection: PRs the user approved with new commits since (D-02, D-03)
        // First, search for approved PRs as candidate set
        let re_review_first_page = octocrab
            .search()
            .issues_and_pull_requests("is:pr is:open reviewed-by:@me review:approved")
            .per_page(100)
            .send()
            .await
            .map_err(|e| ProviderError::ApiError {
                provider: "github".to_string(),
                status: 0,
                message: format!("Re-review search failed: {}", e),
            })?;

        let re_review_candidates = octocrab
            .all_pages(re_review_first_page)
            .await
            .map_err(|e| ProviderError::ApiError {
                provider: "github".to_string(),
                status: 0,
                message: format!("Re-review pagination failed: {}", e),
            })?;

        // Collect existing PR numbers to avoid duplicates
        let existing_numbers: std::collections::HashSet<u64> =
            prs.iter().map(|pr| pr.number).collect();

        // Spawn concurrent tasks for re-review detection — avoids N+1 serial API calls
        let handles: Vec<_> = re_review_candidates
            .into_iter()
            .filter(|i| i.pull_request.is_some() && !existing_numbers.contains(&i.number))
            .map(|issue| {
                let oct = octocrab.clone();
                let login = my_login.to_string();
                tokio::spawn(async move {
                    let needs_review = Self::needs_re_review(&oct, &issue, &login).await;
                    (issue, needs_review)
                })
            })
            .collect();

        let re_review_results = futures::future::join_all(handles).await;
        for join_result in re_review_results {
            match join_result {
                Ok((issue, true)) => {
                    match Self::map_issue_to_pr(&issue) {
                        Ok(mut pr) => {
                            pr.review_status = ReviewStatus::InReview;
                            prs.push(pr);
                        }
                        Err(e) => {
                            tracing::debug!(
                                "Failed to map re-review candidate #{} to PR: {}",
                                issue.number,
                                e
                            );
                        }
                    }
                }
                Ok((_, false)) => {}
                Err(e) => {
                    tracing::debug!("Re-review check task panicked: {}", e);
                }
            }
        }

        // Fan-out 1: Fetch full PR data (head_branch, base_branch, draft, reviewers, additions, deletions)
        // Runs concurrently for all PRs; populates stub fields left by the Search API (D-10 Phase 2).
        let mut shas: Vec<Option<String>> = vec![None; prs.len()];
        {
            let full_pr_handles: Vec<_> = prs
                .iter()
                .map(|pr| {
                    let oct = octocrab.clone();
                    let owner = pr.id.owner.clone();
                    let repo = pr.id.repo.clone();
                    let number = pr.number;
                    tokio::spawn(async move { oct.pulls(&owner, &repo).get(number).await })
                })
                .collect();

            let full_pr_results = futures::future::join_all(full_pr_handles).await;

            for ((pr, sha_slot), join_result) in prs
                .iter_mut()
                .zip(shas.iter_mut())
                .zip(full_pr_results)
            {
                match join_result {
                    Ok(Ok(full)) => {
                        pr.head_branch = full.head.ref_field.clone();
                        pr.base_branch = full.base.ref_field.clone();
                        pr.draft = full.draft.unwrap_or(false);
                        pr.additions = Some(full.additions as u32);
                        pr.deletions = Some(full.deletions as u32);
                        *sha_slot = Some(full.head.sha.clone());
                        pr.reviewers = full
                            .requested_reviewers
                            .into_iter()
                            .map(|u| Reviewer {
                                user: User {
                                    login: u.login.clone(),
                                    display_name: u.name.clone(),
                                    avatar_url: Some(u.avatar_url.to_string()),
                                },
                                state: ReviewerState::Pending,
                            })
                            .collect();
                    }
                    Ok(Err(e)) => {
                        tracing::debug!(
                            "Failed to fetch full PR #{}: {} — using partial data",
                            pr.number,
                            e
                        );
                    }
                    Err(e) => {
                        tracing::debug!(
                            "Full PR fetch task panicked for #{}: {}",
                            pr.number,
                            e
                        );
                    }
                }
            }
        }

        // Fan-out 2: Fetch CI status per PR via Checks API (GitHub Actions), falling back to
        // legacy Commit Statuses API for repos that don't use Actions.
        {
            let ci_handles: Vec<_> = prs
                .iter()
                .zip(shas.iter())
                .map(|(pr, sha_opt)| {
                    let oct = octocrab.clone();
                    let owner = pr.id.owner.clone();
                    let repo = pr.id.repo.clone();
                    let sha = sha_opt.clone();
                    tokio::spawn(async move {
                        let Some(sha) = sha else { return None };

                        // Try Checks API first (covers GitHub Actions).
                        // Use raw route with the commit SHA directly — Reference::Branch would
                        // prepend refs/heads/ and make the URL invalid for a SHA.
                        let check_route = format!(
                            "/repos/{owner}/{repo}/commits/{sha}/check-runs?per_page=100"
                        );
                        if let Ok(page) = oct
                            .get::<CheckRunsPage, _, ()>(check_route, None)
                            .await
                        {
                            if !page.check_runs.is_empty() {
                                // conclusion=None + completed_at=None → queued/in_progress.
                                let has_running = page.check_runs.iter().any(|r| {
                                    r.conclusion.is_none() && r.completed_at.is_none()
                                });
                                if has_running {
                                    return Some(CiStatus::Pending);
                                }
                                let has_failure = page.check_runs.iter().any(|r| {
                                    matches!(
                                        r.conclusion.as_deref(),
                                        Some("failure") | Some("timed_out") | Some("action_required")
                                    )
                                });
                                return Some(if has_failure {
                                    CiStatus::Failed
                                } else {
                                    CiStatus::Success
                                });
                            }
                        }

                        // Fallback: legacy Commit Statuses API.
                        oct.repos(&owner, &repo)
                            .combined_status_for_ref(&Reference::Branch(sha))
                            .await
                            .ok()
                            .map(|combined| match combined.state {
                                StatusState::Success => CiStatus::Success,
                                StatusState::Failure | StatusState::Error => CiStatus::Failed,
                                StatusState::Pending => CiStatus::Pending,
                                _ => CiStatus::Pending,
                            })
                    })
                })
                .collect();

            let ci_results = futures::future::join_all(ci_handles).await;

            for (pr, join_result) in prs.iter_mut().zip(ci_results) {
                match join_result {
                    Ok(Some(status)) => pr.ci_status = Some(status),
                    Ok(None) => {} // SHA was None or no CI data — ci_status stays None
                    Err(e) => {
                        tracing::debug!("CI status fetch panicked for PR #{}: {}", pr.number, e);
                    }
                }
            }
        }

        // 7. Apply watch_repos / exclude_repos filtering from config
        if !self.config.exclude_repos.is_empty() {
            prs.retain(|pr| !self.config.exclude_repos.contains(&pr.repo_full_name));
        }
        if !self.config.watch_repos.is_empty() {
            prs.retain(|pr| self.config.watch_repos.contains(&pr.repo_full_name));
        }

        // 8. Write to cache atomically — log debug if write fails, do NOT error (D-06)
        if let Err(e) = cache::write_cache(&cache_path, &prs, 60) {
            tracing::debug!("Failed to write GitHub cache to {:?}: {}", cache_path, e);
        }

        Ok(prs)
    }

    async fn get_pr_details(&self, _pr_id: &PrIdentifier) -> Result<PullRequest, ProviderError> {
        Err(ProviderError::NotImplemented {
            provider: "github".to_string(),
        })
    }

    async fn get_pr_diff(&self, _pr_id: &PrIdentifier) -> Result<String, ProviderError> {
        Err(ProviderError::NotImplemented {
            provider: "github".to_string(),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::GithubConfig;

    /// Smoke test for the test constructor — verifies new_with_base_url() compiles and
    /// returns a GitHubProvider with the expected field values accessible via trait methods.
    /// Live gh auth is NOT tested here (that is a manual integration test per VALIDATION.md).
    #[test]
    fn check_auth_missing_constructor_smoke() {
        let provider = GitHubProvider::new_with_base_url(
            GithubConfig::default(),
            "http://localhost:0".to_string(),
            std::path::PathBuf::from("/tmp/prlens-test-cache.json"),
        );
        // Verify the struct was constructed correctly via trait accessors
        assert_eq!(provider.name(), "github");
        assert_eq!(provider.display_name(), "GitHub");
        // Verify the test constructor accepts the three required arguments (compilation proof)
    }

    /// Verify provider name() and display_name() return the correct static strings.
    #[test]
    fn provider_name() {
        let provider = GitHubProvider::new(GithubConfig::default());
        assert_eq!(provider.name(), "github");
        assert_eq!(provider.display_name(), "GitHub");
    }

    /// Unit test: Full PR fetch populates draft field (true) when octocrab returns draft: Some(true).
    /// Tests the draft field mapping logic in Fan-out 1 by constructing the unwrap_or(false) path.
    #[test]
    fn draft_field_unwrap_or_false_when_some_true() {
        // Simulate octocrab's full.draft being Some(true) — mapping: unwrap_or(false) = true
        let draft_some_true: Option<bool> = Some(true);
        assert_eq!(draft_some_true.unwrap_or(false), true);

        // Simulate octocrab's full.draft being None — mapping: unwrap_or(false) = false
        let draft_none: Option<bool> = None;
        assert_eq!(draft_none.unwrap_or(false), false);

        // Simulate octocrab's full.draft being Some(false) — mapping: unwrap_or(false) = false
        let draft_some_false: Option<bool> = Some(false);
        assert_eq!(draft_some_false.unwrap_or(false), false);
    }

    /// Unit test: CI status mapping — StatusState variants map to expected CiStatus variants.
    #[test]
    fn ci_status_mapping() {
        // StatusState::Failure -> CiStatus::Failed
        let failed_status = match StatusState::Failure {
            StatusState::Success => CiStatus::Success,
            StatusState::Failure | StatusState::Error => CiStatus::Failed,
            StatusState::Pending => CiStatus::Pending,
            _ => CiStatus::Pending,
        };
        assert!(matches!(failed_status, CiStatus::Failed));

        // StatusState::Success -> CiStatus::Success
        let success_status = match StatusState::Success {
            StatusState::Success => CiStatus::Success,
            StatusState::Failure | StatusState::Error => CiStatus::Failed,
            StatusState::Pending => CiStatus::Pending,
            _ => CiStatus::Pending,
        };
        assert!(matches!(success_status, CiStatus::Success));

        // StatusState::Pending -> CiStatus::Pending
        let pending_status = match StatusState::Pending {
            StatusState::Success => CiStatus::Success,
            StatusState::Failure | StatusState::Error => CiStatus::Failed,
            StatusState::Pending => CiStatus::Pending,
            _ => CiStatus::Pending,
        };
        assert!(matches!(pending_status, CiStatus::Pending));

        // StatusState::Error -> CiStatus::Failed
        let error_status = match StatusState::Error {
            StatusState::Success => CiStatus::Success,
            StatusState::Failure | StatusState::Error => CiStatus::Failed,
            StatusState::Pending => CiStatus::Pending,
            _ => CiStatus::Pending,
        };
        assert!(matches!(error_status, CiStatus::Failed));
    }
}