pub async fn get_installation_token(

    endpoint: &str,

    token: &str,

    installation_id: u64,

) -> Result<TokenResponse, Error> {

    let url = format!("{endpoint}/app/installations/{installation_id}/access_tokens");

    info!("Fetching installation token from '{url}'");

    let client = new_client_with_common_headers(token)?;

    let response = send_request(client.post(&url)).await?;

    let token: TokenResponse = response

        .json()

        .await

        .map_err(|e| Error::Parse("get_installation_token", Box::new(e)))?;

    Ok(token)

}

pub async fn get_check_runs(

    endpoint: &str,

    token: &str,

    repo: &str,

    commit: &str,

) -> Result<Vec<CheckRun>, Error> {

    let url = format!("{endpoint}/repos/{repo}/commits/{commit}/check-runs");

    info!("Fetching check runs from '{url}'");

    let client = new_client_with_common_headers(token)?;

    let response = send_request(client.get(&url)).await?;

    let response = receive_body(response).await?;

    let check_runs: CheckRunsResponse = match serde_json::from_str(&response) {

        Ok(check_runs) => check_runs,

    Ok(check_runs.check_runs)

}

pub async fn create_check_run(

    endpoint: &str,

    token: &str,

    repo: &str,

    payload: &CheckRun,

) -> Result<(), Error> {

    let url = format!("{endpoint}/repos/{repo}/check-runs");

    info!("Creating check-run for '{}' at '{url}'", payload.head_sha);

    let client = new_client_with_common_headers(token)?;

    let response = send_request(client.post(&url).json(payload)).await?;

    let response = receive_body(response).await?;

    match serde_json::from_str::<CheckRun>(&response) {

        Ok(check_run) => {

            info!(

                "Created check-run '{}' for commit '{}'",

            Ok(())

}

pub async fn get_pull_request(

    endpoint: &str,

    token: &str,

    repo: &str,

    pull_number: u64,

) -> Result<PullRequestResponse, Error> {

    let url = format!("{endpoint}/repos/{repo}/pulls/{pull_number}");

    info!("Fetching pull request from '{url}'");

    let client = new_client_with_common_headers(token)?;

    let response = send_request(client.get(&url)).await?;

    let response = receive_body(response).await?;

    match serde_json::from_str::<PullRequestResponse>(&response) {

        Ok(pull_request) => Ok(pull_request),

}

fn new_client_with_common_headers(token: &str) -> Result<Client, Error> {

    let mut headers = HeaderMap::new();

    headers.insert(

        header::ACCEPT,

        HeaderValue::from_static("application/vnd.github+json"),

    headers.insert(

        HeaderName::from_static("x-github-api-version"),

        HeaderValue::from_static("2022-11-28"),

    headers.insert(header::USER_AGENT, HeaderValue::from_static(version::NAME));

    if !token.is_empty() {

        let bearer = format!("Bearer {token}");

        let bearer = HeaderValue::from_str(&bearer).map_err(|_| Error::InvalidBearerToken())?;

        headers.insert(header::AUTHORIZATION, bearer);

    Client::builder()

        .default_headers(headers)

        .build()

        .map_err(Error::CreateRequest)

}

async fn send_request(builder: reqwest::RequestBuilder) -> Result<reqwest::Response, Error> {

    let response = builder.send().await.map_err(Error::Send)?;

    if !response.status().is_success() {

        let status = response.status();

        let url = response.url().to_string();

        debug!(

        return Err(Error::NonOkStatus(url, status));

    }

    Ok(response)

}

async fn receive_body(response: reqwest::Response) -> Result<String, Error> {

    response.text().await.map_err(Error::ReceiveBody)

}