//! Pages for snippets: `/snippets` (list), `/snippets/new`, `/snippets/{id}` (view),
//! `/snippets/{id}/edit`, `/snippets/{id}/revisions` and `POST /snippets/{id}/delete`.
//! Visibility decides who may read: a private snippet answers 404 to everyone but its owner.
//! Only the owner edits or deletes, and every save and delete is audited. Files are served on the
//! user-content origin (see `snippet_raw.rs`), and the page links to them.

use std::collections::HashMap;

use forge_core::store::snippets::{
    MAX_FILES, MAX_TOTAL_BYTES, Snippet, SnippetFile, SnippetRevision, SnippetSummary,
    SnippetVisibility,
};
use forge_core::{AuditAction, Session, User};
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, path_param, route};
use topcoat::view::{Unescaped, View, component, view};

use crate::audit::{self, Actor, Target};
use crate::auth::{current_user, require_csrf, require_user};
use crate::i18n::community::{self as g, K};
use crate::i18n::{self, Lang};
use crate::pages::snippet_raw::snippet_raw_url;
use crate::render::highlight::highlight_lines;
use crate::render::markdown::render_markdown;
use crate::state::AppState;
use crate::views::{alert, shell, user_facing_message};

path_param!(id);

/// What the form shows for one file slot.
struct Slot {
    number: usize,
    name: String,
    content: String,
}

/// The editable state of a snippet, as typed or as saved.
#[derive(Clone, Default)]
struct Draft {
    title: String,
    description: String,
    visibility: String,
    /// Each file with the number of its form fields (`name_<n>`, `content_<n>`). The number stays
    /// with the file when another is added or removed: the browser restores typed text by field
    /// name, so a renumbered card would get the wrong text back.
    files: Vec<(usize, SnippetFile)>,
}

impl Draft {
    fn blank() -> Self {
        Draft {
            visibility: SnippetVisibility::Private.as_str().to_owned(),
            ..Draft::default()
        }
    }

    fn from_snippet(snippet: &Snippet) -> Self {
        Draft {
            title: snippet.title.clone(),
            description: snippet.description.clone(),
            visibility: snippet.visibility.as_str().to_owned(),
            files: snippet.files.iter().cloned().enumerate().collect(),
        }
    }

    /// Reads the form. Every card the page rendered is kept, blank ones too, so "Add file" never
    /// takes a card away; blank cards are dropped only when saving (see `saved_files`).
    fn from_form(form: &HashMap<String, String>) -> Self {
        let field = |key: String| form.get(&key).cloned().unwrap_or_default();
        let mut files = Vec::new();
        for number in 0..MAX_FILES {
            if !form.contains_key(&format!("name_{number}")) {
                continue;
            }
            let name = field(format!("name_{number}")).trim().to_owned();
            let content = field(format!("content_{number}")).replace("\r\n", "\n");
            files.push((number, SnippetFile { name, content }));
        }
        Draft {
            title: field("title".into()),
            description: field("description".into()),
            visibility: field("visibility".into()),
            files,
        }
    }

    /// The files to save: cards with neither a name nor contents are dropped.
    fn saved_files(&self) -> Vec<SnippetFile> {
        self.files
            .iter()
            .map(|(_, file)| file)
            .filter(|file| !(file.name.is_empty() && file.content.trim().is_empty()))
            .cloned()
            .collect()
    }

    /// Drops the card whose fields are `number`. Other cards keep their numbers.
    fn remove(&mut self, number: usize) {
        self.files.retain(|(n, _)| *n != number);
    }

    /// The position of the file whose fields are `number`, if there is one.
    fn position(&self, number: usize) -> Option<usize> {
        self.files.iter().position(|(n, _)| *n == number)
    }

    /// Adds an empty card under the lowest free field number, unless the snippet is full.
    fn add_blank(&mut self) {
        if self.files.len() >= MAX_FILES {
            return;
        }
        let free = (0..MAX_FILES).find(|n| self.files.iter().all(|(m, _)| m != n));
        if let Some(number) = free {
            let file = SnippetFile {
                name: String::new(),
                content: String::new(),
            };
            self.files.push((number, file));
        }
    }

