//! Wikis (hub spec §6.11, oxygenhub#104): Markdown pages kept as an

//! Oxygen repository of their own beside the code, under

//! `<data>/wikis/<owner>/<name>`, read and written on the web and cloned

//! or pushed as `OWNER/NAME.wiki`. A page `Getting-Started` is the file

//! `Getting-Started.md` on bookmark `main`; `_Sidebar.md` is the sidebar.

//! Web edits are changes authored by the user and signed by the hub as

//! their delegate, exactly as code edits are (§6.9).

use crate::repos::edits::{Committed, Signer};

use crate::repos::view::{self, ChangeView};

use crate::repos::{RepoError, RepoName};

use crate::Shared;

use oxy_core::hash::ChangeHash;

use oxy_core::identity::Domain;

use oxy_core::repo::{FileEdit, Repo};

pub const BOOKMARK: &str = "main";

pub const HOME: &str = "Home";

pub const SIDEBAR: &str = "_Sidebar";

/// The suffix a wiki's clone address carries: `OWNER/NAME.wiki`.

pub const SUFFIX: &str = ".wiki";

/// Pages searched at most.

const MAX_SEARCHED: usize = 500;

/// A page's name in a URL and file name: `Getting-Started`.

pub fn slug_ok(slug: &str) -> bool {

    !slug.is_empty()

        && slug.len() <= 100

        && slug.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.'))

        && !slug.contains("..")

        && !slug.starts_with('.')

        && !slug.ends_with('.')

}

/// `Getting Started` → `Getting-Started`.

pub fn slug_of(title: &str) -> String {

    title.split_whitespace().collect::<Vec<_>>().join("-")

}

/// `Getting-Started` → `Getting Started`.

pub fn title_of(slug: &str) -> String {

    slug.replace('-', " ")

}

pub fn path_of(slug: &str) -> String {

    format!("{slug}.md")

}

/// The page a file at the root is, if it is one.

pub fn slug_from_path(path: &str) -> Option<&str> {

    path.strip_suffix(".md").filter(|s| !s.contains('/') && slug_ok(s))

}

/// `OWNER/NAME.wiki` → the repository it belongs to, and whether it was

/// a wiki address at all.

pub fn parent_of(name: &RepoName) -> (RepoName, bool) {

    match name.name.strip_suffix(SUFFIX).and_then(|n| RepoName::new(&name.owner, n)) {

        Some(parent) => (parent, true),

        None => (name.clone(), false),

    }

}

pub fn exists(app: &Shared, repo: &RepoName) -> bool {

    app.wikis.exists(repo)

}

/// `main`'s heads, empty before the first page.

fn heads(r: &Repo) -> Result<Vec<ChangeHash>, RepoError> {

    Ok(r.bookmarks()?.into_iter().find(|b| b.name == BOOKMARK).map(|b| b.heads).unwrap_or_default())

}

/// A page's Markdown, `None` when there is no such page.

pub async fn page(app: &Shared, repo: &RepoName, slug: &str) -> Result<Option<String>, RepoError> {

    if !exists(app, repo) {

        return Ok(None);

    }

    let path = path_of(slug);

    app.wikis

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

            let heads = heads(r)?;

            if heads.is_empty() {

                return Ok(None);

            }

            Ok(r.file_at(&path, Some(&heads)).ok().map(|b| String::from_utf8_lossy(&b).into_owned()))

        })

        .await

}

/// Every page, by slug, sorted; the sidebar and other `_` pages left out.

pub async fn pages(app: &Shared, repo: &RepoName) -> Result<Vec<String>, RepoError> {

    if !exists(app, repo) {

        return Ok(vec![]);

    }

    app.wikis

        .read(repo, |r, cache| {

            let heads = heads(r)?;

            if heads.is_empty() {

                return Ok(vec![]);

            }

            let loaded = cache.load(r, &heads)?;

            let mut out: Vec<String> =

                loaded.snapshot.files.keys().filter_map(|p| slug_from_path(p)).filter(|s| !s.starts_with('_')).map(String::from).collect();

            out.sort_by_key(|s| s.to_lowercase());

            Ok(out)

        })

        .await

}

/// Pages whose text holds `q`, with a line that does: (slug, snippet).

