//! Read-only forge catalogs; fetch targets always stay on the configured remote.
use crate::repository::{checked, run};
use serde_json::Value;
use std::{
    collections::BTreeMap,
    path::Path,
    process::Command,
    sync::atomic::{AtomicBool, Ordering},
};

pub(crate) struct PullRequestSummary {
    pub number: u64,
    pub title: String,
    pub description: String,
    pub closed: bool,
    pub created_at: String,
}

pub(crate) struct PullRequestPage {
    pub entries: Vec<PullRequestSummary>,
    pub has_more: bool,
}

pub(crate) struct PullRequest {
    pub revisions: Result<PullRequestRevisions, String>,
}

pub(crate) struct PullRequestRevisions {
    pub base_ref: String,
    pub base_sha: String,
    pub head_ref: String,
    pub head_sha: String,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Provider {
    Github,
    Gitlab,
    Gitea,
}
struct Forge {
    provider: Provider,
    host: String,
    endpoint: String,
}

fn encode(text: &str) -> String {
    use std::fmt::Write;
    let mut encoded = String::new();
    for byte in text.bytes() {
        if byte.is_ascii_alphanumeric() || b"-._~".contains(&byte) {
            encoded.push(byte as char);
        } else {
            write!(encoded, "%{byte:02X}").unwrap();
        }
    }
    encoded
}

fn decode(path: &str) -> Result<String, String> {
    let mut bytes = path.bytes();
    let mut decoded = Vec::with_capacity(path.len());
    while let Some(byte) = bytes.next() {
        decoded.push(if byte == b'%' {
            let hi = bytes.next().and_then(|b| (b as char).to_digit(16));
            let lo = bytes.next().and_then(|b| (b as char).to_digit(16));
            let (hi, lo) = hi.zip(lo).ok_or("Invalid escaped remote path")?;
            (hi * 16 + lo) as u8
        } else {
            byte
        });
    }
    String::from_utf8(decoded).map_err(|_| "Remote path is not UTF-8".into())
}

fn ssh_hostname(
    mut command: Command,
    destination: &str,
    port: &str,
    cancelled: &AtomicBool,
) -> Result<String, String> {
    command.arg("-G");
    if !port.is_empty() {
        command.args(["-p", &port[1..]]);
    }
    command.args(["--", destination]);
    let output = checked(run(command, vec![], cancelled)?)
        .map_err(|error| format!("Cannot resolve SSH remote configuration: {error}"))?;
    let output = std::str::from_utf8(&output).map_err(|_| "SSH configuration is not UTF-8")?;
    output
        .lines()
        .find_map(|line| line.strip_prefix("hostname "))
        .map(str::to_owned)
        .ok_or_else(|| "SSH configuration returned no hostname".into())
}

impl Forge {
    fn parse(
        url: &str,
        provider: Option<&str>,
        resolve_ssh: impl FnOnce(&str, &str) -> Result<String, String>,
    ) -> Result<Self, String> {
        if url.bytes().any(|b| b <= b' ' || b == 127) || url.contains(['?', '#', '\\']) {
            return Err("Invalid forge remote URL".into());
        }
        let (authority, path, ssh) = if let Some((scheme, rest)) = url.split_once("://") {
            if !matches!(scheme, "https" | "ssh" | "git+ssh") {
                return Err("Pull requests require an HTTPS or SSH remote".into());
            }
            let (authority, path) = rest
                .split_once('/')
                .ok_or("Forge remote has no repository path")?;
            (authority, path, scheme != "https")
        } else {
            let separator = if let Some(end) = url.find(']') {
                end + 1
            } else {
                url.find(':')
                    .ok_or("Pull requests require an HTTPS or SSH remote")?
            };
            if url.as_bytes().get(separator) != Some(&b':') {
                return Err("Invalid SSH remote".into());
            }
            (&url[..separator], &url[separator + 1..], true)
        };
        let destination = authority;
        // Git URL userinfo must never become an API credential.
        if ssh
            && authority
                .rsplit_once('@')
                .is_some_and(|(user, _)| user.contains(':'))
        {
            return Err("SSH remote URLs must not contain passwords".into());
        }
        let authority = authority.rsplit('@').next().unwrap();
        let (host, port) = if authority.starts_with('[') {
            let end = authority.find(']').ok_or("Invalid remote host")?;
            authority[1..end]
                .parse::<std::net::Ipv6Addr>()
                .map_err(|_| "Invalid remote host")?;
            (&authority[..=end], &authority[end + 1..])
        } else {
            let (host, port) = authority.split_at(authority.find(':').unwrap_or(authority.len()));
            if host.is_empty()
                || host.starts_with('-')
                || !host
                    .bytes()
                    .all(|b| b.is_ascii_alphanumeric() || b".-".contains(&b))
            {
                return Err("Invalid remote host".into());
            }
            (host, port)
        };
        if !port.is_empty()
            && port
                .strip_prefix(':')
                .and_then(|p| p.parse::<u16>().ok())
                .filter(|p| *p != 0)
                .is_none()
        {
            return Err("Invalid remote port".into());
        }
        let mut host = host.to_ascii_lowercase();
        if ssh {
            host = resolve_ssh(&destination[..destination.len() - port.len()], port)?
                .to_ascii_lowercase();
            let ipv6 = host.trim_start_matches('[').trim_end_matches(']');
            if ipv6.parse::<std::net::Ipv6Addr>().is_ok() {
                host = format!("[{ipv6}]");
            } else if host.is_empty()
                || host.starts_with('-')
                || !host
                    .bytes()
                    .all(|b| b.is_ascii_alphanumeric() || b".-".contains(&b))
            {
                return Err("SSH configuration returned an invalid hostname".into());
            }
        }
        if ssh && host == "ssh.github.com" {
            host = "github.com".into();
        }
        if ssh && host == "altssh.gitlab.com" {
            host = "gitlab.com".into();
        }
        let provider = match provider {
            Some("github") => Provider::Github,
            Some("gitlab") => Provider::Gitlab,
            Some("gitea") => Provider::Gitea,
            Some(_) => {
                return Err("remote.<name>.vamp-forge must be github, gitlab, or gitea".into());
            }
            None if host == "github.com" => Provider::Github,
            None if host.split('.').any(|label| label == "gitlab") => Provider::Gitlab,
            None if host == "codeberg.org" || host.split('.').any(|label| label == "gitea") => {
                Provider::Gitea
            }
            None => {
                return Err(format!(
                    "Unknown forge for {host}; run `git config remote.<name>.vamp-forge github` (or use gitlab or gitea)"
                ));
            }
        };
        let path = decode(path.trim_matches('/'))?;
        let path = path.strip_suffix(".git").unwrap_or(&path);
        let parts: Vec<_> = path.split('/').collect();
        if parts.len() < 2
            || (provider != Provider::Gitlab && parts.len() != 2)
            || parts.iter().any(|p| {
                p.is_empty() || matches!(*p, "." | "..") || p.chars().any(char::is_control)
            })
        {
            return Err("Invalid repository path for the configured forge".into());
        }
        let authority = format!("{host}{}", if ssh { "" } else { port });
        let endpoint = match provider {
            Provider::Github => format!(
                "{}/repos/{}/{}/pulls",
                if host == "github.com" && (ssh || port.is_empty() || port == ":443") {
                    "https://api.github.com".into()
                } else {
                    format!("https://{authority}/api/v3")
                },
                encode(parts[0]),
                encode(parts[1])
            ),
            Provider::Gitlab => format!(
                "https://{authority}/api/v4/projects/{}/merge_requests",
                encode(path)
            ),
            Provider::Gitea => format!(
                "https://{authority}/api/v1/repos/{}/{}/pulls",
                encode(parts[0]),
                encode(parts[1])
            ),
        };
        Ok(Self {
            provider,
            host: authority,
            endpoint,
        })
    }