    /// The cards to render: one per file, or one empty card for a new snippet.
    fn slots(&self) -> Vec<Slot> {
        if self.files.is_empty() {
            return vec![Slot {
                number: 0,
                name: String::new(),
                content: String::new(),
            }];
        }
        self.files
            .iter()
            .map(|(number, file)| {
                // A browser drops one newline right after <textarea>, so keep a leading one.
                let content = if file.content.starts_with('\n') {
                    format!("\n{}", file.content)
                } else {
                    file.content.clone()
                };
                Slot {
                    number: *number,
                    name: file.name.clone(),
                    content,
                }
            })
            .collect()
    }
}

/// Applies an "Add file" or "Remove file" click to the draft. Returns the tab to show next, or
/// None for a save, which leaves the draft as typed. Adding shows the new last file; removing
/// shows the file before the removed one.
fn apply_slot_step(draft: &mut Draft, form: &HashMap<String, String>) -> Option<usize> {
    if form.get("op").map(String::as_str) == Some("add") {
        draft.add_blank();
        Some(draft.files.len().saturating_sub(1))
    } else if let Some(number) = form.get("remove") {
        let number: usize = number.parse().unwrap_or(usize::MAX);
        let position = draft.position(number).unwrap_or(0);
        draft.remove(number);
        Some(position.saturating_sub(1))
    } else {
        None
    }
}

/// The tab that was checked when a save failed, so the user stays on the file they were editing.
fn posted_tab(draft: &Draft, form: &HashMap<String, String>) -> usize {
    form.get("tab")
        .and_then(|tab| tab.parse().ok())
        .and_then(|number| draft.position(number))
        .unwrap_or(0)
}

/// One file as the view page shows it. `body` is trusted HTML when `markdown` or `highlighted`
/// is set, and plain text otherwise.
struct FileView {
    name: String,
    raw: String,
    markdown: bool,
    highlighted: bool,
    body: String,
}

/// One revision as the history page shows it.
struct RevisionView {
    number: usize,
    author: String,
    at: String,
    file_names: String,
}

/// One row of the list page.
struct ListRow {
    id: String,
    title: String,
    owner: String,
    visibility: &'static str,
    /// The file count and the last update, as one line.
    meta: String,
}

fn visibility_label(lang: Lang, visibility: SnippetVisibility) -> &'static str {
    match visibility {
        SnippetVisibility::Public => g::t(lang, K::VisibilityPublic),
        SnippetVisibility::Unlisted => g::t(lang, K::VisibilityUnlisted),
        SnippetVisibility::Private => g::t(lang, K::VisibilityPrivate),
    }
}

fn extension(name: &str) -> String {
    name.rsplit_once('.')
        .map(|(_, ext)| ext.to_ascii_lowercase())
        .unwrap_or_default()
}

fn file_view(state: &AppState, snippet: &Snippet, file: &SnippetFile) -> FileView {
    let markdown = matches!(extension(&file.name).as_str(), "md" | "markdown");
    let (body, highlighted) = if markdown {
        (render_markdown(&file.content, None), false)
    } else {
        match highlight_lines(&file.name, &file.content) {
            Some(lines) => (lines.join("\n"), true),
            None => (file.content.clone(), false),
        }
    };
    FileView {
        name: file.name.clone(),
        raw: snippet_raw_url(state, snippet, &file.name),
        markdown,
        highlighted,
        body,
    }
}

/// The snippet if the viewer may read it, else 404.
async fn readable(cx: &Cx, viewer_id: Option<&str>, snippet_id: &str) -> Result<Snippet> {
    let store = &app_context::<AppState>(cx).store;
    match store.get_snippet(snippet_id).await? {
        Some(snippet) if snippet.is_visible_to(viewer_id) => Ok(snippet),
        _ => Err(not_found().into()),
    }
}

/// The snippet if the user owns it, else 404. Edits and deletes go through this check.
async fn owned(cx: &Cx, user: &User, snippet_id: &str) -> Result<Snippet> {
    let store = &app_context::<AppState>(cx).store;
    match store.get_snippet(snippet_id).await? {
        Some(snippet) if snippet.owner_id == user.id => Ok(snippet),
        _ => Err(not_found().into()),
    }
}

