//! Wiki pages on the web (hub spec §6.11, oxygenhub#104): view, edit,

//! history, the page list with search, and raw files for images.

use super::{filters, lookup, lookup_role, Error, Page, RepoShell, Shell};

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

use crate::db::accounts;

use crate::repos::view::ChangeView;

use crate::wiki;

use crate::Shared;

use askama::Template;

use axum::extract::{Path, Query, State};

use axum::response::{IntoResponse, Redirect, Response};

use axum::Form;

use serde::Deserialize;

#[derive(Template)]

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

pub struct WikiPage {

    shell: Shell,

    repo: RepoShell,

    slug: String,

    title: String,

    /// Rendered Markdown, or `None` when there is no such page.

    html: Option<String>,

    sidebar: Option<String>,

    /// Whether the wiki has any page at all.

    any: bool,

    can_edit: bool,

    last: Option<ChangeView>,

    notice: Option<String>,

    /// Every page's slug, for the side bar (#194).

    pages: Vec<String>,

    /// How many changes touched this page.

    revisions: usize,

    /// The page's headings: (level, text, id).

    toc: Vec<(u8, String, String)>,

}

#[derive(Template)]

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

pub struct WikiEditPage {

    shell: Shell,

    repo: RepoShell,

    slug: String,

    title: String,

    content: String,

    /// Whether the page exists (an edit) or is new.

    exists: bool,

    error: Option<String>,

}

#[derive(Template)]

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

pub struct WikiPagesPage {

    shell: Shell,

    repo: RepoShell,

    pages: Vec<String>,

    q: String,

    hits: Vec<(String, String)>,

    can_edit: bool,

}

#[derive(Template)]

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

pub struct WikiHistoryPage {

    shell: Shell,

    repo: RepoShell,

    slug: String,

    title: String,

    entries: Vec<ChangeView>,

}

fn base(owner: &str, name: &str) -> String {

    format!("/{owner}/{name}/wiki/")

}

fn render(owner: &str, name: &str, text: &str) -> String {

    crate::render::markdown::render(text, &base(owner, name), &format!("/{owner}/{name}/wiki/_raw/"))

}

/// Whether the viewer may change the wiki: a writer, and not archived.

fn editable(row: &crate::db::repos::RepoRow, rs: &RepoShell) -> bool {

    rs.can(Access::Write) && !row.archived

}

#[derive(Deserialize)]

pub struct ShowQuery {

    notice: Option<String>,

}

/// `GET /{owner}/{name}/wiki`: the Home page.

pub async fn home(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<ShowQuery>,

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

    show_page(app, viewer, owner, name, wiki::HOME.into(), q.notice).await

}

/// `GET /{owner}/{name}/wiki/{slug}`.

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, slug)): Path<(String, String, String)>,

    Query(q): Query<ShowQuery>,

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

    show_page(app, viewer, owner, name, slug, q.notice).await

}

async fn show_page(

    app: Shared,

    viewer: Viewer,

    owner: String,

    name: String,

    slug: String,

    notice: Option<String>,

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

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/{slug}"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    if !wiki::slug_ok(&slug) {

        return Err(Error::not_found(shell));

    }

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

    let text = wiki::page(&app, &repo, &slug).await.map_err(e)?;

    let sidebar = wiki::page(&app, &repo, wiki::SIDEBAR).await.map_err(e)?;

    let pages: Vec<String> = wiki::pages(&app, &repo).await.map_err(e)?.into_iter().filter(|p| p != wiki::SIDEBAR).collect();

    let any = !pages.is_empty();

    let history = if text.is_some() { wiki::history(&app, &repo, &slug, 1000).await.map_err(e)? } else { vec![] };

    let revisions = history.len();

    let last = history.into_iter().next();

    let rs = RepoShell::new(&app, &row, "wiki").with_role(role).with_sky(&app, &row).await;

    let can_edit = editable(&row, &rs);

    let (html, toc) = match text.as_deref().map(|t| contents(&render(&owner, &name, t))) {

        Some((h, t)) => (Some(h), t),

        None => (None, vec![]),

    };

    Ok(Page(WikiPage {

        html,

        pages,

        revisions,

        toc,

        sidebar: sidebar.as_deref().map(|t| render(&owner, &name, t)),

        title: wiki::title_of(&slug),

        shell,

        repo: rs,

        slug,

        any,

        can_edit,

        last,

        notice,

    }))

}