    fn token(&self, root: &Path, cancelled: &AtomicBool) -> Result<Option<String>, String> {
        let names: &[&str] = match self.provider {
            Provider::Github if self.host == "github.com" || self.host == "github.com:443" => {
                &["GH_TOKEN", "GITHUB_TOKEN"]
            }
            Provider::Github => &["GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN"],
            Provider::Gitlab => &["GITLAB_TOKEN"],
            Provider::Gitea => &["GITEA_TOKEN"],
        };
        let mut token = None;
        for name in names {
            match std::env::var(name) {
                Ok(value) if !value.is_empty() => {
                    token = Some(value);
                    break;
                }
                Err(std::env::VarError::NotUnicode(_)) => {
                    return Err("Forge token is not valid UTF-8".into());
                }
                _ => {}
            }
        }
        if token.is_none() && self.provider != Provider::Gitea {
            let mut command = Command::new(if self.provider == Provider::Github {
                "gh"
            } else {
                "glab"
            });
            let host = if self.provider == Provider::Github && self.host == "github.com:443" {
                "github.com"
            } else {
                &self.host
            };
            command
                .current_dir(root)
                .args(["auth", "token", "--hostname", host]);
            match run(command, Vec::new(), cancelled) {
                Ok(output) => {
                    if let Ok(bytes) = checked(output) {
                        token = Some(
                            String::from_utf8(bytes)
                                .map_err(|_| "Stored forge token is not valid UTF-8")?
                                .trim()
                                .to_owned(),
                        );
                    }
                }
                Err(error)
                    if cancelled.load(Ordering::Acquire)
                        || !error.starts_with("Cannot start repository command:") =>
                {
                    return Err(error);
                }
                Err(_) => {}
            }
        }
        token
            .filter(|t| !t.is_empty())
            .map(|token| {
                if token.bytes().all(|b| b.is_ascii_graphic()) {
                    Ok(token)
                } else {
                    Err("Forge token contains invalid header characters".into())
                }
            })
            .transpose()
    }

