//! Site administration (hub spec §6.3 `/admin/*`): accounts, registration

//! mode and invitations, the audit log.

use super::settings::csrf;

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

use crate::auth::{self, Viewer};

use crate::db::accounts;

use crate::Shared;

use askama::Template;

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

use serde::Deserialize;

/// A page of the admin area (oxygenhub#288): grouped in a sidebar, one

/// page per section, as a repository's settings are (#278).

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum AdminSection {

    Overview,

    Accounts,

    Registration,

    Organisations,

    SignIn,

    SecurityContact,

    Mail,

    Runners,

    Images,

    RunnerSettings,

    RunnerUpdates,

    Insights,

    Variables,

    Secrets,

    Assistants,

    Diffusion,

    Storage,

    Backups,

    NewRepositories,

    Audit,

}

/// The sidebar: each group's heading and its pages, in order.

const ADMIN_GROUPS: &[(&str, &[AdminSection])] = &[

    ("Overview", &[AdminSection::Overview]),

    ("People", &[AdminSection::Accounts, AdminSection::Registration, AdminSection::Organisations]),

    ("Sign-in", &[AdminSection::SignIn, AdminSection::SecurityContact]),

    ("Mail", &[AdminSection::Mail]),

    (

        "Flow",

        &[

            AdminSection::Runners,

            AdminSection::Images,

            AdminSection::RunnerSettings,

            AdminSection::RunnerUpdates,

            AdminSection::Insights,

            AdminSection::Variables,

            AdminSection::Secrets,

        ],

    ),

    ("Integrations", &[AdminSection::Assistants, AdminSection::Diffusion]),

    ("Data", &[AdminSection::NewRepositories, AdminSection::Storage, AdminSection::Backups]),

    ("Audit", &[AdminSection::Audit]),

];

/// The admin sidebar's groups, for templates.

pub fn admin_groups() -> &'static [(&'static str, &'static [AdminSection])] {

    ADMIN_GROUPS

}

impl AdminSection {

    /// Its page's address.

    pub fn href(self) -> &'static str {

        match self {

            AdminSection::Overview => "/admin",

            AdminSection::Accounts => "/admin/accounts",

            AdminSection::Registration => "/admin/registration",

            AdminSection::Organisations => "/admin/organisations",

            AdminSection::SignIn => "/admin/signin",

            AdminSection::SecurityContact => "/admin/security",

            AdminSection::Mail => "/admin/mail",

            AdminSection::Runners => "/admin/runners",

            AdminSection::Images => "/admin/runners/images",

            AdminSection::RunnerSettings => "/admin/runners/settings",

            AdminSection::RunnerUpdates => "/admin/runners/updates",

            AdminSection::Insights => "/admin/insights",

            AdminSection::Variables => "/admin/variables",

            AdminSection::Secrets => "/admin/secrets",

            AdminSection::Assistants => "/admin/assistants",

            AdminSection::Diffusion => "/admin/diffusion",

            AdminSection::Storage => "/admin/storage",

            AdminSection::Backups => "/admin/backups",

            AdminSection::NewRepositories => "/admin/repositories",

            AdminSection::Audit => "/admin/audit",

        }

    }

    /// The anchor it had on the one-page admin, so a kept `/admin#mail`

    /// link opens its page (hub.js).

    pub fn slug(self) -> &'static str {

        match self {

            AdminSection::Overview => "overview",

            AdminSection::Accounts => "accounts",

            AdminSection::Registration => "registration",

            AdminSection::Organisations => "organisations",

            AdminSection::SignIn => "signin",

            AdminSection::SecurityContact => "security",

            AdminSection::Mail => "mail",

            AdminSection::Runners => "runners",

            AdminSection::Images => "images",

            AdminSection::RunnerSettings => "runner-settings",

            AdminSection::RunnerUpdates => "runner-updates",

            AdminSection::Insights => "insights",

            AdminSection::Variables => "variables",

            AdminSection::Secrets => "secrets",

            AdminSection::Assistants => "assistants",

            AdminSection::Diffusion => "diffusion",

            AdminSection::Storage => "storage",

            AdminSection::Backups => "backups",

            AdminSection::NewRepositories => "repositories",

            AdminSection::Audit => "audit",

        }

    }

    pub fn title(self) -> &'static str {

        match self {

            AdminSection::Overview => "Overview",

            AdminSection::Accounts => "Accounts",

            AdminSection::Registration => "Registration & invitations",

            AdminSection::Organisations => "Organisations",

            AdminSection::SignIn => "Sign in with",

            AdminSection::SecurityContact => "Security contact",

            AdminSection::Mail => "Mail",

            AdminSection::Runners => "Runners",

            AdminSection::Images => "Images",

            AdminSection::RunnerSettings => "Runner settings",

            AdminSection::RunnerUpdates => "Runner updates",

            AdminSection::Insights => "Insights",

            AdminSection::Variables => "Variables",

            AdminSection::Secrets => "Secrets",

            AdminSection::Assistants => "AI assistants",

            AdminSection::Diffusion => "Diffusion",

            AdminSection::Storage => "Storage & maintenance",

            AdminSection::Backups => "Backups",

            AdminSection::NewRepositories => "New repositories",

            AdminSection::Audit => "Audit log",

        }

    }

    /// The section a page of admin.html shows, by its address.

    fn of_path(path: &str) -> Option<AdminSection> {

        ADMIN_GROUPS.iter().flat_map(|(_, pages)| pages.iter().copied()).find(|s| s.href() == path)

    }

}