pub async fn search(app: &Shared, repo: &RepoName, q: &str) -> Result<Vec<(String, String)>, RepoError> {

    let q = q.trim().to_lowercase();

    if q.is_empty() || !exists(app, repo) {

        return Ok(vec![]);

    }

    app.wikis

        .read(repo, move |r, cache| {

            let heads = heads(r)?;

            if heads.is_empty() {

                return Ok(vec![]);

            }

            let loaded = cache.load(r, &heads)?;

            let mut out = vec![];

            for path in loaded.snapshot.files.keys().take(MAX_SEARCHED) {

                let Some(slug) = slug_from_path(path) else { continue };

                let Ok(bytes) = r.file_at(path, Some(&heads)) else { continue };

                let text = String::from_utf8_lossy(&bytes);

                let hit = slug.to_lowercase().contains(&q) || text.to_lowercase().contains(&q);

                if hit {

                    let line = text.lines().find(|l| l.to_lowercase().contains(&q)).unwrap_or("").trim();

                    out.push((slug.to_string(), line.chars().take(160).collect()));

                }

            }

            Ok(out)

        })

        .await

}

/// The changes that touched a page, newest first.

pub async fn history(app: &Shared, repo: &RepoName, slug: &str, limit: usize) -> Result<Vec<ChangeView>, RepoError> {

    if !exists(app, repo) {

        return Ok(vec![]);

    }

    let path = path_of(slug);

    app.wikis

        .read(repo, move |r, cache| {

            if heads(r)?.is_empty() {

                return Ok(vec![]);

            }

            let target = view::resolve(r, cache, BOOKMARK)?;

            Ok(view::history(r, cache, target, Some(&path), 0, limit)?.entries)

        })

        .await

}

/// Record `edits` as a change on the wiki's `main`, authored by the user

/// and signed by the hub as their delegate; the wiki is made on the first.

pub async fn commit(app: &Shared, repo: &RepoName, edits: Vec<FileEdit>, message: String, signer: Signer) -> Result<Committed, RepoError> {

    if !exists(app, repo) {

        // Bound to an id from the start, so it clones before any push.

        app.wikis.create(repo, Some(rand::random::<[u8; 16]>()))?;

    }

    app.wikis

        .write(repo, move |r, _| {

            let base_heads = heads(r)?;

            let author = signer.author.hash();

            let change = r.build_change(&base_heads, &edits, &message, author)?;

            let hash = change.hash();

            let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);

            let mut state = r.load_state(&base_heads)?;

            state.add(change.clone()).map_err(|e| RepoError::Oxy(oxy_core::repo::RepoError::Msg(e.to_string())))?;

            let mut candidates = base_heads.clone();

            candidates.push(hash);

            let heads = state.maximal(&candidates);

            let update = r.host_ref_update(BOOKMARK, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;

            let (old_state, new_state) = (update.old_state.to_hex(), update.new_state.to_hex());

            let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;

            if let Some(refused) = report.results.iter().find(|x| !x.ok) {

                return Err(RepoError::Oxy(oxy_core::repo::RepoError::Msg(format!("the wiki refused the change: {}", refused.reason))));

            }

            Ok(Committed { change: hash, bookmark: BOOKMARK.into(), old_state, new_state, heads, report })

        })

        .await

}

/// Remove the wiki (to the trash), when the repository goes or an admin

/// asks under Settings › Advanced.

pub fn trash(app: &Shared, repo: &RepoName) -> Result<(), RepoError> {

    if exists(app, repo) {

        app.wikis.trash(repo)?;

    }

    Ok(())

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn slugs_titles_and_paths() {

        assert_eq!(slug_of("  Getting   Started "), "Getting-Started");

        assert_eq!(title_of("Getting-Started"), "Getting Started");

        assert_eq!(path_of("Home"), "Home.md");

        assert_eq!(slug_from_path("Home.md"), Some("Home"));

        assert_eq!(slug_from_path("docs/Home.md"), None);

        assert_eq!(slug_from_path("notes.txt"), None);

        assert!(slug_ok("_Sidebar") && slug_ok("v1.2-notes") && !slug_ok("") && !slug_ok("a/b") && !slug_ok("..") && !slug_ok("a b"));

    }

}