//! 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,

    /// The repositories it serves, in words.

    pub scope: String,

}

/// A scope in words: the whole site, an owner's repositories, or one

/// repository.

async fn scope_words(app: &Shared, s: &runners::Scope) -> String {

    match s.repo_id {

        Some(id) => match db::repos::get_by_id(&app.db, id).await.ok().flatten() {

            Some(r) => format!("{}/{}", r.owner, r.name),

            None => "a removed repository".into(),

        },

        None if s.owner.is_empty() => "the whole site".into(),

        None => format!("{}'s repositories", s.owner),

    }

}

/// A scope as typed: empty for the whole site, an owner, or

/// `owner/repository`.

async fn parse_scope(app: &Shared, text: &str) -> Result<runners::Scope, String> {

    let text = text.trim().trim_matches('/');

    if text.is_empty() {

        return Ok(runners::Scope::default());

    }

    if let Some((owner, name)) = text.split_once('/') {

        return match db::repos::get(&app.db, owner, name).await {

            Ok(Some(r)) => Ok(runners::Scope { owner: r.owner.clone(), repo_id: Some(r.id) }),

            _ => Err(format!("There is no repository {text}.")),

        };

    }

    let user = accounts::account_by_name(&app.db, text).await.ok().flatten().is_some();

    let org = accounts::org_by_name(&app.db, text).await.ok().flatten().is_some();

    if user || org {

        Ok(runners::Scope { owner: text.to_string(), repo_id: None })

    } else {

        Err(format!("There is no user or organisation {text}."))

    }

}

#[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>,

    /// Running jobs, then queued ones in the order runners claim them.

    queue: Vec<db::flow::QueueEntry>,

}

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 mut rows = Vec::with_capacity(list.len());

    for r in list {

        let scope = scope_words(app, &r.scope()).await;

        rows.push(RunnerRow { running: running.get(&r.id).copied().unwrap_or(0), scope, r });

    }

    let queue = db::flow::queue(&app.db).await.map_err(e)?;

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

}

/// `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,

}

#[derive(Deserialize)]

pub struct ScopeForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// Empty for the whole site, an owner, or `owner/repository`.

    #[serde(default)]

    scope: String,

}

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

/// for a runner of the scope given.

pub async fn new_token(State(app): State<Shared>, viewer: Viewer, Form(f): Form<ScopeForm>) -> 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 scope = match parse_scope(&app, &f.scope).await {

        Ok(s) => s,

        Err(e) => return page(&app, shell, None, None, Some(e)).await,

    };

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

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

        .await

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

    let words = scope_words(&app, &scope).await;

    accounts::audit(&app.db, Some(&me), "flow.runner.token", "", &format!("registration token created for {words}")).await.ok();

    page(&app, shell, Some(token), Some(format!("The runner it registers will take jobs from {words}.")), None).await

}

/// `POST /admin/runners/{id}/scope`: change the repositories a runner serves.

pub async fn set_scope(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(id): Path<i64>,

    Form(f): Form<ScopeForm>,

) -> 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 r =

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

    let scope = match parse_scope(&app, &f.scope).await {

        Ok(s) => s,

        Err(e) => return page(&app, shell, None, None, Some(e)).await,

    };

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

    let words = scope_words(&app, &scope).await;

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

    page(&app, shell, None, Some(format!("{} now takes jobs from {words}.", r.name)), 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(),

    }

}

// ---------------------------------------------------------------- settings

#[derive(Template)]

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

pub struct SettingsPage {

    shell: Shell,

    default_m: u64,

    max_m: u64,

    grace_m: i64,

    /// What hub.toml says, shown beside a setting the page overrides.

    file_default_m: u64,

    flow_repos: Vec<String>,

    notice: Option<String>,

    error: Option<String>,

}

async fn settings_page(app: &Shared, shell: Shell, notice: Option<String>, error: Option<String>) -> Page<SettingsPage> {

    let l = crate::flow::limits(app).await;

    Page(SettingsPage {

        shell,

        default_m: l.default_s / 60,

        max_m: l.max_s / 60,

        grace_m: l.grace_ms / 60_000,

        file_default_m: app.config.flow.job_timeout_minutes,

        flow_repos: app.config.flow.repos.clone(),

        notice,

        error,

    })

}

/// `GET /admin/runners/settings` (oxygenhub#89).

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

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

    require_admin(&viewer, &shell)?;

    Ok(settings_page(&app, shell, None, None).await)

}

#[derive(Deserialize)]

pub struct SettingsForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    default_minutes: String,

    max_minutes: String,

    grace_minutes: String,

}

/// `POST /admin/runners/settings`: the site's job time limits.

pub async fn save_settings(State(app): State<Shared>, viewer: Viewer, Form(f): Form<SettingsForm>) -> Result<Page<SettingsPage>, Error> {

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

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

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

    let num = |v: &str| v.trim().parse::<u64>().ok().filter(|n| *n > 0);

    let (Some(d), Some(m), Some(g)) = (num(&f.default_minutes), num(&f.max_minutes), num(&f.grace_minutes)) else {

        return Ok(settings_page(&app, shell, None, Some("Each limit is a whole number of minutes, at least 1.".into())).await);

    };

    if d > m {

        return Ok(settings_page(&app, shell, None, Some("The default cannot be longer than the maximum.".into())).await);

    }

    if m > 24 * 60 {

        return Ok(settings_page(&app, shell, None, Some("A job may run for a day at most (1440 minutes).".into())).await);

    }

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

    accounts::set_setting(&app.db, crate::flow::SETTING_DEFAULT, &d.to_string()).await.map_err(e)?;

    accounts::set_setting(&app.db, crate::flow::SETTING_MAX, &m.to_string()).await.map_err(e)?;

    accounts::set_setting(&app.db, crate::flow::SETTING_GRACE, &g.to_string()).await.map_err(e)?;

    accounts::audit(

        &app.db,

        Some(&me),

        "flow.settings",

        "",

        &format!("job time limit {d} min by default, {m} min at most; lost after {g} min more"),

    )

    .await

    .ok();

    Ok(settings_page(&app, shell, Some("Saved. Jobs claimed from now on run under these limits.".into()), None).await)

}