/// Give a rendered page's `<h1>`–`<h3>` ids and list them, for the

/// table of contents (#194). The HTML is already sanitised; the ids are

/// made of letters, digits and dashes only, and the text keeps only what

/// was between the tags.

fn contents(html: &str) -> (String, Vec<(u8, String, String)>) {

    let mut out = String::with_capacity(html.len() + 64);

    let mut toc = vec![];

    let mut used = std::collections::HashSet::new();

    let mut rest = html;

    while let Some(at) = rest.find("<h") {

        let level = rest.as_bytes().get(at + 2).copied().unwrap_or(0);

        let tagged = matches!(level, b'1'..=b'3') && rest[at + 3..].starts_with('>');

        let close = format!("</h{}>", level as char);

        let end = if tagged { rest[at..].find(&close).map(|e| at + e) } else { None };

        let Some(end) = end else {

            out.push_str(&rest[..at + 2]);

            rest = &rest[at + 2..];

            continue;

        };

        let inner = &rest[at + 4..end];

        let mut text = String::new();

        let mut in_tag = false;

        for c in inner.chars() {

            match c {

                '<' => in_tag = true,

                '>' => in_tag = false,

                c if !in_tag => text.push(c),

                _ => {}

            }

        }

        let mut id: String = text

            .replace("&", "and")

            .chars()

            .map(|c| if c.is_alphanumeric() { c.to_ascii_lowercase() } else { '-' })

            .collect::<String>()

            .split('-')

            .filter(|p| !p.is_empty())

            .collect::<Vec<_>>()

            .join("-");

        if id.is_empty() {

            id = "section".into();

        }

        let mut unique = id.clone();

        let mut n = 1;

        while !used.insert(unique.clone()) {

            n += 1;

            unique = format!("{id}-{n}");

        }

        out.push_str(&rest[..at]);

        out.push_str(&format!("<h{l} id=\"{unique}\">{inner}{close}", l = level as char));

        toc.push((level - b'0', text.trim().to_string(), unique));

        rest = &rest[end + close.len()..];

    }

    out.push_str(rest);

    (out, toc)

}

#[derive(Deserialize)]

pub struct PagesQuery {

    #[serde(default)]

    q: String,

}

/// `GET /{owner}/{name}/wiki/_pages`: every page, and a search.

pub async fn pages(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<PagesQuery>,

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

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/_pages"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

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

    let pages = wiki::pages(&app, &repo).await.map_err(e)?;

    let q: String = q.q.trim().chars().take(100).collect();

    let hits = if q.is_empty() { vec![] } else { wiki::search(&app, &repo, &q).await.map_err(e)? };

    let rs = RepoShell::new(&app, &row, "wiki").with_role(role);

    let can_edit = editable(&row, &rs);

    Ok(Page(WikiPagesPage { shell, repo: rs, pages, q, hits, can_edit }))

}

/// `GET /{owner}/{name}/wiki/{slug}/history`.

pub async fn history(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, slug)): Path<(String, String, String)>,

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

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/{slug}/history"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    if !wiki::slug_ok(&slug) {

        return Err(Error::not_found(shell));

    }

    let mut entries = wiki::history(&app, &repo, &slug, 100).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    super::attribute(&app, &mut entries.iter_mut().collect::<Vec<_>>()).await;

    Ok(Page(WikiHistoryPage {

        title: wiki::title_of(&slug),

        shell,

        repo: RepoShell::new(&app, &row, "wiki").with_role(role),

        slug,

        entries,

    }))

}

