//! Land when checks pass (oxygenhub#261): someone who may land a proposal

//! sets it, and the hub lands it, as them, once its required checks pass

//! on its projected state and nothing else blocks it. A push to the source

//! makes a new projected state whose checks run again, so it waits again;

//! a required check that fails turns it off, with a note on the timeline;

//! so does the setter losing the right to land. Anyone who may land can

//! turn it off.

use crate::auth::roles::{self, Access};

use crate::db::{self, accounts, proposals as pdb};

use crate::repos::RepoName;

use crate::Shared;

/// One evaluation at a time across the hub: two checks finishing together

/// must not land a proposal twice.

static TURN: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());

/// Check statuses that end a check without its passing.

const FAILED: [&str; 2] = ["failed", "cancelled"];

/// Turn it on (`by`, who may land) or off, and look at once: a proposal

/// whose checks have already passed lands now.

pub async fn set(app: &Shared, row: &db::repos::RepoRow, p: &pdb::ProposalRow, by: &accounts::Account, on: bool) -> sqlx::Result<()> {

    if on {

        pdb::set_auto_land(&app.db, p.id, &by.username).await?;

        pdb::add_event(&app.db, p.id, &by.username, "set it to land when its checks pass", "").await.ok();

        accounts::audit(&app.db, Some(by), "proposal.auto_land", &format!("{}/{}#{}", row.owner, row.name, p.number), "on").await.ok();

        let p = pdb::get(&app.db, row.id, p.number).await?.unwrap_or_else(|| p.clone());

        evaluate(app, row, p).await;

    } else if !p.auto_land_by.is_empty() {

        pdb::set_auto_land(&app.db, p.id, "").await?;

        pdb::add_event(&app.db, p.id, &by.username, "turned off landing when its checks pass", "").await.ok();

        accounts::audit(&app.db, Some(by), "proposal.auto_land", &format!("{}/{}#{}", row.owner, row.name, p.number), "off").await.ok();

    }

    Ok(())

}

/// A check was recorded on `state`: the proposals set to land on it are

/// looked at again.

pub async fn on_check(app: &Shared, row: &db::repos::RepoRow, state: &str) {

    let waiting = match pdb::auto_landing(&app.db, row.id, state).await {

        Ok(w) => w,

        Err(e) => {

            tracing::warn!("auto-land: {e}");

            return;

        }

    };

    for p in waiting {

        evaluate(app, row, p).await;

    }

}

/// [`on_check`] as a boxed task, for `hooks::emit` to spawn: landing emits

/// hooks itself, so the future's type would otherwise contain itself.

pub fn on_check_task(

    app: Shared,

    row: db::repos::RepoRow,

    state: String,

) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>> {

    Box::pin(async move { on_check(&app, &row, &state).await })

}

async fn off(app: &Shared, p: &pdb::ProposalRow, why: &str) {

    pdb::set_auto_land(&app.db, p.id, "").await.ok();

    pdb::add_event(&app.db, p.id, "oxygenhub", "turned off landing when its checks pass", why).await.ok();

}

/// Land it if its checks have passed and nothing else blocks it; turn it

/// off if a required check failed or its setter may no longer land; else

/// wait.

async fn evaluate(app: &Shared, row: &db::repos::RepoRow, p: pdb::ProposalRow) {

    let _turn = TURN.lock().await;

    // And one at a time for this proposal across the hub's processes

    // (#275): two web nodes recording its last checks land it once.

    let Ok(_proposal) = crate::leader::exclusive(&app.db, &format!("autoland:{}", p.id)).await else { return };

    // Landed or closed meanwhile, or turned off.

    let Ok(Some(p)) = pdb::get(&app.db, row.id, p.number).await else { return };

    if !p.is_open() || p.auto_land_by.is_empty() {

        return;

    }

    let setter = match accounts::account_by_name(&app.db, &p.auto_land_by).await {

        Ok(Some(a)) if !a.blocked() => a,

        _ => return off(app, &p, &format!("{} can no longer land it", p.auto_land_by)).await,

    };

    let role = roles::role_for(&app.db, Some(&setter), row).await.ok().flatten();

    if !roles::allows(role, Access::Write) {

        return off(app, &p, &format!("{} can no longer land it", setter.username)).await;

    }

    let Some(repo) = RepoName::new(&row.owner, &row.name) else { return };

    let number = p.number;

    let Ok(loaded) = crate::web::proposals::load_summary(app, &repo, p.clone()).await else { return };

    let required = db::hooks::required_checks(&app.db, row.id).await.unwrap_or_default();

    let checks = db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await.unwrap_or_default();

    let failed: Vec<&str> = required

        .iter()

        .filter(|n| checks.iter().any(|c| &c.name == *n && FAILED.contains(&c.status.as_str())))

        .map(|n| n.as_str())

        .collect();

    if !failed.is_empty() {

        let why = format!("{} did not pass", failed.join(", "));

        return off(app, &p, &why).await;

    }

    let Ok(v) = crate::web::proposals::verdict(app, &loaded, row.id).await else { return };

    if !v.blockers.is_empty() {

        return;

    }

    let via = format!("when its checks passed (set by {})", setter.username);

    match crate::web::proposals::land_as(app, &repo, row, &setter, number, &via, false, None).await {

        Ok(_) => {

            pdb::set_auto_land(&app.db, p.id, "").await.ok();

        }

        Err(crate::web::proposals::Landing::Refused(why)) => off(app, &p, &why).await,

        Err(crate::web::proposals::Landing::NotFound) => {}

    }

}