    fn get(
        &self,
        url: &str,
        token: Option<&str>,
        root: &Path,
        cancelled: &AtomicBool,
    ) -> Result<Value, String> {
        let mut headers = String::from("Accept: application/json\n");
        if let Some(token) = token {
            let prefix = match self.provider {
                Provider::Github => "Authorization: Bearer",
                Provider::Gitlab => "PRIVATE-TOKEN:",
                Provider::Gitea => "Authorization: token",
            };
            headers.push_str(&format!("{prefix} {token}\n"));
        }
        // Ignore curlrc; credentials only travel on stdin. Never follow Location or API-provided URLs.
        let mut command = Command::new("curl");
        command.current_dir(root).args([
            "--disable",
            "--silent",
            "--globoff",
            "--proto",
            "=https",
            "--connect-timeout",
            "15",
            "--max-time",
            "55",
            "--max-redirs",
            "0",
            "--user-agent",
            "vamp",
            "--header",
            "@-",
            "--write-out",
            "\n%{http_code}",
            "--url",
            url,
        ]);
        let bytes = checked(run(command, headers.into_bytes(), cancelled)?).map_err(
            |_| "Forge API request failed; check curl, network access, and authentication",
        )?;
        let split = bytes
            .iter()
            .rposition(|b| *b == b'\n')
            .ok_or("Invalid forge HTTP response")?;
        let status = &bytes[split + 1..];
        if status != b"200" {
            let code = std::str::from_utf8(status)
                .ok()
                .filter(|s| s.len() == 3 && s.bytes().all(|b| b.is_ascii_digit()))
                .unwrap_or("unknown");
            return Err(format!(
                "Forge API returned HTTP {code}; check remote URL and authentication (redirects are not followed)"
            ));
        }
        serde_json::from_slice(&bytes[..split])
            .map_err(|_| "Forge API returned invalid JSON".into())
    }
}

impl Forge {
    fn page_with(
        &self,
        closed: bool,
        page: u32,
        mut get: impl FnMut(&str) -> Result<Value, String>,
    ) -> Result<PullRequestPage, String> {
        if page == 0 {
            return Err("Forge page numbers start at 1".into());
        }
        let states: &[&str] = match (self.provider, closed) {
            (Provider::Gitlab, true) => &["closed", "merged"],
            (Provider::Gitlab, false) => &["opened"],
            (_, true) => &["closed"],
            (_, false) => &["open"],
        };
        let mut entries = BTreeMap::new();
        let mut has_more = false;
        for state in states {
            let query = match self.provider {
                Provider::Github => "per_page=50&sort=created&direction=desc",
                Provider::Gitlab => "scope=all&per_page=50&order_by=created_at&sort=desc",
                // Gitea's default sort is descending creation time; "oldest" reverses it.
                Provider::Gitea => "limit=50",
            };
            let values = get(&format!(
                "{}?state={state}&{query}&page={page}",
                self.endpoint
            ))?;
            let values = values
                .as_array()
                .ok_or("Forge API returned a non-array pull request list")?;
            // Servers may cap page sizes. Only an empty page proves exhaustion.
            has_more |= !values.is_empty();
            for value in values {
                let entry = summary(self.provider, value)?;
                if entry.closed != closed {
                    return Err("Forge API returned a pull request in the wrong category".into());
                }
                entries.insert(entry.number, entry);
            }
        }
        // GitLab needs two independently paged states for Closed. Later batches may
        // precede older rows from the other state; consumers sort the partial catalog.
        let mut entries: Vec<_> = entries.into_values().collect();
        entries.sort_unstable_by(|a, b| {
            b.created_at
                .cmp(&a.created_at)
                .then_with(|| b.number.cmp(&a.number))
        });
        Ok(PullRequestPage { entries, has_more })
    }