#[derive(Deserialize)]

pub struct NewQuery {

    #[serde(default)]

    title: String,

}

/// `GET /{owner}/{name}/wiki/_new`: a new page, named by the form.

pub async fn new_form(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<NewQuery>,

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

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/_new"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    let slug = wiki::slug_of(&q.title);

    Ok(Page(WikiEditPage {

        title: if slug.is_empty() { String::new() } else { wiki::title_of(&slug) },

        shell,

        repo: RepoShell::new(&app, &row, "wiki").with_role(role),

        slug,

        content: String::new(),

        exists: false,

        error: None,

    }))

}

/// `GET /{owner}/{name}/wiki/{slug}/edit`.

pub async fn edit_form(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, slug)): Path<(String, String, String)>,

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

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/{slug}/edit"), &viewer);

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    if !wiki::slug_ok(&slug) {

        return Err(Error::not_found(shell));

    }

    let text = wiki::page(&app, &repo, &slug).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    Ok(Page(WikiEditPage {

        title: wiki::title_of(&slug),

        shell,

        repo: RepoShell::new(&app, &row, "wiki").with_role(role),

        slug,

        exists: text.is_some(),

        content: text.unwrap_or_default(),

        error: None,

    }))

}

#[derive(Deserialize)]

pub struct SaveForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// The page's title; its slug is the file name. A changed title on an

    /// existing page renames it.

    #[serde(default)]

    title: String,

    #[serde(default)]

    content: String,

    #[serde(default)]

    message: String,

}

/// `POST /{owner}/{name}/wiki/{slug}/edit` (`_new` for a new page): the

/// change is authored by the user and signed by the hub as their delegate.

pub async fn save(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, slug)): Path<(String, String, String)>,

    Form(f): Form<SaveForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/{slug}/edit"), &viewer);

    let me = super::settings::require(&viewer, &shell)?;

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

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    let is_new = slug == "_new";

    let old_slug = if is_new { String::new() } else { slug.clone() };

    let new_slug = wiki::slug_of(&f.title);

    let content = f.content.replace("\r\n", "\n");

    let again = |msg: String| {

        Page(WikiEditPage {

            title: f.title.clone(),

            shell: shell.clone(),

            repo: RepoShell::new(&app, &row, "wiki").with_role(role),

            slug: if is_new { new_slug.clone() } else { old_slug.clone() },

            content: content.clone(),

            exists: !is_new,

            error: Some(msg),

        })

        .into_response()

    };

    if !is_new && !wiki::slug_ok(&old_slug) {

        return Err(Error::not_found(shell));

    }

    if !wiki::slug_ok(&new_slug) {

        return Ok(again("A page title is letters, digits, spaces, dots, dashes and underscores, up to 100 characters.".into()));

    }

    if content.trim().is_empty() {

        return Ok(again("Write something on the page.".into()));

    }

    let signer = match super::edit::signer_for(&app, me.account.id).await {

        Ok(s) => s,

        Err(msg) => return Ok(again(msg)),

    };

    let renamed = !is_new && new_slug != old_slug;

    let taken = wiki::page(&app, &repo, &new_slug).await.map_err(|e| Error::from_repo(shell.clone(), e))?.is_some();

    if (is_new || renamed) && taken {

        return Ok(again(format!("There is already a page called {}.", wiki::title_of(&new_slug))));

    }

    let message = if f.message.trim().is_empty() {

        format!(

            "{} {}",

            if is_new {

                "Create"

            } else if renamed {

                "Rename and update"

            } else {

                "Update"

            },

            wiki::title_of(&new_slug)

        )

    } else {

        f.message.trim().chars().take(200).collect()

    };

    let mut edits = vec![];

    if renamed {

        edits.push(oxy_core::repo::FileEdit { path: wiki::path_of(&old_slug), content: None });

    }

    edits.push(oxy_core::repo::FileEdit { path: wiki::path_of(&new_slug), content: Some(content.clone().into_bytes()) });

    if let Err(e) = wiki::commit(&app, &repo, edits, message.clone(), signer).await {

        return Ok(again(e.to_string()));

    }

    accounts::audit(&app.db, Some(&me.account), "wiki.edited", &repo.to_string(), &new_slug).await.ok();

    crate::hooks::emit(&app, &row, "wiki", &me.account.username, serde_json::json!({ "page": new_slug, "message": message })).await;

    Ok(Redirect::to(&format!("/{owner}/{name}/wiki/{new_slug}")).into_response())

}