#[component]
async fn snippet_list_body(lang: Lang, rows: Vec<ListRow>, signed_in: bool) -> Result<impl View> {
    Ok(view! {
        <section class="page-head">
            <h1>(g::t(lang, K::Snippets))</h1>
            if signed_in {
                <a class="button primary" href="/snippets/new">(g::t(lang, K::NewSnippet))</a>
            }
        </section>
        <section class="card">
            if rows.is_empty() {
                <p class="muted">(g::t(lang, K::NoSnippets))</p>
            } else {
                <ul class="item-list snippet-list">
                    for row in rows.into_iter() {
                        <li class="item">
                            <div class="item-main">
                                <a href=(format!("/snippets/{}", row.id))><strong>(row.title)</strong></a>
                                <span class="muted small">
                                    (row.owner) " · " (row.visibility) " · " (row.meta)
                                </span>
                            </div>
                        </li>
                    }
                </ul>
            }
        </section>
    })
}

/// The files card: a tab strip with one tab per file and the "Add file" tab at its end, then one
/// panel per file. Every panel stays in the form so all fields submit; CSS shows only the panel
/// of the checked tab. A tab is a radio plus a label, so the strip works with JavaScript off.
/// The panel's remove button is shown only when there is more than one file.
#[component]
async fn snippet_files(
    lang: Lang,
    slots: Vec<Slot>,
    active: usize,
    removable: bool,
    can_add: bool,
    counter: String,
) -> Result<impl View> {
    let blanks = slots.iter().filter(|s| s.name.trim().is_empty()).count();
    let tabs: Vec<(usize, String, bool)> = slots
        .iter()
        .enumerate()
        .map(|(index, slot)| {
            let label = if slot.name.trim().is_empty() {
                let untitled = g::t(lang, K::Untitled);
                if blanks > 1 {
                    format!("{untitled} {}", index + 1)
                } else {
                    untitled.to_owned()
                }
            } else {
                slot.name.clone()
            };
            (slot.number, label, index == active)
        })
        .collect();
    Ok(view! {
        <div class="snippet-files">
            <div class="snippet-tabbar">
                <div class="snippet-tabs" role="group" aria-label=(g::t(lang, K::Files))>
                    for (number, label, checked) in tabs.into_iter() {
                        <input type="radio" class="snippet-tab-radio" id=(format!("snippet-tab-{number}"))
                            name="tab" value=(number.to_string()) checked=(checked)>
                        <label class="snippet-tab" for=(format!("snippet-tab-{number}"))>(label)</label>
                    }
                    if can_add {
                        <button type="submit" class="ghost snippet-tab-add" name="op" value="add" formnovalidate=(true)
                            title=(g::t(lang, K::AddFile)) aria-label=(g::t(lang, K::AddFile))>
                            <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M12 5v14M5 12h14"/></svg>
                        </button>
                    }
                </div>
                <span class="snippet-count muted small">(counter)</span>
            </div>
            for (index, slot) in slots.into_iter().enumerate() {
                <fieldset class=(format!("snippet-panel snippet-panel-{}", slot.number))>
                    <legend class="sr-only">(g::t(lang, K::FileLabel))(index + 1)</legend>
                    <div class="snippet-slot-head">
                        <svg class="ico" viewBox="0 0 24 24" aria-hidden="true"><path d="M14 3H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z"/><path d="M14 3v6h6"/></svg>
                        <input type="text" class="snippet-name" name=(format!("name_{}", slot.number)) value=(slot.name)
                            maxlength="100" placeholder=(g::t(lang, K::FileNamePlaceholder)) aria-label=(g::t(lang, K::FileName))>
                        if removable {
                            <button type="submit" class="ghost snippet-remove" name="remove" value=(slot.number.to_string())
                                formnovalidate=(true) title=(g::t(lang, K::RemoveFile)) aria-label=(g::t(lang, K::RemoveFile))>
                                <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M18 6 6 18M6 6l12 12"/></svg>
                            </button>
                        }
                    </div>
                    <textarea class="code snippet-content" name=(format!("content_{}", slot.number))
                        spellcheck="false" aria-label=(g::t(lang, K::FileContents))>(slot.content)</textarea>
                </fieldset>
            }
        </div>
    })
}