#[derive(Template)]

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

pub struct AdminPage {

    shell: Shell,

    /// The page shown (oxygenhub#288).

    section: AdminSection,

    accounts: Vec<accounts::Account>,

    orgs: Vec<accounts::Organisation>,

    mode: String,

    invitations: Vec<(String, Option<i64>, i64)>,

    /// New repositories' default bookmark across the site (#371); empty, `main`.

    site_bookmark: String,

    audit: Vec<accounts::AuditRow>,

    repos: usize,

    notice: Option<String>,

    /// Mail settings (#101): the SMTP URL with its password masked, the

    /// From address, whether mail is on, and the administrator's own

    /// address for a test message.

    mail_smtp: String,

    mail_from: String,

    mail_enabled: bool,

    /// The saved mail settings as the panel shows them (oxygenhub#181).

    mail: crate::mail::Choice,

    my_email: String,

    /// The audit log's next page: rows older than this id (#110).

    audit_older: Option<i64>,

    /// The site's AI assistants and prompt (#97).

    assistants: super::assistants::Panel,

    /// The site's Flow variables (#102).

    variables: super::variables::Panel,

    /// The site's Flow secrets (#107).

    secrets: super::secrets::Panel,

    /// Sign-in providers (#106).

    providers: Vec<super::signin::ProviderView>,

    /// The security.txt contact and policy (oxygenhub#224).

    security_contact: String,

    security_policy: String,

    /// The /security-contact page's address and text (oxygenhub#230).

    security_email: String,

    security_page: String,

    security_default: &'static str,

}

pub(super) 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(super) async fn admin_page(

    app: &Shared,

    shell: Shell,

    section: AdminSection,

    notice: Option<String>,

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

    admin_page_at(app, shell, section, notice, None).await

}

/// The audit log shows this many rows a page.

const AUDIT_PAGE: i64 = 50;

async fn admin_page_at(

    app: &Shared,

    shell: Shell,

    section: AdminSection,

    notice: Option<String>,

    audit_before: Option<i64>,

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

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

    let accounts_list = accounts::accounts(&app.db).await.map_err(e)?;

    let orgs = accounts::orgs(&app.db).await.map_err(e)?;

    let mode = super::session::registration_mode(app).await;

    let invitations = accounts::invitations(&app.db).await.map_err(e)?;

    let site_bookmark =

        crate::repo_setup::bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Site).await.map_err(e)?.unwrap_or_default();

    let mut audit = accounts::audit_page(&app.db, audit_before, AUDIT_PAGE + 1).await.map_err(e)?;

    let audit_older = if audit.len() as i64 > AUDIT_PAGE {

        audit.truncate(AUDIT_PAGE as usize);

        audit.last().map(|r| r.id)

    } else {

        None

    };

    let repos = crate::db::repos::list(&app.db).await.map_err(e)?.len();

    let mail = crate::mail::settings(app);

    let my_email = match shell.user.as_deref() {

        Some(u) => accounts::account_by_name(&app.db, u).await.map_err(e)?.map(|a| a.email).unwrap_or_default(),

        None => String::new(),

    };

    let assistants = super::assistants::panel(app, &site_assistants()).await.map_err(e)?;

    let variables = super::variables::panel(app, &site_assistants()).await.map_err(e)?;

    let secrets = super::secrets::panel(app, &site_assistants()).await.map_err(e)?;

    let providers = super::signin::provider_views(app).await.map_err(e)?;

    let (security_contact, security_policy) = super::security_txt::settings(app).await;

    let (security_email, security_page) = super::security_txt::page_settings(app).await;

    Ok(Page(AdminPage {

        section,

        providers,

        security_contact,

        security_policy,

        security_email,

        security_page,

        security_default: super::security_txt::DEFAULT_PAGE,

        assistants,

        variables,

        secrets,

        shell,

        accounts: accounts_list,

        orgs,

        mode,

        site_bookmark,

        invitations,

        audit,

        repos,

        notice,

        mail: crate::mail::describe(&mail.smtp),

        mail_smtp: crate::mail::masked(&mail.smtp),

        mail_from: mail.from.clone(),

        mail_enabled: !mail.smtp.is_empty() && !mail.from.is_empty(),

        my_email,

        audit_older,

    }))

}

