wikioxide 0.1.0

//! Classification and dispatch: turns an expanded template name into a magic word, parser
//! function or transclusion, and evaluates the parser functions and magic words.

use super::Expander;
use crate::engine::expand::pf::strings::{self, UrlEncodeKind};
use crate::engine::expand::pf::{expr, time};
use crate::engine::pp::Part;
use crate::engine::source::Span;
use crate::engine::strip::StripPayload;
use crate::model::ModuleInvocation;
use crate::title::{Namespace, Title};
use crate::warn::Warning;

impl Expander<'_> {
    /// Classifies a template name (subst-stripped) and routes it: `#name` → parser
    /// function; a colon whose head resolves as a magic word → colon function / variable;
    /// a bare single-part magic word → variable; anything else → transclusion.
    pub(super) fn dispatch(
        &mut self,
        dom_idx: usize,
        name: &str,
        parts: &[Part],
        span: Span,
        frame: usize,
        out: &mut String,
    ) {
        let target = strip_subst(name);

        if let Some(rest) = target.strip_prefix('#') {
            self.parser_function(dom_idx, rest, parts, span, frame, out);
            return;
        }

        if let Some((head, tail)) = target.split_once(':') {
            let colon = &target[..head.len() + 1];
            if let Some(id) = self
                .config
                .resolve_magic_word(colon)
                .or_else(|| self.config.resolve_magic_word(head))
            {
                let id = id.to_owned();
                self.colon_function(dom_idx, &id, tail.trim(), parts, frame, out);
                return;
            }
        } else if parts.len() == 1 {
            if let Some(id) = self.config.resolve_magic_word(target) {
                let id = id.to_owned();
                if let Some(value) = self.variable(&id, None) {
                    out.push_str(&value);
                    return;
                }
                // A registered magic word we do not model renders as nothing.
                return;
            }
        }

        let Ok(title) = Title::parse_with_default(target, self.config, Namespace::TEMPLATE) else {
            out.push_str(self.store.slice(span));
            return;
        };
        self.transclude(title, dom_idx, parts, frame, out);
    }

    /// A `#name` parser function. `rest` is everything after `#`; its first `:` splits the
    /// function id from the first argument.
    fn parser_function(
        &mut self,
        dom_idx: usize,
        rest: &str,
        parts: &[Part],
        span: Span,
        frame: usize,
        out: &mut String,
    ) {
        let (raw_id, arg0) = match rest.split_once(':') {
            Some((id, arg0)) => (id.trim(), arg0.trim()),
            None => (rest.trim(), ""),
        };
        let id = self
            .config
            .resolve_magic_word(raw_id)
            .map(str::to_owned)
            .unwrap_or_else(|| raw_id.to_ascii_lowercase());

        match id.as_str() {
            "if" => {
                let branch = if arg0.is_empty() { 2 } else { 1 };
                out.push_str(&self.arg(dom_idx, parts, branch, frame));
            }
            "ifeq" => {
                let b = self.arg(dom_idx, parts, 1, frame);
                let branch = if values_equal(arg0, &b) { 2 } else { 3 };
                out.push_str(&self.arg(dom_idx, parts, branch, frame));
            }
            "ifexpr" => match expr::eval(arg0) {
                Ok(value) => {
                    let branch = if is_truthy(&value) { 1 } else { 2 };
                    out.push_str(&self.arg(dom_idx, parts, branch, frame));
                }
                Err(err) => out.push_str(err.message()),
            },
            "iferror" => {
                let branch = if arg0.contains("class=\"error\"") {
                    2
                } else {
                    1
                };
                // #iferror: arg1 is the "then" (error) branch, arg2 the "else"; when only
                // one branch is given MediaWiki returns the tested value on success.
                if branch == 1 && parts.len() < 3 {
                    out.push_str(arg0);
                } else {
                    let idx = if branch == 2 { 1 } else { 2 };
                    out.push_str(&self.arg(dom_idx, parts, idx, frame));
                }
            }
            "ifexist" => self.if_exist(dom_idx, arg0, parts, frame, out),
            "switch" => self.switch(dom_idx, arg0, parts, frame, out),
            "expr" => match expr::eval(arg0) {
                Ok(value) => out.push_str(&value),
                Err(err) => out.push_str(err.message()),
            },
            "time" | "timel" => self.time(dom_idx, arg0, parts, frame, out),
            "tag" => self.tag(dom_idx, arg0, parts, frame, out),
            "invoke" => self.invoke(dom_idx, arg0, parts, frame, out),
            _ => {
                self.warnings.emit(Warning::UnsupportedParserFunction {
                    name: format!("#{raw_id}"),
                });
                out.push_str(self.store.slice(span));
            }
        }
    }

    /// `{{#ifexist:title|then|else}}` — expensive; consults the existence provider, else
    /// records the query and takes the false branch.
    fn if_exist(
        &mut self,
        dom_idx: usize,
        arg0: &str,
        parts: &[Part],
        frame: usize,
        out: &mut String,
    ) {
        let exists = if !self.charge_expensive() {
            false
        } else if let Ok(title) = Title::parse(arg0, self.config) {
            match self
                .ctx
                .existence
                .map(|p| p.lookup(std::slice::from_ref(&title)))
            {
                Some(Ok(map)) => map.get(&title).is_some_and(|r| r.exists),
                _ => {
                    self.warnings.emit(Warning::ExistenceUnknown {
                        title: title.text(),
                    });
                    self.record_wanted(title);
                    false
                }
            }
        } else {
            false
        };
        let branch = if exists { 1 } else { 2 };
        out.push_str(&self.arg(dom_idx, parts, branch, frame));
    }

    /// `{{#switch:value|case=result|…|#default=result}}` with fall-through and a trailing
    /// bare default.
    fn switch(
        &mut self,
        dom_idx: usize,
        value: &str,
        parts: &[Part],
        frame: usize,
        out: &mut String,
    ) {
        let cases = &parts[1.min(parts.len())..];
        let last = cases.len().saturating_sub(1);
        let mut matched = false;
        let mut default: Option<String> = None;
        for (i, part) in cases.iter().enumerate() {
            let (name, result) = self.switch_case(dom_idx, part, frame);
            match name {
                Some(name) => {
                    if matched || name == value {
                        out.push_str(&result);
                        return;
                    }
                    if name == "#default" {
                        default = Some(result);
                    }
                }
                None => {
                    if matched {
                        out.push_str(&result);
                        return;
                    }
                    if result == value {
                        matched = true;
                    } else if i == last {
                        default = Some(result);
                    }
                }
            }
        }
        if let Some(default) = default {
            out.push_str(&default);
        }
    }

    /// Splits a `#switch` case part into its (optional) case name and result value, both
    /// expanded and trimmed.
    fn switch_case(
        &mut self,
        dom_idx: usize,
        part: &Part,
        frame: usize,
    ) -> (Option<String>, String) {
        match part.eq {
            Some(eq) if part.children.get(eq).is_some() => {
                let name = self
                    .expand_nodes_owned(dom_idx, &part.children[..eq], frame)
                    .trim()
                    .to_owned();
                let value = self
                    .expand_nodes_owned(dom_idx, &part.children[eq + 1..], frame)
                    .trim()
                    .to_owned();
                (Some(name), value)
            }
            _ => (None, self.arg_part(dom_idx, part, frame)),
        }
    }

    /// A colon-form function or variable-with-argument. `arg0` is the (expanded, trimmed)
    /// text after the first colon of the name.
    fn colon_function(
        &mut self,
        dom_idx: usize,
        id: &str,
        arg0: &str,
        parts: &[Part],
        frame: usize,
        out: &mut String,
    ) {
        match id {
            "lc" => out.push_str(&strings::lc(arg0)),
            "uc" => out.push_str(&strings::uc(arg0)),
            "lcfirst" => out.push_str(&strings::lcfirst(arg0)),
            "ucfirst" => out.push_str(&strings::ucfirst(arg0)),
            "padleft" => {
                let width = self
                    .arg(dom_idx, parts, 1, frame)
                    .parse::<usize>()
                    .unwrap_or(0);
                let pad = self.arg_or(dom_idx, parts, 2, frame, "0");
                out.push_str(&strings::padleft(arg0, width, &pad));
            }
            "padright" => {
                let width = self
                    .arg(dom_idx, parts, 1, frame)
                    .parse::<usize>()
                    .unwrap_or(0);
                let pad = self.arg_or(dom_idx, parts, 2, frame, "0");
                out.push_str(&strings::padright(arg0, width, &pad));
            }
            "urlencode" => {
                let kind = UrlEncodeKind::parse(&self.arg(dom_idx, parts, 1, frame));
                out.push_str(&strings::urlencode(arg0, kind));
            }
            "anchorencode" => out.push_str(&strings::anchorencode(arg0)),
            "ns" => {
                if let Some(name) = self.namespace_name(arg0) {
                    out.push_str(&name);
                }
            }
            "defaultsort" => self.default_sort = Some(arg0.to_owned()),
            "displaytitle" => self.display_title = Some(arg0.to_owned()),
            "formatnum" => out.push_str(arg0),
            _ => {
                if let Some(value) = self.variable(id, Some(arg0)) {
                    out.push_str(&value);
                }
            }
        }
    }

    /// `{{#tag:name|body|attr=value|…}}` — builds an extension-tag strip marker whose body
    /// and attributes are the expanded arguments (parked in an owned source buffer).
    fn tag(&mut self, dom_idx: usize, name: &str, parts: &[Part], frame: usize, out: &mut String) {
        if name.is_empty() {
            return;
        }
        let body = parts
            .get(1)
            .map(|part| self.arg_part(dom_idx, part, frame))
            .filter(|_| parts.len() > 1);
        let mut attr = String::new();
        for part in parts.iter().skip(2) {
            let (key, value) = self.switch_case(dom_idx, part, frame);
            if let Some(key) = key {
                attr.push(' ');
                attr.push_str(&key);
                attr.push_str("=\"");
                attr.push_str(&value);
                attr.push('"');
            }
        }
        let attributes = (!attr.is_empty()).then(|| {
            let src = self.store.push_raw(attr);
            Span::new(src, 0, self.store.text(src).len() as u32)
        });
        let body = body.map(|text| {
            let src = self.store.push_raw(text);
            Span::new(src, 0, self.store.text(src).len() as u32)
        });
        self.strips.add(
            out,
            StripPayload::ExtTag {
                name: name.to_lowercase(),
                attributes,
                body,
            },
        );
    }

    /// `{{#invoke:Module|function|args}}` — records the module in the transclusion closure
    /// and as an invocation; Scribunto is not executed, so it renders nothing.
    fn invoke(
        &mut self,
        dom_idx: usize,
        module_name: &str,
        parts: &[Part],
        frame: usize,
        out: &mut String,
    ) {
        let _ = out;
        let Ok(module) = Title::parse_with_default(module_name, self.config, Namespace::MODULE)
        else {
            return;
        };
        self.record_used(module.clone());
        self.warnings.emit(Warning::UnsupportedModuleInvocation {
            module: module.text(),
        });
        let function = self.arg(dom_idx, parts, 1, frame);
        let mut args = std::collections::BTreeMap::new();
        let mut positional = 0_usize;
        for part in parts.iter().skip(2) {
            let (name, value) = self.switch_case(dom_idx, part, frame);
            match name {
                Some(name) => {
                    args.insert(name, value);
                }
                None => {
                    positional += 1;
                    args.insert(positional.to_string(), value);
                }
            }
        }
        self.modules
            .push(ModuleInvocation::new(module, function, args));
    }

    /// `{{#time:format|timestamp}}` — formats `timestamp` (default: the frozen now) per the
    /// MediaWiki format string; an unsupported code emits a warning.
    fn time(
        &mut self,
        dom_idx: usize,
        format: &str,
        parts: &[Part],
        frame: usize,
        out: &mut String,
    ) {
        let spec = self.arg(dom_idx, parts, 1, frame);
        let unix = parse_time_spec(&spec, self.ctx.now.unix());
        let result = time::format_time(format, unix);
        if result.unsupported {
            self.warnings.emit(Warning::UnsupportedTimeFormat);
        }
        out.push_str(&result.text);
    }

    /// Resolves a magic variable (`{{PAGENAME}}`, `{{SITENAME}}`, `{{CURRENT*}}`, `{{!}}`,
    /// …), optionally with a colon argument. Returns `None` for ids this engine does not
    /// model as a variable.
    fn variable(&self, id: &str, arg: Option<&str>) -> Option<String> {
        let page = match arg {
            Some(arg) => Title::parse(arg, self.config).ok()?,
            None => self.ctx.title.clone(),
        };
        let pagename = page.dbkey().replace('_', " ");
        let value = match id {
            "!" => "|".to_owned(),
            "=" => "=".to_owned(),
            "sitename" => self.config.site_name().to_owned(),
            "contentlanguage" | "pagelanguage" => self.config.lang().to_owned(),
            "pagename" => pagename,
            "pagenamee" => page.dbkey().to_owned(),
            "fullpagename" => page.text(),
            "namespace" => self
                .config
                .namespace_name(page.namespace())
                .unwrap_or("")
                .to_owned(),
            "namespacenumber" => page.namespace().id().to_string(),
            "basepagename" => base_pagename(&pagename),
            "subpagename" => sub_pagename(&pagename),
            "rootpagename" => root_pagename(&pagename),
            "currentyear" => self.current("Y"),
            "currentmonth" | "currentmonth2" => self.current("m"),
            "currentmonth1" => self.current("n"),
            "currentmonthname" => self.current("F"),
            "currentmonthabbrev" => self.current("M"),
            "currentday" => self.current("j"),
            "currentday2" => self.current("d"),
            "currentdow" => self.current("w"),
            "currentdayname" => self.current("l"),
            "currenttime" => self.current("H:i"),
            "currenthour" => self.current("H"),
            "currenttimestamp" => self.current("YmdHis"),
            "currentweek" => self.current("W"),
            _ => return None,
        };
        Some(value)
    }

    /// Formats the frozen "now" with a `{{#time:}}` format string (for the `CURRENT*`
    /// variables).
    fn current(&self, format: &str) -> String {
        time::format_time(format, self.ctx.now.unix()).text
    }

    /// The localized name of the namespace identified by `arg` (a numeric id or a
    /// namespace name), for `{{ns:}}`.
    fn namespace_name(&self, arg: &str) -> Option<String> {
        let ns = match arg.trim().parse::<i32>() {
            Ok(id) => Namespace::new(id),
            Err(_) => self.config.resolve_namespace(arg.trim())?,
        };
        self.config.namespace_name(ns).map(str::to_owned)
    }

    /// Expands parts[index] (whole part), trimmed; empty when out of range.
    fn arg(&mut self, dom_idx: usize, parts: &[Part], index: usize, frame: usize) -> String {
        match parts.get(index) {
            Some(part) => self.arg_part(dom_idx, part, frame),
            None => String::new(),
        }
    }

    /// Like [`arg`](Self::arg) but substitutes `fallback` when the part is absent.
    fn arg_or(
        &mut self,
        dom_idx: usize,
        parts: &[Part],
        index: usize,
        frame: usize,
        fallback: &str,
    ) -> String {
        match parts.get(index) {
            Some(part) => self.arg_part(dom_idx, part, frame),
            None => fallback.to_owned(),
        }
    }

    /// Expands a whole part (all children), trimmed.
    fn arg_part(&mut self, dom_idx: usize, part: &Part, frame: usize) -> String {
        self.expand_part_all(dom_idx, part, frame).trim().to_owned()
    }
}