/// The new and edit form. Save is the first submit button, so Enter in a field saves; "Add file"
/// and the remove buttons submit the same form with `formnovalidate` and never save.
#[component]
async fn snippet_form(
    lang: Lang,
    csrf: &str,
    action: &str,
    heading: &str,
    title: &str,
    description: &str,
    visibility: &str,
    slots: Vec<Slot>,
    active: usize,
    error: Option<String>,
) -> Result<impl View> {
    let public = visibility == "public";
    let unlisted = visibility == "unlisted";
    let private = visibility == "private";
    let removable = slots.len() > 1;
    let can_add = slots.len() < MAX_FILES;
    let counter = g::files_limit(
        lang,
        slots.len(),
        MAX_FILES,
        MAX_TOTAL_BYTES / (1024 * 1024),
    );
    Ok(view! {
        if let Some(message) = error {
            alert(message: message.as_str())
        }
        <form method="post" action=(action) class="snippet-form">
            <input type="hidden" name="csrf" value=(csrf)>
            <header class="snippet-head">
                <h1>(heading)</h1>
                <div class="snippet-head-actions">
                    <fieldset class="snippet-visibility">
                        <legend class="sr-only">(g::t(lang, K::Visibility))</legend>
                        <div class="segmented snippet-segmented">
                            <label class="segment" title=(g::t(lang, K::PublicOption))>
                                <input type="radio" name="visibility" value="public" checked=(public)>
                                <svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="12" cy="12" r="9"/><path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18"/></svg>
                                <span>(g::t(lang, K::VisibilityPublic))</span>
                            </label>
                            <label class="segment" title=(g::t(lang, K::UnlistedOption))>
                                <input type="radio" name="visibility" value="unlisted" checked=(unlisted)>
                                <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M10 13a5 5 0 0 0 7.5.5l3-3a5 5 0 0 0-7-7l-1.7 1.7"/><path d="M14 11a5 5 0 0 0-7.5-.5l-3 3a5 5 0 0 0 7 7l1.7-1.7"/></svg>
                                <span>(g::t(lang, K::VisibilityUnlisted))</span>
                            </label>
                            <label class="segment" title=(g::t(lang, K::PrivateOption))>
                                <input type="radio" name="visibility" value="private" checked=(private)>
                                <svg viewBox="0 0 24 24" aria-hidden="true"><rect x="5" y="11" width="14" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></svg>
                                <span>(g::t(lang, K::VisibilityPrivate))</span>
                            </label>
                        </div>
                    </fieldset>
                    <button type="submit" class="primary">(g::t(lang, K::SaveSnippet))</button>
                </div>
            </header>
            <div class="snippet-doc">
                <div class="snippet-meta">
                    <input type="text" class="snippet-title" name="title" value=(title) maxlength="120" required=(true)
                        placeholder=(g::t(lang, K::SnippetTitlePlaceholder)) aria-label=(g::t(lang, K::Title))>
                    <input type="text" class="snippet-desc" name="description" value=(description) maxlength="1000"
                        placeholder=(g::t(lang, K::DescriptionOptional)) aria-label=(g::t(lang, K::Description))>
                </div>
                snippet_files(lang: lang, slots: slots, active: active, removable: removable, can_add: can_add,
                    counter: counter)
            </div>
        </form>
    })
}

#[component]
async fn snippet_body(
    lang: Lang,
    snippet_id: &str,
    title: &str,
    owner: &str,
    description: &str,
    visibility: &'static str,
    updated: &str,
    files: Vec<FileView>,
    owner_csrf: Option<String>,
) -> Result<impl View> {
    let is_owner = owner_csrf.is_some();
    let edit_href = format!("/snippets/{snippet_id}/edit");
    let history_href = format!("/snippets/{snippet_id}/revisions");
    let delete_action = format!("/snippets/{snippet_id}/delete");
    Ok(view! {
        <section class="page-head">
            <h1>(title)</h1>
            <span class="muted small">(owner) " · " (visibility) " · " (g::updated_on(lang, updated))</span>
        </section>
        if !description.is_empty() {
            <p class="snippet-description">(description)</p>
        }
        <nav class="file-actions" aria-label=(g::t(lang, K::SnippetNav))>
            <a href=(history_href)>(g::t(lang, K::Revisions))</a>
            if let Some(token) = owner_csrf {
                <a href=(edit_href)>(g::t(lang, K::Edit))</a>
                <form method="post" action=(delete_action) class="inline-form">
                    <input type="hidden" name="csrf" value=(token.as_str())>
                    <button type="submit" class="danger">(g::t(lang, K::Delete))</button>
                </form>
            }
        </nav>
        for file in files.into_iter() {
            <section class="file snippet-file">
                <header class="file-head">
                    <strong>(file.name.clone())</strong>
                    <nav class="file-actions" aria-label=(g::t(lang, K::FileNav))>
                        <a href=(file.raw.clone())>(g::t(lang, K::Raw))</a>
                    </nav>
                </header>
                if file.markdown {
                    <div class="markdown-body">(Unescaped::new_unchecked(file.body.clone()))</div>
                } else if file.highlighted {
                    <pre class="code snippet-code"><code>(Unescaped::new_unchecked(file.body.clone()))</code></pre>
                } else {
                    <pre class="code snippet-code"><code>(file.body.clone())</code></pre>
                }
            </section>
        }
        if !is_owner {
            <p class="muted small">(g::t(lang, K::OnlyOwnerEdits))</p>
        }
    })
}