    fn resolve_with(
        &self,
        id: u64,
        mut get: impl FnMut(&str) -> Result<Value, String>,
    ) -> Result<PullRequest, String> {
        if id == 0 {
            return Err("Pull request numbers start at 1".into());
        }
        let detail = get(&format!("{}/{id}", self.endpoint))?;
        if number(
            &detail,
            if self.provider == Provider::Gitlab {
                "iid"
            } else {
                "number"
            },
        )? != id
        {
            return Err("Forge API returned a different pull request".into());
        }
        let preserved_head = if self.provider == Provider::Gitea {
            let repo = self.endpoint.strip_suffix("/pulls").unwrap();
            let reference = get(&format!("{repo}/git/refs/pull/{id}/head"))?;
            Some(gitea_head(&reference, id)?)
        } else {
            None
        };
        pull_request(self.provider, &detail, preserved_head)
    }
}

fn gitea_head(value: &Value, id: u64) -> Result<String, String> {
    // Gitea versions return either an object or an array for the filtered refs API.
    let value = if let Some(values) = value.as_array() {
        if values.len() != 1 {
            return Err(format!(
                "Gitea pull request #{id} has no unique preserved head reference"
            ));
        }
        &values[0]
    } else {
        value
    };
    if field(value, "ref")? != format!("refs/pull/{id}/head") {
        return Err("Gitea API returned a different pull request reference".into());
    }
    let object = value
        .get("object")
        .ok_or("Gitea API returned no reference object")?;
    if field(object, "type")? != "commit" {
        return Err("Gitea API returned a non-commit pull request head".into());
    }
    sha(object, "sha")
}

fn created_at(value: &Value) -> Result<String, String> {
    let invalid = || "Forge API returned invalid created_at".to_owned();
    let text = field(value, "created_at")?;
    let digits = |text: &str| -> Option<i32> {
        (!text.is_empty() && text.bytes().all(|b| b.is_ascii_digit()))
            .then(|| text.parse().ok())
            .flatten()
    };
    if !text.is_ascii()
        || text.len() < 20
        || &text[4..5] != "-"
        || &text[7..8] != "-"
        || &text[10..11] != "T"
        || &text[13..14] != ":"
        || &text[16..17] != ":"
    {
        return Err(invalid());
    }
    let mut year = digits(&text[..4]).ok_or_else(invalid)?;
    let mut month = digits(&text[5..7]).ok_or_else(invalid)?;
    let mut day = digits(&text[8..10]).ok_or_else(invalid)?;
    let hour = digits(&text[11..13]).ok_or_else(invalid)?;
    let minute = digits(&text[14..16]).ok_or_else(invalid)?;
    let second = digits(&text[17..19]).ok_or_else(invalid)?;
    let days = |year: i32, month: i32| match month {
        2 => 28 + i32::from(year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)),
        4 | 6 | 9 | 11 => 30,
        _ => 31,
    };
    if year == 0
        || !(1..=12).contains(&month)
        || !(1..=days(year, month)).contains(&day)
        || hour > 23
        || minute > 59
        || second > 59
    {
        return Err(invalid());
    }
    let mut rest = &text[19..];
    let mut nanos = 0;
    if let Some(fraction) = rest.strip_prefix('.') {
        let end = fraction
            .find(|c: char| !c.is_ascii_digit())
            .ok_or_else(invalid)?;
        if end == 0 || end > 9 {
            return Err(invalid());
        }
        nanos = digits(&fraction[..end]).ok_or_else(invalid)? * 10i32.pow(9 - end as u32);
        rest = &fraction[end..];
    }
    let offset = if rest == "Z" {
        0
    } else if rest.len() == 6 && matches!(&rest[..1], "+" | "-") && &rest[3..4] == ":" {
        let hours = digits(&rest[1..3]).ok_or_else(invalid)?;
        let minutes = digits(&rest[4..6]).ok_or_else(invalid)?;
        if hours > 23 || minutes > 59 {
            return Err(invalid());
        }
        (hours * 60 + minutes) * if rest.starts_with('+') { 1 } else { -1 }
    } else {
        return Err(invalid());
    };
    let minutes = hour * 60 + minute - offset;
    day += minutes.div_euclid(1440);
    if day == 0 {
        month -= 1;
        if month == 0 {
            year -= 1;
            month = 12;
        }
        day = days(year, month);
    } else if day > days(year, month) {
        day = 1;
        month += 1;
        if month == 13 {
            year += 1;
            month = 1;
        }
    }
    if !(1..=9999).contains(&year) {
        return Err(invalid());
    }
    let minutes = minutes.rem_euclid(1440);
    Ok(format!(
        "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{second:02}.{nanos:09}Z",
        minutes / 60,
        minutes % 60
    ))
}

