pub fn list_repos(owner: &str) -> Result<Vec<Repository>> {
    let output = Command::new("gh")
        .args(&[
            "repo", "list", owner,
            "--limit", "50",
            "--json", "name,owner,language,description,pushedAt,createdAt,updatedAt,isFork",
        ])
        .output()?;

    let gh_repos: Vec<GhRepo> = serde_json::from_slice(&output.stdout)?;

    // Transform to internal Repository model
    let repos = gh_repos.into_iter()
        .map(|gh_repo| Repository {
            id: format!("{}/{}", gh_repo.owner.login, gh_repo.name),
            owner: gh_repo.owner.login,
            name: gh_repo.name,
            // ... other fields
        })
        .collect();

    Ok(repos)
}

pub fn create_pull_request(request: &PrRequest) -> Result<PullRequest> {
    let body_file = tempfile::NamedTempFile::new()?;
    std::fs::write(&body_file, &request.body)?;

    let output = Command::new("gh")
        .args(&[
            "pr", "create",
            "--repo", &format!("{}/{}", request.owner, request.repo),
            "--head", &request.head,
            "--base", &request.base,
            "--title", &request.title,
            "--body-file", body_file.path().to_str().unwrap(),
        ])
        .output()?;

    // Parse URL from output
    let url = String::from_utf8(output.stdout)?.trim().to_string();

    // Extract PR number from URL
    let pr_number = extract_pr_number(&url)?;

    Ok(PullRequest {
        number: pr_number,
        state: "OPEN".to_string(),
        title: request.title.clone(),
        url,
        // ...
    })
}

pub enum BranchStatus {
    Unknown,       // No comparison data
    NeedsSync,     // Behind base branch
    ReadyForPR,    // Ahead, no PR
    PROpen,        // Has open PR
    Merged,        // Already merged
}

pub fn execute_gh_command(args: &[&str]) -> Result<String> {
    let output = Command::new("gh")
        .args(args)
        .output()
        .context("Failed to execute gh command")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);

        // Parse specific error types
        if stderr.contains("authentication") {
            return Err(anyhow!("GitHub authentication required. Run: gh auth login"));
        }

        if stderr.contains("rate limit") {
            // Extract retry-after if available
            return Err(anyhow!("GitHub API rate limit exceeded"));
        }

        if stderr.contains("404") || stderr.contains("Not Found") {
            return Err(anyhow!("Repository or resource not found"));
        }

        return Err(anyhow!("gh command failed: {}", stderr));
    }

    Ok(String::from_utf8(output.stdout)?)
}

pub fn fetch_with_retry<T, F>(operation: F, max_retries: u32) -> Result<T>
where
    F: Fn() -> Result<T>,
{
    let mut attempts = 0;
    let mut delay = Duration::from_secs(2);

    loop {
        match operation() {
            Ok(result) => return Ok(result),
            Err(e) if attempts < max_retries => {
                if e.to_string().contains("rate limit") {
                    tracing::warn!("Rate limited, waiting {:?} before retry", delay);
                    std::thread::sleep(delay);
                    delay *= 2; // Exponential backoff
                    attempts += 1;
                } else {
                    return Err(e); // Don't retry non-rate-limit errors
                }
            }
            Err(e) => return Err(e),
        }
    }
}

pub struct RateLimitInfo {
    pub limit: u32,
    pub remaining: u32,
    pub reset_at: DateTime<Utc>,
}

pub fn check_rate_limit() -> Result<RateLimitInfo> {
    let output = Command::new("gh")
        .args(&["api", "rate_limit"])
        .output()?;

    let data: serde_json::Value = serde_json::from_slice(&output.stdout)?;

    Ok(RateLimitInfo {
        limit: data["resources"]["core"]["limit"].as_u64().unwrap() as u32,
        remaining: data["resources"]["core"]["remaining"].as_u64().unwrap() as u32,
        reset_at: DateTime::from_timestamp(
            data["resources"]["core"]["reset"].as_i64().unwrap(),
            0,
        ).unwrap(),
    })
}

#[cfg(test)]
pub struct MockGitHubClient {
    pub repos: HashMap<String, Vec<Repository>>,
    pub branches: HashMap<String, Vec<Branch>>,
    pub prs: HashMap<String, Vec<PullRequest>>,
}

impl MockGitHubClient {
    pub fn new() -> Self {
        Self {
            repos: HashMap::new(),
            branches: HashMap::new(),
            prs: HashMap::new(),
        }
    }

    pub fn with_repo(mut self, owner: &str, repo: Repository) -> Self {
        self.repos
            .entry(owner.to_string())
            .or_insert_with(Vec::new)
            .push(repo);
        self
    }
}

#[test]
#[ignore] // Run with: cargo test -- --ignored
fn test_real_github_api() {
    let repos = list_repos("softwarewrighter").unwrap();
    assert!(!repos.is_empty());

    let first_repo = &repos[0];
    let branches = fetch_branches(&first_repo.owner, &first_repo.name).unwrap();
    assert!(!branches.is_empty());
}