#[component]
async fn revisions_body(
    lang: Lang,
    snippet_id: &str,
    title: &str,
    revisions: Vec<RevisionView>,
) -> Result<impl View> {
    let back = format!("/snippets/{snippet_id}");
    let heading = g::revisions_of(lang, title);
    Ok(view! {
        <section class="page-head">
            <h1>(heading.as_str())</h1>
            <a href=(back)>(g::t(lang, K::BackToSnippet))</a>
        </section>
        <section class="card">
            if revisions.is_empty() {
                <p class="muted">(g::t(lang, K::NoRevisions))</p>
            } else {
                <ul class="item-list">
                    for rev in revisions.into_iter() {
                        <li class="item">
                            <div class="item-main">
                                <strong>(g::t(lang, K::RevisionLabel))(rev.number)</strong>
                                <span class="muted small">
                                    (rev.author) " · " (rev.at) " · " (rev.file_names)
                                </span>
                            </div>
                        </li>
                    }
                </ul>
            }
        </section>
    })
}

#[component]
async fn snippet_form_page(
    lang: Lang,
    viewer: &(User, Session),
    heading: &str,
    action: &str,
    draft: Draft,
    error: Option<String>,
    active: usize,
) -> Result<impl View> {
    let csrf = viewer.1.csrf_token.clone();
    let slots = draft.slots();
    let title = draft.title.clone();
    let description = draft.description.clone();
    let visibility = draft.visibility.clone();
    Ok(view! {
        shell(title: heading, viewer: Some(viewer),
            snippet_form(lang: lang, csrf: csrf.as_str(), action: action, heading: heading,
                title: title.as_str(), description: description.as_str(),
                visibility: visibility.as_str(), slots: slots, active: active, error: error)
        )
    })
}

#[page("/snippets")]
async fn snippets_list(cx: &Cx) -> Result<impl View> {
    let viewer = current_user(cx).await?;
    let lang = i18n::lang(cx, viewer.as_ref().map(|(user, _)| user));
    let viewer_id = viewer.as_ref().map(|(user, _)| user.id.clone());
    let summaries: Vec<SnippetSummary> = app_context::<AppState>(cx)
        .store
        .list_snippets(viewer_id.as_deref())
        .await?;
    let rows: Vec<ListRow> = summaries
        .into_iter()
        .map(|s| ListRow {
            id: s.id,
            title: s.title,
            owner: s.owner_name,
            visibility: visibility_label(lang, s.visibility),
            meta: g::files_updated(lang, s.file_count, &s.updated_at),
        })
        .collect();
    let signed_in = viewer.is_some();
    let title = g::t(lang, K::Snippets);
    Ok(view! {
        shell(title: title, viewer: viewer.as_ref(),
            snippet_list_body(lang: lang, rows: rows, signed_in: signed_in)
        )
    })
}

#[page("/snippets/new")]
async fn snippet_new(cx: &Cx) -> Result<impl View> {
    let viewer = require_user(cx).await?;
    let lang = i18n::lang(cx, Some(&viewer.0));
    Ok(view! {
        snippet_form_page(lang: lang, viewer: &viewer, heading: g::t(lang, K::NewSnippet), action: "/snippets/new",
            draft: Draft::blank(), error: None, active: 0)
    })
}