fn summary(provider: Provider, value: &Value) -> Result<PullRequestSummary, String> {
    let gitlab = provider == Provider::Gitlab;
    let (closed, merged) = status(provider, value)?;
    let author = author(provider, value)?;
    let state = if merged {
        "merged"
    } else if closed {
        "closed"
    } else {
        "open"
    };
    let (base, head) = if gitlab {
        (
            value.get("target_branch").and_then(Value::as_str),
            value.get("source_branch").and_then(Value::as_str),
        )
    } else {
        (
            value.pointer("/base/ref").and_then(Value::as_str),
            value
                .pointer(if provider == Provider::Gitea {
                    "/head/label"
                } else {
                    "/head/ref"
                })
                .and_then(Value::as_str)
                .filter(|s| !s.is_empty())
                .or_else(|| value.pointer("/head/ref").and_then(Value::as_str)),
        )
    };
    Ok(PullRequestSummary {
        number: number(value, if gitlab { "iid" } else { "number" })?,
        title: field(value, "title")?.to_owned(),
        description: match (base, head) {
            (Some(base), Some(head)) => format!("{author} · {state} · {head} → {base}"),
            _ => format!("{author} · {state}"),
        },
        closed,
        created_at: created_at(value)?,
    })
}

fn field<'a>(value: &'a Value, key: &str) -> Result<&'a str, String> {
    value
        .get(key)
        .and_then(Value::as_str)
        .ok_or_else(|| format!("Forge API returned invalid {key}"))
}
fn number(value: &Value, key: &str) -> Result<u64, String> {
    value
        .get(key)
        .and_then(Value::as_u64)
        .filter(|n| *n > 0)
        .ok_or_else(|| format!("Forge API returned invalid {key}"))
}
fn sha(value: &Value, key: &str) -> Result<String, String> {
    let sha = field(value, key)?;
    if matches!(sha.len(), 40 | 64)
        && sha.bytes().all(|b| b.is_ascii_hexdigit())
        && sha.bytes().any(|b| b != b'0')
    {
        Ok(sha.to_ascii_lowercase())
    } else {
        Err(format!("Forge API returned invalid {key} commit ID"))
    }
}
fn branch<'a>(value: &'a Value, key: &str) -> Result<&'a str, String> {
    let branch = field(value, key)?;
    if branch.is_empty()
        || branch.contains(['~', '^', ':', '?', '*', '[', '\\'])
        || branch.contains("..")
        || branch.contains("@{")
        || branch.bytes().any(|b| b <= b' ' || b == 127)
        || branch
            .split('/')
            .any(|p| p.is_empty() || p.starts_with('.') || p.ends_with('.') || p.ends_with(".lock"))
    {
        Err(format!("Forge API returned invalid {key} branch"))
    } else {
        Ok(branch)
    }
}

fn status(provider: Provider, value: &Value) -> Result<(bool, bool), String> {
    let gitlab = provider == Provider::Gitlab;
    let state = field(value, "state")?;
    let closed = match (gitlab, state) {
        (false, "open") | (true, "opened" | "locked") => false,
        (false, "closed") | (true, "closed" | "merged") => true,
        _ => return Err("Forge API returned invalid pull request state".into()),
    };
    let merged = match provider {
        Provider::Github => match value.get("merged_at") {
            Some(Value::Null) => false,
            Some(Value::String(date)) if !date.is_empty() => true,
            _ => return Err("Forge API returned invalid merged_at".into()),
        },
        Provider::Gitlab => state == "merged",
        Provider::Gitea => value
            .get("merged")
            .and_then(Value::as_bool)
            .ok_or("Forge API returned invalid merged flag")?,
    };
    if merged && !closed {
        return Err("Forge API returned inconsistent merged state".into());
    }
    Ok((closed, merged))
}