impl AdminPage {

    fn mail_services(&self) -> &'static [(&'static str, &'static str)] {

        crate::mail::SERVICES

    }

}

#[derive(Deserialize)]

pub struct MailForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    smtp: String,

    #[serde(default)]

    from: String,

    /// The panel's service (oxygenhub#181); absent, `smtp` is the URL as

    /// before.

    #[serde(default)]

    service: String,

    #[serde(default)]

    region: String,

    #[serde(default)]

    user: String,

    #[serde(default)]

    secret: String,

    #[serde(default)]

    host: String,

    #[serde(default)]

    port: String,

    #[serde(default)]

    security: String,

}

/// `POST /admin/mail`: the SMTP URL and From address (#101). The URL

/// comes back masked, so a masked value left as it was keeps the stored

/// one; an empty URL turns mail off.

pub async fn set_mail(State(app): State<Shared>, viewer: Viewer, Form(f): Form<MailForm>) -> Result<Page<AdminPage>, Error> {

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

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

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

    let current = crate::mail::settings(&app);

    // A service the panel knows: it makes the SMTP URL (oxygenhub#181).

    let smtp = match f.service.as_str() {

        "off" => String::new(),

        "" | "url" => {

            let smtp = f.smtp.trim();

            if !current.smtp.is_empty() && smtp == crate::mail::masked(&current.smtp) {

                current.smtp.clone()

            } else {

                smtp.to_string()

            }

        }

        _ => {

            let asked = crate::mail::Asked {

                service: f.service.clone(),

                region: f.region.clone(),

                user: f.user.clone(),

                secret: f.secret.trim().to_string(),

                host: f.host.clone(),

                port: f.port.clone(),

                security: f.security.clone(),

            };

            match crate::mail::compose(&asked, &current.smtp) {

                Ok(url) => url,

                Err(why) => return admin_page(&app, shell, AdminSection::Mail, Some(why)).await,

            }

        }

    };

    let from = f.from.trim().to_string();

    if !smtp.is_empty() && !(smtp.starts_with("smtp://") || smtp.starts_with("smtps://") || smtp.starts_with("file://")) {

        return admin_page(

            &app,

            shell,

            AdminSection::Mail,

            Some("The SMTP URL starts with smtp:// or smtps:// (file:///dir writes messages to a directory, for testing).".into()),

        )

        .await;

    }

    if !smtp.is_empty() && from.is_empty() {

        return admin_page(&app, shell, AdminSection::Mail, Some("A From address is needed: OxygenHub <[email protected]>.".into()))

            .await;

    }

    crate::mail::save(&app, &smtp, &from).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "admin.mail", if smtp.is_empty() { "off" } else { "on" }, &from).await.ok();

    admin_page(&app, shell, AdminSection::Mail, Some(if smtp.is_empty() { "Mail is off.".into() } else { "Mail settings saved.".into() }))

        .await

}

/// `POST /admin/mail/test`: a message to the administrator's own address.

pub async fn test_mail(

    State(app): State<Shared>,

    viewer: Viewer,

    Form(f): Form<super::session::CsrfForm>,

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

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

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

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

    if !crate::mail::enabled(&app) {

        return admin_page(&app, shell, AdminSection::Mail, Some("Mail is off; save an SMTP URL and a From address first.".into())).await;

    }

    if me.email.is_empty() {

        return admin_page(&app, shell, AdminSection::Mail, Some("Your account has no email address to send the test to.".into())).await;

    }

    let base = app.config.base_url().to_string();

    let notice = match crate::mail::send_letter(

        &app,

        me.name(),

        &me.email,

        "🧪 Test message",

        "This is a test message from your hub's mail settings. If you can read it, mail works: verification links, password resets and notifications will reach people.",

        Some(crate::mail::Action { label: "Open the hub", url: &base }),

        None,

    )

    .await

    {

        Ok(()) => format!("Sent a test message to {}.", me.email),

        Err(e) => format!("Sending failed: {e}"),

    };

    admin_page(&app, shell, AdminSection::Mail, Some(notice)).await

}

