//! Page: GPG keys (`/settings/gpg`). Keys are imported into the forge-managed keyring and stored
//! per user; a signed commit is badged Verified only when its signer's key is listed here.

use forge_core::AuditAction;
use forge_core::store::signatures::GpgKey;
use serde::Deserialize;
use topcoat::Result;
use topcoat::context::{Cx, app_context};
use topcoat::router::content::Form;
use topcoat::router::error::{SeeOther, not_found, see_other};
use topcoat::router::{page, route};
use topcoat::view::{View, component, view};

use crate::audit::{self, Actor, Target};
use crate::auth::{require_csrf, require_user};
use crate::i18n::{self, Key, Lang, added_line, t};
use crate::signatures;
use crate::state::AppState;
use crate::views::{alert, shell, user_facing_message};

#[derive(Deserialize)]
struct AddKeyForm {
    #[serde(default)]
    csrf: String,
    #[serde(default)]
    armored: String,
}

#[derive(Deserialize)]
struct DeleteKeyForm {
    #[serde(default)]
    csrf: String,
    #[serde(default)]
    id: String,
}

#[component]
async fn gpg_view(
    lang: Lang,
    csrf: &str,
    keys: Vec<GpgKey>,
    armored: &str,
    error: Option<String>,
    available: bool,
) -> Result<impl View> {
    Ok(view! {
        <section class="page-head">
            <h1>(t(lang, Key::GpgKeys))</h1>
        </section>
        if !available {
            <p class="notice">(t(lang, Key::GpgUnavailable))</p>
        }
        <section class="card">
            if keys.is_empty() {
                <p class="muted">(t(lang, Key::NoGpgKeys))</p>
            } else {
                <ul class="item-list">
                    for key in keys.into_iter() {
                        <li class="item">
                            <div class="item-main">
                                <code class="small">(key.fingerprint.clone())</code>
                                <span class="muted small">(key.emails.join(", "))</span>
                                <span class="muted small">(added_line(lang, key.created_at.as_str(), None))</span>
                            </div>
                            <form method="post" action="/settings/gpg/delete">
                                <input type="hidden" name="csrf" value=(csrf)>
                                <input type="hidden" name="id" value=(key.id.clone())>
                                <button type="submit" class="danger">(t(lang, Key::Delete))</button>
                            </form>
                        </li>
                    }
                </ul>
            }
        </section>
        <section class="card">
            <h2>(t(lang, Key::AddGpgKeyTitle))</h2>
            if let Some(message) = error {
                alert(message: message.as_str())
            }
            <form method="post" action="/settings/gpg" class="stack">
                <input type="hidden" name="csrf" value=(csrf)>
                <label>
                    <span>(t(lang, Key::ArmoredPublicKeyLabel))</span>
                    <textarea name="armored" rows="10" spellcheck="false" required=(true)>(armored)</textarea>
                    <small class="muted">(t(lang, Key::ArmoredHint))</small>
                </label>
                <button type="submit" class="primary">(t(lang, Key::AddKeyButton))</button>
            </form>
        </section>
    })
}

#[page("/settings/gpg")]
async fn gpg_page(cx: &Cx) -> Result<impl View> {
    let viewer = require_user(cx).await?;
    let lang = i18n::lang(cx, Some(&viewer.0));
    let state = app_context::<AppState>(cx);
    let keys = state.store.list_gpg_keys(&viewer.0.id).await?;
    let available = signatures::gpg_available(state).await;
    let csrf = viewer.1.csrf_token.clone();
    Ok(view! {
        shell(title: t(lang, Key::GpgKeys), viewer: Some(&viewer), gpg_view(lang: lang, csrf: csrf.as_str(), keys: keys, armored: "", error: None, available: available))
    })
}

#[page(POST "/settings/gpg")]
async fn gpg_add(cx: &Cx, Form(form): Form<AddKeyForm>) -> Result<impl View> {
    let viewer = require_csrf(cx, &form.csrf).await?;
    let lang = i18n::lang(cx, Some(&viewer.0));
    let state = app_context::<AppState>(cx);

    let message: String = match signatures::import_gpg_key(state, &form.armored).await {
        Err(message) => message,
        Ok((fingerprint, emails)) => {
            match state
                .store
                .add_gpg_key(&viewer.0.id, &fingerprint, &form.armored, &emails)
                .await
            {
                Ok(key) => {
                    signatures::on_keys_changed(state, &viewer.0.id).await;
                    audit::record(
                        &state.store,
                        Some(cx),
                        Actor::User(&viewer.0),
                        AuditAction::GpgKeyAdded,
                        Target {
                            kind: "gpg_key",
                            id: &key.id,
                            name: &key.fingerprint,
                        },
                        serde_json::Value::Null,
                    )
                    .await;
                    return Err(see_other("/settings/gpg").into());
                }
                Err(e) => match user_facing_message(&e) {
                    Some(message) => message,
                    None => return Err(e.into()),
                },
            }
        }
    };

    let keys = state.store.list_gpg_keys(&viewer.0.id).await?;
    let available = signatures::gpg_available(state).await;
    let csrf = viewer.1.csrf_token.clone();
    Ok(view! {
        shell(title: t(lang, Key::GpgKeys), viewer: Some(&viewer), gpg_view(lang: lang, csrf: csrf.as_str(), keys: keys, armored: form.armored.as_str(), error: Some(message), available: available))
    })
}

#[route(POST "/settings/gpg/delete")]
async fn gpg_delete(cx: &Cx, Form(form): Form<DeleteKeyForm>) -> Result<SeeOther> {
    let (user, _) = require_csrf(cx, &form.csrf).await?;
    let state = app_context::<AppState>(cx);
    // `delete_gpg_key` only matches the viewer's own keys, so anything else is a 404.
    let Some(key) = state.store.delete_gpg_key(&user.id, &form.id).await? else {
        return Err(not_found().into());
    };
    signatures::remove_gpg_key(state, &key.fingerprint).await;
    signatures::on_keys_changed(state, &user.id).await;
    audit::record(
        &state.store,
        Some(cx),
        Actor::User(&user),
        AuditAction::GpgKeyDeleted,
        Target {
            kind: "gpg_key",
            id: &key.id,
            name: &key.fingerprint,
        },
        serde_json::Value::Null,
    )
    .await;
    Ok(see_other("/settings/gpg"))
}