#[page(POST "/snippets/new")]
async fn snippet_create(cx: &Cx, Form(form): Form<HashMap<String, String>>) -> Result<impl View> {
    let (user, _) = require_csrf(cx, form.get("csrf").map_or("", String::as_str)).await?;
    let lang = i18n::lang(cx, Some(&user));
    let mut draft = Draft::from_form(&form);
    let mut error = None;
    let step = apply_slot_step(&mut draft, &form);
    if step.is_none() {
        let store = &app_context::<AppState>(cx).store;
        let files = draft.saved_files();
        let saved = match SnippetVisibility::parse(&draft.visibility) {
            None => Err(g::t(lang, K::ChooseVisibility).to_owned()),
            Some(visibility) => match store
                .create_snippet(
                    &user.id,
                    &draft.title,
                    &draft.description,
                    visibility,
                    &files,
                )
                .await
            {
                Ok(snippet) => Ok(snippet),
                Err(e) => match user_facing_message(&e) {
                    Some(message) => Err(message),
                    None => return Err(e.into()),
                },
            },
        };
        match saved {
            Ok(snippet) => {
                audit::record(
                    store,
                    Some(cx),
                    Actor::User(&user),
                    AuditAction::SnippetCreated,
                    Target {
                        kind: "snippet",
                        id: &snippet.id,
                        name: &snippet.title,
                    },
                    serde_json::Value::Null,
                )
                .await;
                return Err(see_other(format!("/snippets/{}", snippet.id)).into());
            }
            Err(message) => error = Some(message),
        }
    }
    let active = step.unwrap_or_else(|| posted_tab(&draft, &form));
    let viewer = require_user(cx).await?;
    Ok(view! {
        snippet_form_page(lang: lang, viewer: &viewer, heading: g::t(lang, K::NewSnippet), action: "/snippets/new",
            draft: draft, error: error, active: active)
    })
}

#[page("/snippets/{id}")]
async fn snippet_view(cx: &Cx) -> Result<impl View> {
    let snippet_id = path_param::<Id>(cx).to_owned();
    let viewer = current_user(cx).await?;
    let lang = i18n::lang(cx, viewer.as_ref().map(|(user, _)| user));
    let viewer_id = viewer.as_ref().map(|(user, _)| user.id.clone());
    let snippet = readable(cx, viewer_id.as_deref(), &snippet_id).await?;
    let state = app_context::<AppState>(cx);
    let files: Vec<FileView> = snippet
        .files
        .iter()
        .map(|file| file_view(state, &snippet, file))
        .collect();
    let owner_csrf = match &viewer {
        Some((user, session)) if user.id == snippet.owner_id => Some(session.csrf_token.clone()),
        _ => None,
    };
    let updated = snippet.updated_at.clone();
    let visibility = visibility_label(lang, snippet.visibility);
    Ok(view! {
        shell(title: snippet.title.as_str(), viewer: viewer.as_ref(),
            snippet_body(lang: lang, snippet_id: snippet.id.as_str(), title: snippet.title.as_str(),
                owner: snippet.owner_name.as_str(), description: snippet.description.as_str(),
                visibility: visibility, updated: updated.as_str(), files: files,
                owner_csrf: owner_csrf)
        )
    })
}

#[page("/snippets/{id}/edit")]
async fn snippet_edit(cx: &Cx) -> Result<impl View> {
    let snippet_id = path_param::<Id>(cx).to_owned();
    let viewer = require_user(cx).await?;
    let lang = i18n::lang(cx, Some(&viewer.0));
    let snippet = owned(cx, &viewer.0, &snippet_id).await?;
    let action = format!("/snippets/{snippet_id}/edit");
    let draft = Draft::from_snippet(&snippet);
    Ok(view! {
        snippet_form_page(lang: lang, viewer: &viewer, heading: g::t(lang, K::EditSnippet), action: action.as_str(),
            draft: draft, error: None, active: 0)
    })
}