#[derive(Deserialize)]

pub struct DeleteForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

}

/// `POST /{owner}/{name}/wiki/{slug}/delete`: a change that removes the page.

pub async fn delete(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, slug)): Path<(String, String, String)>,

    Form(f): Form<DeleteForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/{slug}"), &viewer);

    let me = super::settings::require(&viewer, &shell)?;

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

    let (repo, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    if !wiki::slug_ok(&slug) || wiki::page(&app, &repo, &slug).await.map_err(|e| Error::from_repo(shell.clone(), e))?.is_none() {

        return Err(Error::not_found(shell));

    }

    let signer = super::edit::signer_for(&app, me.account.id).await.map_err(|m| Error::bad(shell.clone(), m))?;

    let message = format!("Delete {}", wiki::title_of(&slug));

    wiki::commit(&app, &repo, vec![oxy_core::repo::FileEdit { path: wiki::path_of(&slug), content: None }], message.clone(), signer)

        .await

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

    accounts::audit(&app.db, Some(&me.account), "wiki.deleted", &repo.to_string(), &slug).await.ok();

    crate::hooks::emit(&app, &row, "wiki", &me.account.username, serde_json::json!({ "page": slug, "message": message, "deleted": true }))

        .await;

    Ok(Redirect::to(&format!("/{owner}/{name}/wiki?notice={}", super::settings::urlencode(&format!("{} deleted.", wiki::title_of(&slug)))))

        .into_response())

}

/// `GET /{owner}/{name}/wiki/_raw/{*path}`: a file of the wiki as bytes,

/// for images pages embed.

pub async fn raw(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, path)): Path<(String, String, String)>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/wiki/_raw/{path}"), &viewer);

    let (repo, _, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    if !wiki::exists(&app, &repo) || path.contains("..") {

        return Err(Error::not_found(shell));

    }

    let p = path.trim_matches('/').to_string();

    let file_name = p.rsplit('/').next().unwrap_or("").to_string();

    let bytes = app

        .wikis

        .read(&repo, move |r, _| {

            let heads = r.bookmarks()?.into_iter().find(|b| b.name == wiki::BOOKMARK).map(|b| b.heads).unwrap_or_default();

            Ok(r.file_at(&p, Some(&heads)).ok())

        })

        .await

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

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    Ok(super::raw(bytes, &file_name, true))

}

#[cfg(test)]

mod tests {

    #[test]

    fn headings_get_ids_and_a_contents_list() {

        let (html, toc) = super::contents("<h1>R* API</h1><p>x</p><h2>Build &amp; run</h2><h2>Build &amp; run</h2><h4>deep</h4><hr>");

        assert_eq!(

            html,

            "<h1 id=\"r-api\">R* API</h1><p>x</p><h2 id=\"build-and-run\">Build &amp; run</h2><h2 id=\"build-and-run-2\">Build &amp; run</h2><h4>deep</h4><hr>"

        );

        assert_eq!(

            toc.iter().map(|t| (t.0, t.2.as_str())).collect::<Vec<_>>(),

            [(1, "r-api"), (2, "build-and-run"), (2, "build-and-run-2")]

        );

    }

}