/// Strips one leading `subst:`/`safesubst:` (case-insensitive) and following whitespace.
fn strip_subst(name: &str) -> &str {
    for prefix in ["safesubst:", "subst:"] {
        if let Some(head) = name.get(..prefix.len()) {
            if head.eq_ignore_ascii_case(prefix) {
                return name[prefix.len()..].trim_start();
            }
        }
    }
    name
}

/// `#ifeq`/`#switch` comparison: numeric when both sides parse as numbers, else string.
fn values_equal(a: &str, b: &str) -> bool {
    match (a.trim().parse::<f64>(), b.trim().parse::<f64>()) {
        (Ok(x), Ok(y)) => x == y,
        _ => a == b,
    }
}

/// `#ifexpr` truthiness: a nonzero, non-empty numeric result.
fn is_truthy(value: &str) -> bool {
    match value.trim().parse::<f64>() {
        Ok(n) => n != 0.0,
        Err(_) => !value.trim().is_empty(),
    }
}

/// Parses a `{{#time:}}` timestamp argument: empty → `now`; `@<seconds>` → an absolute
/// Unix time; anything else is unsupported and falls back to `now`.
fn parse_time_spec(spec: &str, now: i64) -> i64 {
    let spec = spec.trim();
    if spec.is_empty() {
        return now;
    }
    if let Some(seconds) = spec.strip_prefix('@') {
        if let Ok(value) = seconds.trim().parse::<i64>() {
            return value;
        }
    }
    now
}

/// `{{BASEPAGENAME}}`: everything before the last `/`.
fn base_pagename(name: &str) -> String {
    match name.rfind('/') {
        Some(slash) => name[..slash].to_owned(),
        None => name.to_owned(),
    }
}

/// `{{SUBPAGENAME}}`: everything after the last `/`.
fn sub_pagename(name: &str) -> String {
    match name.rfind('/') {
        Some(slash) => name[slash + 1..].to_owned(),
        None => name.to_owned(),
    }
}

/// `{{ROOTPAGENAME}}`: everything before the first `/`.
fn root_pagename(name: &str) -> String {
    match name.find('/') {
        Some(slash) => name[..slash].to_owned(),
        None => name.to_owned(),
    }
}