#[page(POST "/snippets/{id}/edit")]
async fn snippet_update(cx: &Cx, Form(form): Form<HashMap<String, String>>) -> Result<impl View> {
    let snippet_id = path_param::<Id>(cx).to_owned();
    let (user, _) = require_csrf(cx, form.get("csrf").map_or("", String::as_str)).await?;
    let lang = i18n::lang(cx, Some(&user));
    owned(cx, &user, &snippet_id).await?;
    let mut draft = Draft::from_form(&form);
    let mut error = None;
    let step = apply_slot_step(&mut draft, &form);
    if step.is_none() {
        let store = &app_context::<AppState>(cx).store;
        let files = draft.saved_files();
        let saved = match SnippetVisibility::parse(&draft.visibility) {
            None => Err(g::t(lang, K::ChooseVisibility).to_owned()),
            Some(visibility) => match store
                .update_snippet(
                    &user.id,
                    &snippet_id,
                    &draft.title,
                    &draft.description,
                    visibility,
                    &files,
                )
                .await
            {
                Ok(snippet) => Ok(snippet),
                Err(e) => match user_facing_message(&e) {
                    Some(message) => Err(message),
                    None => return Err(e.into()),
                },
            },
        };
        match saved {
            Ok(snippet) => {
                audit::record(
                    store,
                    Some(cx),
                    Actor::User(&user),
                    AuditAction::SnippetUpdated,
                    Target {
                        kind: "snippet",
                        id: &snippet.id,
                        name: &snippet.title,
                    },
                    serde_json::Value::Null,
                )
                .await;
                return Err(see_other(format!("/snippets/{}", snippet.id)).into());
            }
            Err(message) => error = Some(message),
        }
    }
    let active = step.unwrap_or_else(|| posted_tab(&draft, &form));
    let viewer = require_user(cx).await?;
    let action = format!("/snippets/{snippet_id}/edit");
    Ok(view! {
        snippet_form_page(lang: lang, viewer: &viewer, heading: g::t(lang, K::EditSnippet), action: action.as_str(),
            draft: draft, error: error, active: active)
    })
}

#[page("/snippets/{id}/revisions")]
async fn snippet_revisions(cx: &Cx) -> Result<impl View> {
    let snippet_id = path_param::<Id>(cx).to_owned();
    let viewer = current_user(cx).await?;
    let viewer_id = viewer.as_ref().map(|(user, _)| user.id.clone());
    let snippet = readable(cx, viewer_id.as_deref(), &snippet_id).await?;
    let lang = i18n::lang(cx, viewer.as_ref().map(|(user, _)| user));
    let store = &app_context::<AppState>(cx).store;
    let revisions: Vec<SnippetRevision> = store.list_snippet_revisions(&snippet.id).await?;
    // Stored oldest first; the page shows the newest first with its number.
    let rows: Vec<RevisionView> = revisions
        .into_iter()
        .enumerate()
        .map(|(index, rev)| RevisionView {
            number: index + 1,
            author: rev.author_name,
            at: rev.created_at,
            file_names: rev
                .files
                .iter()
                .map(|f| f.name.as_str())
                .collect::<Vec<_>>()
                .join(", "),
        })
        .rev()
        .collect();
    Ok(view! {
        shell(title: snippet.title.as_str(), viewer: viewer.as_ref(),
            revisions_body(lang: lang, snippet_id: snippet.id.as_str(), title: snippet.title.as_str(),
                revisions: rows)
        )
    })
}

