//! The Askama entry point for a described markdown field.
//!
//! Shape 5 of the conversion plan (wiki `mnw-shape-conversion-plans`), and the
//! narrowest of them: one member, [`FieldKind::Rich`], a field whose value is
//! markdown. Autosave and section reordering stay hand-written by ruling, so
//! what moves here is the editor surface and nothing around it.
//!
//! Four templates declared a markdown textarea by hand and one of them wrapped
//! it in a Write/Preview pair it drew itself. All four call this instead, so
//! the box, the pair and the pane come out of the renderer that already ships
//! the CSS for them: `makeover_webview::form` emits the group, and
//! `static/layout.css` carries its `[data-format="markdown"]` rules because
//! `build.rs` generates that file from the same crate.
//!
//! # Why the id is built out of a prefix rather than taken whole
//!
//! `Filling::id_for` is `<prefix>-<name>`, and every one of the four ids these
//! templates already had reads that way: `text-body`, `post-body`,
//! `new-psec-body`, `edit-psec-body`, `new-section-body`. So the field is named
//! `body` on all five, which is what the value is, and the surface supplies the
//! prefix, which is what makes it unique in a document holding two of them.
//!
//! That is not a coincidence being leaned on. It is what keeps the conversion
//! from breaking the thing that reaches these controls by id from outside: each
//! surface's own script reads its value back with `getElementById`, and the id
//! is the same string it was.
//!
//! The described picker addresses its destination by [`Field::name`] rather
//! than by a textarea id, which is what makes [`named`] necessary; see its own
//! note.
//!
//! # Why height is the app's and not the description's
//!
//! The description says nothing about how tall a control is, deliberately, and
//! the four surfaces did not agree anyway: 400px of CSS on the item editor,
//! `rows="20"` on the blog editor, `rows="10"` twice in project settings and
//! `rows="6"` in the wizard. So the fact stays here, as [`Height`], and lands
//! as a class on a wrapper this module owns. Three sizes rather than four
//! because the item editor and the blog editor were already the same surface at
//! two spellings.

use makeover_layout::{Field, FieldKind};
use makeover_webview::{
    Emit,
    form::{Filling, Value, field_html},
};

/// How much room the editor takes before the reader drags it.
///
/// A markdown editor is one surface, so the sizes are named for the room they
/// are given rather than for the screen that gives it. The classes are matched
/// in `css/60-interaction.css`, under `RICH FIELD`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Height {
    /// A few lines, for an editor behind a disclosure the reader opened to add
    /// one row. The wizard's Add Section.
    Compact,
    /// A screenful, for an editor that is one field among several.
    Standard,
    /// The page's main work surface, for a screen that exists to write prose.
    Tall,
}

impl Height {
    /// The wrapper class this size lands as.
    const fn class(self) -> &'static str {
        match self {
            Self::Compact => "rich-field rich-field--compact",
            Self::Standard => "rich-field rich-field--standard",
            Self::Tall => "rich-field rich-field--tall",
        }
    }
}

/// The markup, for an Askama template to drop in.
///
/// `prefix` scopes the control's `id` and must be unique in the document;
/// `label` and `placeholder` are the question and its ghost text; `value` is
/// what the field holds now, escaped by the emitter rather than by the caller.
///
/// The wrapper is this app's and the group inside it is the renderer's, the
/// same division `widgets::carousel` makes for the same reason: a class this
/// host prefixes with nothing and a description that has no idea it exists.
#[must_use]
pub fn html(prefix: &str, label: &str, placeholder: &str, value: &str, height: Height) -> String {
    named(Some(prefix), "body", label, placeholder, value, height)
}