#[derive(Deserialize)]

pub struct IndexQuery {

    audit_before: Option<i64>,

}

pub async fn index(

    State(app): State<Shared>,

    viewer: Viewer,

    axum::extract::Query(q): axum::extract::Query<IndexQuery>,

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

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

    require_admin(&viewer, &shell)?;

    admin_page_at(&app, shell, AdminSection::Overview, None, q.audit_before).await

}

/// `GET /admin/{page}` for the sections admin.html shows (oxygenhub#288):

/// accounts, registration, organisations, sign-in, the security contact,

/// mail, variables, secrets, AI assistants and the audit log.

pub async fn section(

    State(app): State<Shared>,

    viewer: Viewer,

    uri: axum::http::Uri,

    axum::extract::Query(q): axum::extract::Query<IndexQuery>,

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

    let shell = Shell::new(&app, uri.path(), &viewer);

    require_admin(&viewer, &shell)?;

    let section = AdminSection::of_path(uri.path()).ok_or_else(|| Error::not_found(shell.clone()))?;

    admin_page_at(&app, shell, section, None, q.audit_before).await

}

#[derive(Deserialize)]

pub struct ModeForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    mode: String,

}

pub async fn set_mode(State(app): State<Shared>, viewer: Viewer, Form(f): Form<ModeForm>) -> Result<Page<AdminPage>, Error> {

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

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

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

    if !matches!(f.mode.as_str(), "open" | "invite" | "closed") {

        return Err(Error::bad(shell, "mode is open, invite or closed"));

    }

    accounts::set_setting(&app.db, "registration_mode", &f.mode).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "admin.registration", &f.mode, "").await.ok();

    admin_page(&app, shell, AdminSection::Registration, Some(format!("Registration is {}.", f.mode))).await

}

#[derive(Deserialize)]

pub struct BookmarkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    default_bookmark: String,

}

/// `POST /admin/repositories` (oxygenhub#371): the default bookmark of new

/// repositories whose owner has not chosen one; empty, `main`.

pub async fn set_bookmark(State(app): State<Shared>, viewer: Viewer, Form(f): Form<BookmarkForm>) -> Result<Page<AdminPage>, Error> {

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

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

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

    let scope = crate::repo_setup::BookmarkScope::Site;

    if let Err(m) = crate::repo_setup::set_bookmark_setting(&app.db, scope, &f.default_bookmark).await {

        return Err(Error::bad(shell, &m));

    }

    let b = f.default_bookmark.trim();

    accounts::audit(&app.db, Some(&me), "admin.default_bookmark", b, "").await.ok();

    let b = if b.is_empty() { crate::repo_setup::MAIN } else { b };

    admin_page(

        &app,

        shell,

        AdminSection::NewRepositories,

        Some(format!("New repositories start on {b} unless their owner chooses another.")),

    )

    .await

}

pub async fn invite(State(app): State<Shared>, viewer: Viewer, Form(f): Form<super::session::CsrfForm>) -> Result<Page<AdminPage>, Error> {

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

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

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

    let code = auth::random_hex(12);

    accounts::create_invitation(&app.db, &code, Some(me.id)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "admin.invite", &code, "").await.ok();

    admin_page(

        &app,

        shell,

        AdminSection::Registration,

        Some(format!("Invitation created: {}/register?invite={code}", app.config.base_url())),

    )

    .await

}

#[derive(Deserialize)]

pub struct AccountForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    username: String,

    action: String,

    /// For delete: the username typed again.

    #[serde(default)]

    confirm: String,

}

pub async fn account(State(app): State<Shared>, viewer: Viewer, Form(f): Form<AccountForm>) -> Result<Page<AdminPage>, Error> {

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

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

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

    let Some(target) = accounts::account_by_name(&app.db, f.username.trim()).await.map_err(|e| Error::from_db(shell.clone(), e))? else {

        return admin_page(&app, shell, AdminSection::Accounts, Some("No such account.".into())).await;

    };

    if target.id == me.id && matches!(f.action.as_str(), "ban" | "demote" | "disable" | "delete") {

        return admin_page(&app, shell, AdminSection::Accounts, Some("Not on yourself.".into())).await;

    }

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

    // The hub must keep an admin who can sign in (oxygenhub#81).

    if target.is_admin && matches!(f.action.as_str(), "disable" | "delete") {

        let others =

            accounts::accounts(&app.db).await.map_err(e)?.into_iter().filter(|a| a.is_admin && !a.blocked() && a.id != target.id).count();