//! Admin → Runners (hub spec §13.2): the OxygenFlow runners of this hub,

//! what they are and are running, their history, registration tokens, and

//! draining, disabling and removing them.

use super::settings::csrf;

use super::{filters, Error, Page, Shell};

use crate::auth::Viewer;

use crate::db::{self, accounts, runners};

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Path, Query, State};

use axum::response::{IntoResponse, Redirect, Response};

use serde::Deserialize;

use std::collections::HashMap;

fn require_admin(viewer: &Viewer, shell: &Shell) -> Result<accounts::Account, Error> {

    match viewer.account() {

        Some(a) if a.is_admin => Ok(a.clone()),

        _ => Err(Error::not_found(shell.clone())),

    }

}

pub struct RunnerRow {

    pub r: runners::Runner,

    /// Jobs it is running now.

    pub running: i64,

}

#[derive(Template)]

#[template(path = "admin_runners.html")]

pub struct RunnersPage {

    shell: Shell,

    runners: Vec<RunnerRow>,

    /// Registration tokens waiting to be used: (created by, created, expires).

    pending: Vec<(String, i64, i64)>,

    /// A token just made, shown once, with the command that uses it.

    new_token: Option<String>,

    hub: String,

    notice: Option<String>,

    error: Option<String>,

}

async fn page(

    app: &Shared,

    shell: Shell,

    new_token: Option<String>,

    notice: Option<String>,

    error: Option<String>,

) -> Result<Page<RunnersPage>, Error> {

    let e = |e| Error::from_db(shell.clone(), e);

    let list = runners::list(&app.db).await.map_err(e)?;

    let running: HashMap<i64, i64> = runners::running(&app.db).await.map_err(e)?.into_iter().collect();

    let pending = runners::pending_registrations(&app.db).await.map_err(e)?;

    let rows = list.into_iter().map(|r| RunnerRow { running: running.get(&r.id).copied().unwrap_or(0), r }).collect();

    Ok(Page(RunnersPage { hub: app.config.base_url().to_string(), shell, runners: rows, pending, new_token, notice, error }))

}

/// `GET /admin/runners`.

pub async fn list(State(app): State<Shared>, viewer: Viewer) -> Result<Page<RunnersPage>, Error> {

    let shell = Shell::new(&app, "/admin/runners", &viewer);

    require_admin(&viewer, &shell)?;

    page(&app, shell, None, None, None).await

}

#[derive(Deserialize)]

pub struct CsrfOnly {

    #[serde(rename = "_csrf")]

    csrf_token: String,

}

/// `POST /admin/runners/token`: a one-time registration token, shown once.

pub async fn new_token(State(app): State<Shared>, viewer: Viewer, Form(f): Form<CsrfOnly>) -> Result<Page<RunnersPage>, Error> {

    let shell = Shell::new(&app, "/admin/runners", &viewer);

    let me = require_admin(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let token = format!("flowreg_{}", crate::auth::random_hex(24));

    runners::add_registration(&app.db, &blake3::hash(token.as_bytes()).to_hex(), &me.username)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "flow.runner.token", "", "registration token created").await.ok();

    page(&app, shell, Some(token), None, None).await

}

#[derive(Deserialize)]

pub struct StateForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// `active`, `draining` or `disabled`.

    state: String,

}

/// `POST /admin/runners/{id}/state`: drain, disable or resume a runner.

pub async fn set_state(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(id): Path<i64>,

    Form(f): Form<StateForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/admin/runners", &viewer);

    let me = require_admin(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    if !matches!(f.state.as_str(), "active" | "draining" | "disabled") {

        return Err(Error::bad(shell, "a runner is active, draining or disabled"));

    }

    let r =

        runners::get(&app.db, id).await.map_err(|e| Error::from_db(shell.clone(), e))?.ok_or_else(|| Error::not_found(shell.clone()))?;

    runners::set_state(&app.db, id, &f.state).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "flow.runner.state", &r.name, &f.state).await.ok();

    Ok(Redirect::to("/admin/runners").into_response())

}

/// `POST /admin/runners/{id}/remove`: forget a runner that runs nothing.

pub async fn remove(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(id): Path<i64>,

    Form(f): Form<CsrfOnly>,

) -> Result<Page<RunnersPage>, Error> {

    let shell = Shell::new(&app, "/admin/runners", &viewer);

    let me = require_admin(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let r = runners::get(&app.db, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let busy = runners::running(&app.db).await.map_err(e)?.into_iter().any(|(rid, n)| rid == id && n > 0);

    if busy {

        return page(

            &app,

            shell,

            None,

            None,

            Some(format!("{} is running jobs: drain it first, then remove it when they finish.", r.name)),

        )

        .await;

    }

    runners::remove(&app.db, id).await.map_err(e)?;

    accounts::audit(&app.db, Some(&me), "flow.runner.remove", &r.name, "").await.ok();

    let also = if r.source == "config" {

        " It is configured in hub.toml; remove its token there too, or it comes back on its next claim."

    } else {

        ""

    };

    page(&app, shell, None, Some(format!("Removed {}.{also}", r.name)), None).await

}

#[derive(Template)]

#[template(path = "admin_runner.html")]

pub struct RunnerPage {

    shell: Shell,

    r: runners::Runner,

    running: i64,

    history: Vec<runners::RunnerJob>,

    older: Option<i64>,

    jobs: i64,

    passed: i64,

    busy_ms: i64,

}

impl RunnerPage {

    /// Time spent running jobs, as pages show durations.

    pub fn busy(&self) -> String {

        crate::flow::human_ms(self.busy_ms)

    }

}

#[derive(Deserialize, Default)]

pub struct HistoryQuery {

    before: Option<i64>,

}

const PER_PAGE: i64 = 50;

/// `GET /admin/runners/{id}`: a runner and the jobs it ran.

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(id): Path<i64>,

    Query(q): Query<HistoryQuery>,

) -> Result<Page<RunnerPage>, Error> {

    let shell = Shell::new(&app, &format!("/admin/runners/{id}"), &viewer);

    require_admin(&viewer, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let r = runners::get(&app.db, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let mut history = runners::history(&app.db, id, PER_PAGE + 1, q.before).await.map_err(e)?;

    let older = (history.len() as i64 > PER_PAGE).then(|| history[PER_PAGE as usize - 1].started_ms).flatten();

    history.truncate(PER_PAGE as usize);

    let (jobs, passed, busy_ms) = runners::totals(&app.db, id).await.map_err(e)?;

    let running = runners::running(&app.db).await.map_err(e)?.into_iter().find(|(rid, _)| *rid == id).map(|(_, n)| n).unwrap_or(0);

    Ok(Page(RunnerPage { shell, r, running, history, older, jobs, passed, busy_ms }))

}

pub fn duration(j: &runners::RunnerJob) -> String {

    match (j.started_ms, j.finished_ms) {

        (Some(a), Some(b)) => crate::flow::human_ms(b - a),

        (Some(a), None) => crate::flow::human_ms(db::now_ms() - a),

        _ => "–".into(),

    }

}