/// The same editor, naming the value itself.
///
/// The rule above ("the name is what the value is, and the id is what tells two
/// editors apart") holds while nothing has to *address* an editor.
/// [`Act::fills`](quasi_router::Act::fills) does: a picker names the
/// box it deposits into by [`Field::name`], because a name is what identifies a
/// field within a description.
///
/// So a document holding two editors under one name has one addressable editor
/// and one unreachable one. `item_details.html` is the measured case and was
/// worse than that: its two section bodies were raw `<textarea>` elements with
/// an id and **no name at all**, which nothing can address. They come through
/// here with names of their own, `new-sec-body` and `edit-sec-body`, and no
/// prefix, so the ids their scripts read by are the strings they always were.
///
/// The four callers of [`html`] are unaffected and stay named `body`: each is
/// the only markdown editor under that name in its document, which is what
/// makes them addressable.
///
/// Passing `None` for the prefix is what makes the name the whole id, and is
/// the only way to give an editor a document-unique name without also changing
/// the id something reads it by.
#[must_use]
pub fn named(
    prefix: Option<&str>,
    name: &str,
    label: &str,
    placeholder: &str,
    value: &str,
    height: Height,
) -> String {
    let mut field = Field::new(FieldKind::Rich, name, label);
    field.placeholder = Some(placeholder);

    let filling = Filling {
        value: Value::Text(value),
        trailing: None,
        // Nothing of this host's own goes on the control. The seam exists for a
        // fact the description does not carry, and quasi's suggestion source is
        // the one caller there is.
        control_attrs: None,
        id_prefix: prefix,
    };

    format!(
        "<div class=\"{}\">{}</div>",
        height.class(),
        field_html(&field, &filling, &Emit::default())
    )
}

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

    /// The id every caller depends on. Three scripts read their value back by
    /// id, so the prefix-plus-`body` arrangement is the contract and not an
    /// implementation detail.
    #[test]
    fn the_prefix_and_the_name_make_the_id_the_templates_already_had() {
        for prefix in ["text", "post", "new-psec", "edit-psec", "new-section"] {
            let html = super::html(prefix, "Body", "Write it", "", Height::Standard);
            assert!(html.contains(&format!("id=\"{prefix}-body\"")), "{html}");
            assert!(html.contains(&format!("for=\"{prefix}-body\"")), "{html}");
        }
    }

    /// The name is the same on all four callers of `html`, because it is what
    /// the value is. Only the id distinguishes two editors in one document,
    /// which is what `Filling::id_prefix` exists to do.
    #[test]
    fn the_name_is_the_value_and_never_the_surface() {
        let html = super::html("new-psec", "Body", "", "", Height::Standard);
        assert!(html.contains("name=\"body\""), "{html}");
        assert!(!html.contains("name=\"new-psec-body\""), "{html}");
    }

    /// And the exception the picker needs: an editor that has to be addressed
    /// by name in a document that holds another one carries a name of its own,
    /// with the id its scripts read by unchanged.
    #[test]
    fn a_named_editor_keeps_the_id_and_gains_a_name_that_tells_it_apart() {
        for name in ["new-sec-body", "edit-sec-body"] {
            let html = super::named(None, name, "Body (Markdown)", "", "", Height::Compact);
            assert!(html.contains(&format!("id=\"{name}\"")), "{html}");
            assert!(html.contains(&format!("name=\"{name}\"")), "{html}");
            assert!(html.contains(&format!("for=\"{name}\"")), "{html}");
        }
    }

    /// The mark and the chrome the binder looks for. Without all three
    /// `markdown-editor.js` finds nothing and the reader is left with the plain
    /// textarea, which is the no-script rendering rather than a failure, so
    /// this is the test that says the enhancement has something to bind to.
    #[test]
    fn the_editor_chrome_is_there_for_the_binder() {
        let html = super::html("text", "Content", "", "", Height::Tall);
        assert!(html.contains(r#"<div data-format="markdown">"#), "{html}");
        assert!(html.contains(r#"data-editor-mode="write""#), "{html}");
        assert!(html.contains(r#"data-editor-mode="preview""#), "{html}");
        assert!(html.contains("data-editor-preview"), "{html}");
    }

    /// The value is the emitter's to escape. Worth a test of its own because
    /// the four templates it replaces escaped through Askama and this one does
    /// not go through Askama at all.
    #[test]
    fn the_value_arrives_escaped() {
        let html = super::html(
            "text",
            "Content",
            "",
            "</textarea><script>x</script>",
            Height::Tall,
        );
        assert!(!html.contains("<script>"), "{html}");
        assert!(html.contains("&lt;/textarea&gt;"), "{html}");
    }

    /// The wizard step, rendered whole. The four surfaces call this module
    /// from Askama, so one of them is rendered here to say that the call site
    /// is wired and that the id survived the conversion; the other three are
    /// the same call with a different prefix.
    #[test]
    fn a_template_call_site_still_carries_the_id_its_script_reads() {
        use askama::Template as _;

        let html = crate::templates::WizardItemSectionsTemplate {
            nav: Vec::new(),
            project_slug: "a-project".into(),
            item_id: "an-item".into(),
            sections: Vec::new(),
        }
        .render()
        .expect("render the sections step");

        assert!(html.contains(r#"id="new-section-body""#), "{html}");
        assert!(html.contains("rich-field--compact"), "{html}");
        assert!(html.contains("data-editor-preview"), "{html}");
    }

    /// Each size is a class of its own, so a stylesheet rule can be missing
    /// rather than silently shared.
    #[test]
    fn every_height_is_its_own_class() {
        for (height, class) in [
            (Height::Compact, "rich-field--compact"),
            (Height::Standard, "rich-field--standard"),
            (Height::Tall, "rich-field--tall"),
        ] {
            let html = super::html("text", "Body", "", "", height);
            assert!(html.contains(class), "{html}");
        }
    }
}