#[route(POST "/snippets/{id}/delete")]
async fn snippet_delete(cx: &Cx, Form(form): Form<HashMap<String, String>>) -> Result<SeeOther> {
    let snippet_id = path_param::<Id>(cx).to_owned();
    let (user, _) = require_csrf(cx, form.get("csrf").map_or("", String::as_str)).await?;
    let snippet = owned(cx, &user, &snippet_id).await?;
    let store = &app_context::<AppState>(cx).store;
    if store.delete_snippet(&user.id, &snippet.id).await? {
        audit::record(
            store,
            Some(cx),
            Actor::User(&user),
            AuditAction::SnippetDeleted,
            Target {
                kind: "snippet",
                id: &snippet.id,
                name: &snippet.title,
            },
            serde_json::Value::Null,
        )
        .await;
    }
    Ok(see_other("/snippets"))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn form(pairs: &[(&str, &str)]) -> HashMap<String, String> {
        pairs
            .iter()
            .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
            .collect()
    }

    #[test]
    fn blank_cards_are_dropped_only_on_save() {
        let draft = Draft::from_form(&form(&[
            ("title", "t"),
            ("visibility", "public"),
            ("name_0", "a.txt"),
            ("content_0", "one\r\ntwo"),
            ("name_1", ""),
            ("content_1", "   "),
            ("name_2", "b.rs"),
            ("content_2", ""),
        ]));
        assert_eq!(
            draft.files.len(),
            3,
            "every rendered card is kept while editing"
        );
        let saved = draft.saved_files();
        assert_eq!(saved.len(), 2);
        assert_eq!(saved[0].content, "one\ntwo");
        assert_eq!(saved[1].name, "b.rs");
    }

    #[test]
    fn new_form_shows_one_empty_card() {
        let draft = Draft::blank();
        let slots = draft.slots();
        assert_eq!(slots.len(), 1);
        assert_eq!((slots[0].number, slots[0].name.as_str()), (0, ""));
    }

    #[test]
    fn add_appends_a_card_until_the_snippet_is_full() {
        let mut draft = Draft::blank();
        for _ in 0..MAX_FILES + 3 {
            draft.add_blank();
        }
        assert_eq!(draft.slots().len(), MAX_FILES);
        let numbers: Vec<usize> = draft.slots().iter().map(|s| s.number).collect();
        assert_eq!(numbers, (0..MAX_FILES).collect::<Vec<_>>());
    }

    #[test]
    fn remove_keeps_the_other_field_numbers() {
        let mut draft = Draft::blank();
        draft.add_blank();
        draft.add_blank();
        draft.add_blank();
        draft.files[1].1.name = "b.txt".into();
        draft.remove(0);
        let numbers: Vec<usize> = draft.slots().iter().map(|s| s.number).collect();
        assert_eq!(numbers, vec![1, 2]);
        assert_eq!(draft.slots()[0].name, "b.txt");
    }

    #[test]
    fn add_and_remove_clicks_are_told_apart_from_a_save() {
        let add = form(&[("op", "add"), ("name_0", "a")]);
        let mut draft = Draft::from_form(&add);
        assert_eq!(apply_slot_step(&mut draft, &add), Some(1));
        assert_eq!(draft.slots().len(), 2);
        let remove = form(&[("remove", "1"), ("name_0", "a"), ("name_1", "")]);
        let mut draft = Draft::from_form(&remove);
        assert_eq!(apply_slot_step(&mut draft, &remove), Some(0));
        assert_eq!(draft.slots().len(), 1);
        assert_eq!(
            apply_slot_step(&mut Draft::blank(), &form(&[("title", "t")])),
            None
        );
    }

    #[test]
    fn add_shows_the_new_last_file() {
        let mut draft = Draft::blank();
        let add = form(&[("op", "add"), ("name_0", "a")]);
        assert_eq!(apply_slot_step(&mut draft, &add), Some(0));
        assert_eq!(apply_slot_step(&mut draft, &add), Some(1));
        assert_eq!(draft.slots().len(), 2);
    }

    #[test]
    fn remove_shows_the_file_before_the_removed_one() {
        let mut draft = Draft::blank();
        for _ in 0..3 {
            draft.add_blank();
        }
        // Files 0..=2 at positions 0..=2; removing the file at position 2 shows position 1.
        let remove = form(&[("remove", "2")]);
        assert_eq!(apply_slot_step(&mut draft, &remove), Some(1));
        // Removing the first file shows the new first one.
        let remove = form(&[("remove", "0")]);
        assert_eq!(apply_slot_step(&mut draft, &remove), Some(0));
    }

    #[test]
    fn a_failed_save_keeps_the_posted_tab() {
        let mut draft = Draft::blank();
        for _ in 0..3 {
            draft.add_blank();
        }
        let numbers: Vec<usize> = draft.slots().iter().map(|s| s.number).collect();
        assert_eq!(numbers, vec![0, 1, 2]);
        assert_eq!(posted_tab(&draft, &form(&[("tab", "2")])), 2);
        assert_eq!(posted_tab(&draft, &form(&[("tab", "9")])), 0);
        assert_eq!(posted_tab(&draft, &form(&[])), 0);
    }

    #[test]
    fn leading_newline_survives_the_textarea() {
        let mut draft = Draft::blank();
        draft.files = vec![(
            0,
            SnippetFile {
                name: "a".into(),
                content: "\nx".into(),
            },
        )];
        assert_eq!(draft.slots()[0].content, "\n\nx");
    }
}