fn author(provider: Provider, value: &Value) -> Result<&str, String> {
    let gitlab = provider == Provider::Gitlab;
    let author = value
        .get(if gitlab { "author" } else { "user" })
        .ok_or("Forge API returned no author")?;
    if author.is_null() {
        Ok("deleted user")
    } else {
        field(author, if gitlab { "username" } else { "login" })
    }
}

fn pull_request(
    provider: Provider,
    value: &Value,
    preserved_head: Option<String>,
) -> Result<PullRequest, String> {
    let gitlab = provider == Provider::Gitlab;
    let number = number(value, if gitlab { "iid" } else { "number" })?;
    status(provider, value)?;
    let revisions = (|| -> Result<_, String> {
        let (base, head, base_sha, head_sha) = if gitlab {
            let refs = value.get("diff_refs").filter(|v| v.is_object()).ok_or(
                "GitLab merge request has no prepared diff_refs; retry after GitLab prepares it",
            )?;
            // Legacy MRs omit the target tip; their recorded merge base yields the same PR diff.
            (
                branch(value, "target_branch")?,
                branch(value, "source_branch")?,
                sha(
                    refs,
                    if refs.get("start_sha").is_none_or(Value::is_null) {
                        "base_sha"
                    } else {
                        "start_sha"
                    },
                )?,
                sha(refs, "head_sha")?,
            )
        } else {
            let base = value
                .get("base")
                .ok_or("Forge API returned no base branch")?;
            let head = value
                .get("head")
                .ok_or("Forge API returned no head branch")?;
            // Gitea base.sha follows the live target branch even after merging.
            let base_sha = if provider == Provider::Gitea {
                sha(value, "merge_base")?
            } else {
                sha(base, "sha")?
            };
            let head_key = if provider == Provider::Gitea
                && head
                    .get("label")
                    .and_then(Value::as_str)
                    .is_some_and(|s| !s.is_empty())
            {
                "label"
            } else {
                "ref"
            };
            (
                branch(base, "ref")?,
                if provider == Provider::Gitea {
                    field(head, head_key)?
                } else {
                    branch(head, head_key)?
                },
                base_sha,
                if provider == Provider::Gitea {
                    preserved_head.ok_or_else(|| {
                        format!("Gitea pull request #{number} has no preserved head reference")
                    })?
                } else {
                    sha(head, "sha")?
                },
            )
        };
        Ok((
            PullRequestRevisions {
                base_ref: format!("refs/heads/{base}"),
                base_sha,
                head_ref: format!(
                    "refs/{}/{number}/head",
                    if gitlab { "merge-requests" } else { "pull" }
                ),
                head_sha,
            },
            base,
            head,
        ))
    })();
    Ok(PullRequest {
        revisions: revisions.map(|(revisions, _, _)| revisions),
    })
}

pub(crate) fn page(
    url: &str,
    provider: Option<&str>,
    closed: bool,
    page: u32,
    root: &Path,
    cancelled: &AtomicBool,
) -> Result<PullRequestPage, String> {
    let forge = Forge::parse(url, provider, |destination, port| {
        let mut command = Command::new("ssh");
        command.current_dir(root);
        ssh_hostname(command, destination, port, cancelled)
    })?;
    let token = forge.token(root, cancelled)?;
    forge.page_with(closed, page, |url| {
        forge.get(url, token.as_deref(), root, cancelled)
    })
}

pub(crate) fn resolve(
    url: &str,
    provider: Option<&str>,
    number: u64,
    root: &Path,
    cancelled: &AtomicBool,
) -> Result<PullRequest, String> {
    let forge = Forge::parse(url, provider, |destination, port| {
        let mut command = Command::new("ssh");
        command.current_dir(root);
        ssh_hostname(command, destination, port, cancelled)
    })?;
    let token = forge.token(root, cancelled)?;
    forge.resolve_with(number, |url| {
        forge.get(url, token.as_deref(), root, cancelled)
    })
}

#[cfg(test)]
#[path = "../tests/unit/forge.rs"]
mod tests;