abbaye/

site.rs

use std::{
    future::Future,
    path::{Path, PathBuf},
    pin::Pin,
};

use chrono::{DateTime, SecondsFormat, Utc};
use indicatif::ProgressStyle;
use miette::{IntoDiagnostic, Result};
use sha2::{Digest, Sha256};
use tera::{Context, Tera};
use tracing::{info, warn};

use crate::{
    changelog::ChangelogExtractor,
    config::{AbbayeConfig, OutputFormat},
    render::{extract_local_refs, render_markdown_gemtext, render_markdown_html},
    utils,
    version_extractors::VersionInfo,
};

pub const TEMPLATE_BASE_HTML: &str = include_str!("templates/base.html.j2");
pub const TEMPLATE_ROOT_INDEX_HTML: &str = include_str!("templates/root_index.html.j2");
pub const TEMPLATE_VERSION_INDEX_HTML: &str = include_str!("templates/version_index.html.j2");
pub const TEMPLATE_ROOT_INDEX_GEMTEXT: &str = include_str!("templates/root_index.gmi.j2");
pub const TEMPLATE_VERSION_INDEX_GEMTEXT: &str = include_str!("templates/version_index.gmi.j2");
pub const SITE_CSS: &str = include_str!("templates/site.css");
const ATOM_FEED_FILENAME: &str = "releases.atom";

pub(crate) const SPINNER_CHARS: &str = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏ ";

/// Create a spinner style matching the rest of the abbaye UI.
/// When `indent` is true the template is prefixed with two spaces (for child spinners).
pub(crate) fn spinner_style(indent: bool) -> ProgressStyle {
    let tmpl = if indent {
        "  {spinner:.bold} {prefix} {msg}"
    } else {
        "{spinner:.bold} {prefix} {msg}"
    };
    ProgressStyle::with_template(tmpl)
        .expect("valid template")
        .tick_chars(SPINNER_CHARS)
}

// ── Types ───────────────────────────────────────────────────────────────────

/// A version entry as passed to Tera templates.
#[derive(serde::Serialize)]
struct VersionEntry {
    /// Version string (e.g. `"1.2.3"`).
    version: String,
    /// ISO-8601 date string (e.g. `"2024-01-15"`) when the release date is known.
    date: Option<String>,
}

impl VersionEntry {
    fn from_info(info: &VersionInfo) -> Self {
        Self {
            version: info.version.clone(),
            date: info.date.map(|dt| dt.format("%Y-%m-%d").to_string()),
        }
    }
}

/// Metadata about a single file-type dist artifact, passed to Tera templates.
#[derive(serde::Serialize, Clone)]
struct DistFileInfo {
    /// File name (relative to `dist/`).
    name: String,
    /// Raw byte size of the file.
    size_bytes: u64,
    /// Human-readable size (e.g. "1.4 MB").
    size_human: String,
    /// Lowercase hex-encoded SHA-256 digest of the file contents.
    sha256: String,
    /// Optional category inherited from the builder that produced this file.
    #[serde(skip_serializing_if = "Option::is_none")]
    category: Option<String>,
    /// Optional display name inherited from the builder entry.
    #[serde(skip_serializing_if = "Option::is_none")]
    group_name: Option<String>,
    /// Optional comment inherited from the builder entry.
    #[serde(skip_serializing_if = "Option::is_none")]
    group_comment: Option<String>,
}

/// A sub-group of dist artifacts sharing the same group name (from the same
/// builder entry).
#[derive(serde::Serialize)]
struct DistSubgroup {
    /// Display name for this group, or `None`.
    #[serde(skip_serializing_if = "Option::is_none")]
    name: Option<String>,
    /// Comment for this group, or `None`.
    #[serde(skip_serializing_if = "Option::is_none")]
    comment: Option<String>,
    /// Files in this sub-group.
    files: Vec<DistFileInfo>,
}

/// A group of dist artifacts sharing the same builder category.
#[derive(serde::Serialize)]
struct DistCategory {
    /// The shared category, or `None` for builders without one.
    category: Option<String>,
    /// Sub-groups within this category, each from a different builder entry.
    groups: Vec<DistSubgroup>,
}

/// Build the full website into `config.output_dir` (defaults to `public/`).
///
/// # Steps
///
/// 1. Extract the current version via the configured [`crate::version_extractors::AnyVersionExtractor`].
/// 2. Run every configured builder and split the resulting [`crate::builders::ArtifactPath`]s
///    into *dist* (regular files) and *docs* (directories).
/// 3. Copy dist artifacts to `<output>/<version>/dist/`.
/// 4. Copy doc directories to `<output>/<version>/docs/<crate>/` and archive
///    the whole `docs/` tree as `docs.tar.gz`.
/// 5. Render `<output>/<version>/index.html` from the project README and the
///    matching changelog section.
/// 6. Re-render the root `<output>/index.html`, listing all known versions
///    (newest first).
/// 7. Update the `<output>/latest` symlink (Unix) or redirect page (other).
pub async fn build_site(config: AbbayeConfig) -> Result<()> {
    let output_dir = &config.site.output_dir;

    tokio::fs::create_dir_all(output_dir)
        .await
        .into_diagnostic()?;

    // ── 1. Version ────────────────────────────────────────────────────────────
    info!("Extracting version …");
    let version_info = config.version_extractor.extract().await?;
    let version = version_info.version.clone();

    // ── 2. Tera setup ─────────────────────────────────────────────────────────
    info!("Setting up templates …");
    let mut tera = Tera::default();
    let theme_path = PathBuf::from(".abbaye").join("theme");

    // Load templates for each configured format (with theme overrides).
    register_format_templates(
        &mut tera,
        &theme_path,
        &config.site.formats,
        &[
            (
                "root_index",
                TEMPLATE_ROOT_INDEX_HTML,
                TEMPLATE_ROOT_INDEX_GEMTEXT,
            ),
            (
                "version_index",
                TEMPLATE_VERSION_INDEX_HTML,
                TEMPLATE_VERSION_INDEX_GEMTEXT,
            ),
        ],
    )?;
    // Write shared CSS to static/ so the git UI templates can reference it.
    {
        let static_dir = output_dir.join("static");
        tokio::fs::create_dir_all(&static_dir)
            .await
            .into_diagnostic()?;
        tokio::fs::write(static_dir.join("site.css"), SITE_CSS)
            .await
            .into_diagnostic()?;
    }
    // If there's a `static` directory in the theme, copy it over (may overwrite site.css).
    if theme_path.join("static").is_dir() {
        copy_dir_recursive(theme_path.join("static"), output_dir.join("static")).await?;
    }

    // ── 3. Builders (run in parallel, respecting depends_on ordering) ─────────
    info!("Running builders for version {version} …");
    let (dist_artifacts, doc_artifacts) =
        crate::builders::orchestrator::run_builders(&config.builders, &version).await?;

    // ── 4. Lay out dist/ ──────────────────────────────────────────────────────
    info!("Laying out {} dist artifact(s) …", dist_artifacts.len());
    let version_dir = output_dir.join(&version);
    let dist_dir = version_dir.join("dist");
    tokio::fs::create_dir_all(&dist_dir)
        .await
        .into_diagnostic()?;

    // Copy dist artifacts and compute size + SHA-256 in a single pass.
    let mut dist_file_infos: Vec<DistFileInfo> = Vec::new();
    for artifact in &dist_artifacts {
        let bytes = tokio::fs::read(&artifact.path).await.into_diagnostic()?;
        let size_bytes = bytes.len() as u64;
        let sha256 = hex_sha256(&bytes);
        let dest = dist_dir.join(&artifact.name);
        tokio::fs::write(&dest, &bytes).await.into_diagnostic()?;
        dist_file_infos.push(DistFileInfo {
            name: artifact.name.clone(),
            size_bytes,
            size_human: human_size(size_bytes),
            sha256,
            category: artifact.category.clone(),
            group_name: artifact.group_name.clone(),
            group_comment: artifact.group_comment.clone(),
        });
    }

    // Group dist artifacts by category, then by group name within each category.
    let mut category_map: std::collections::BTreeMap<Option<String>, Vec<DistFileInfo>> =
        std::collections::BTreeMap::new();
    for info in dist_file_infos {
        category_map
            .entry(info.category.clone())
            .or_default()
            .push(info);
    }
    let dist_categories: Vec<DistCategory> = category_map
        .into_iter()
        .map(|(category, files)| {
            let mut subgroup_map: std::collections::BTreeMap<
                (Option<String>, Option<String>),
                Vec<DistFileInfo>,
            > = std::collections::BTreeMap::new();
            for f in files {
                subgroup_map
                    .entry((f.group_name.clone(), f.group_comment.clone()))
                    .or_default()
                    .push(f);
            }
            let groups: Vec<DistSubgroup> = subgroup_map
                .into_iter()
                .map(|((name, comment), files)| DistSubgroup {
                    name,
                    comment,
                    files,
                })
                .collect();
            DistCategory { category, groups }
        })
        .collect();
    let has_dist = !dist_categories.is_empty();

    // ── 5. Lay out docs/ ──────────────────────────────────────────────────────
    info!("Laying out {} doc artifact(s) …", doc_artifacts.len());
    let has_docs = !doc_artifacts.is_empty();
    let has_docs_tarball;

    if has_docs {
        let docs_dir = version_dir.join("docs");

        for artifact in &doc_artifacts {
            // Copy the complete target/doc tree - this includes the shared
            // rustdoc CSS, JS, fonts and search indices at the root of the
            // directory in addition to the per-crate HTML subdirectories.
            copy_dir_recursive(artifact.path.clone(), docs_dir.clone()).await?;
        }

        // Rustdoc writes index.html at the root for single-crate projects.
        // For workspaces it may be absent; generate a fallback listing then.
        if !docs_dir.join("index.html").exists() {
            let crate_names = find_doc_crates(&docs_dir).await?;
            write_docs_index(&docs_dir, &crate_names).await?;
        }

        let tarball = version_dir.join("docs.tar.gz");
        let docs_dir_c = docs_dir.clone();
        let tarball_c = tarball.clone();
        tokio::task::spawn_blocking(move || utils::archive_dir(&docs_dir_c, &tarball_c))
            .await
            .into_diagnostic()??;

        has_docs_tarball = true;
    } else {
        has_docs_tarball = false;
    }

    // ── 6. Raw README content ─────────────────────────────────────────────────
    let readme_path = config
        .site
        .readme
        .as_deref()
        .unwrap_or(Path::new("README.md"));

    let readme_md = tokio::fs::read_to_string(readme_path)
        .await
        .unwrap_or_else(|_| {
            warn!("README not found at {}", readme_path.display());
            String::new()
        });

    // Copy any locally-referenced files (e.g. images) from the README's
    // directory into the version directory so they resolve correctly from
    // the generated pages.
    if !readme_md.is_empty() {
        let readme_dir = readme_path.parent().unwrap_or_else(|| Path::new("."));
        for rel in extract_local_refs(&readme_md) {
            let src = readme_dir.join(&rel);
            if src.is_file() {
                let dest = version_dir.join(&rel);
                if let Some(parent) = dest.parent() {
                    tokio::fs::create_dir_all(parent).await.into_diagnostic()?;
                }
                tokio::fs::copy(&src, &dest).await.into_diagnostic()?;
            }
        }
    }

    // ── 7. Raw changelog section ──────────────────────────────────────────────
    let changelog_md = match ChangelogExtractor
        .section(config.changelog.clone(), &version)
        .await
    {
        Ok(section) => section,
        Err(_) => {
            warn!("No changelog entry found for version {version}");
            String::new()
        }
    };

    // ── 8. Version pages (per format) ─────────────────────────────────────────
    info!("Rendering version pages …");

    // Git UI integration: derive the clone URL once and compute the tag name
    // for the current version so the templates can link into the repository UI.
    let git_ui_clone_url: Option<String> = config.git_ui.as_ref().and_then(|cfg| {
        cfg.clone_url.clone().or_else(|| {
            config
                .site
                .base_url
                .as_ref()
                .map(|b| format!("{}/repository.git", b.trim_end_matches('/')))
        })
    });
    let version_tag = config.version_extractor.tag_name(&version);

    for format in &config.site.formats {
        let suffix = format.extension();
        let tmpl_name = format!("version_index.{suffix}");
        let ext = format.extension();

        let (readme_content, changelog_content): (String, String) = match format {
            OutputFormat::Html => (
                render_markdown_html(&readme_md),
                render_markdown_html(&changelog_md),
            ),
            OutputFormat::Gemtext => (
                render_markdown_gemtext(&readme_md),
                render_markdown_gemtext(&changelog_md),
            ),
        };

        // Pre-render HTML versions (only needed for the HTML template)
        let (readme_html, changelog_html) = match format {
            OutputFormat::Html => (
                render_markdown_html(&readme_md),
                render_markdown_html(&changelog_md),
            ),
            OutputFormat::Gemtext => (String::new(), String::new()),
        };

        let mut ctx = Context::new();
        ctx.insert("config", &config);
        ctx.insert("project_name", &config.site.name);
        ctx.insert("lang", &config.site.lang);
        ctx.insert("repo_url", &config.site.repo_url);
        ctx.insert("version", &version);
        ctx.insert("readme_html", &readme_html);
        ctx.insert("changelog_html", &changelog_html);
        ctx.insert("readme_content", &readme_content);
        ctx.insert("changelog_content", &changelog_content);
        ctx.insert("has_docs", &has_docs);
        ctx.insert("has_docs_tarball", &has_docs_tarball);
        ctx.insert("has_dist", &has_dist);
        ctx.insert("dist_categories", &dist_categories);
        ctx.insert("git_ui_enabled", &config.git_ui.is_some());
        ctx.insert("git_ui_clone_url", &git_ui_clone_url);
        ctx.insert("version_tag", &version_tag);
        ctx.insert("root_path", "../");

        let content = tera.render(&tmpl_name, &ctx).into_diagnostic()?;
        tokio::fs::write(version_dir.join(format!("index.{ext}")), content)
            .await
            .into_diagnostic()?;
    }

    // ── 9. Root index.html + Atom feed ──────────────────────────────────────
    info!("Rendering root index and Atom feed …");
    // Collect every known version from the version extractor, ensure the
    // current version is present (handles untagged builds), then sort newest-first.
    let mut all_versions = config.version_extractor.extract_all().await?;
    if !all_versions.iter().any(|v| v.version == version) {
        all_versions.push(version_info.clone());
    }
    all_versions.sort_by(|a, b| compare_versions(&b.version, &a.version));

    // Build the template-friendly list (version string + optional date string).
    let version_entries: Vec<VersionEntry> =
        all_versions.iter().map(VersionEntry::from_info).collect();

    let base_url = config
        .site
        .base_url
        .as_deref()
        .map(|u| u.trim_end_matches('/'));

    for format in &config.site.formats {
        let suffix = format.extension();
        let tmpl_name = format!("root_index.{suffix}");
        let ext = format.extension();

        let mut ctx = Context::new();
        ctx.insert("config", &config);
        ctx.insert("project_name", &config.site.name);
        ctx.insert("lang", &config.site.lang);
        ctx.insert("repo_url", &config.site.repo_url);
        ctx.insert("versions", &version_entries);
        ctx.insert("atom_feed", ATOM_FEED_FILENAME);
        ctx.insert("git_ui_enabled", &config.git_ui.is_some());
        ctx.insert("git_ui_clone_url", &git_ui_clone_url);
        ctx.insert("root_path", "");

        let content = tera.render(&tmpl_name, &ctx).into_diagnostic()?;
        tokio::fs::write(output_dir.join(format!("index.{ext}")), content)
            .await
            .into_diagnostic()?;
    }

    // ── 10. Atom feed ─────────────────────────────────────────────────────────
    // Load all changelog sections once so we can embed release notes in feed entries.
    let changelog_sections = match ChangelogExtractor
        .all_sections(config.changelog.clone())
        .await
    {
        Ok(map) => map,
        Err(_) => {
            warn!("Could not load changelog for Atom feed; entries will have no content");
            std::collections::HashMap::new()
        }
    };

    let atom_xml = generate_atom_feed(
        &config.site.name,
        &all_versions,
        base_url,
        &changelog_sections,
    );
    tokio::fs::write(output_dir.join(ATOM_FEED_FILENAME), atom_xml)
        .await
        .into_diagnostic()?;

    // ── 11. `latest` symlink ──────────────────────────────────────────────────
    if let Some(latest) = all_versions.first() {
        update_latest_symlink(output_dir, &latest.version)?;
    }

    Ok(())
}

// ── Private helpers ───────────────────────────────────────────────────────────

/// Scan `docs_dir` for subdirectories that contain an `index.html` and return
/// their names. Used to build a fallback listing when rustdoc itself did not
/// generate a root `index.html` (typical for multi-crate workspaces).
async fn find_doc_crates(docs_dir: &Path) -> Result<Vec<String>> {
    let mut names = Vec::new();
    let mut entries = tokio::fs::read_dir(docs_dir).await.into_diagnostic()?;
    while let Some(entry) = entries.next_entry().await.into_diagnostic()? {
        let path = entry.path();
        if path.is_dir() && path.join("index.html").exists() {
            names.push(entry.file_name().to_string_lossy().into_owned());
        }
    }
    Ok(names)
}

/// Write a `docs/index.html` that either redirects straight to the single
/// crate's docs (one crate) or lists all crates (multiple crates).
async fn write_docs_index(docs_dir: &Path, crate_names: &[String]) -> Result<()> {
    let html = if crate_names.len() == 1 {
        format!(
            "<!DOCTYPE html><html><head>\
            <meta http-equiv=\"refresh\" content=\"0;url={}/index.html\">\
            </head></html>",
            crate_names[0]
        )
    } else {
        let items = crate_names
            .iter()
            .map(|n| format!("  <li><a href=\"{n}/index.html\">{n}</a></li>"))
            .collect::<Vec<_>>()
            .join("\n");
        format!(
            "<!DOCTYPE html>\n<html><head><meta charset=\"utf-8\">\
            <title>Documentation</title></head>\
            <body><h1>Documentation</h1><ul>\n{items}\n</ul></body></html>"
        )
    };

    tokio::fs::write(docs_dir.join("index.html"), html)
        .await
        .into_diagnostic()
}

/// Recursively copy the contents of `src` into `dst`.
///
/// Uses explicit boxing to satisfy the compiler for the async recursive call.
fn copy_dir_recursive(
    src: PathBuf,
    dst: PathBuf,
) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
    Box::pin(async move {
        tokio::fs::create_dir_all(&dst).await.into_diagnostic()?;
        let mut entries = tokio::fs::read_dir(&src).await.into_diagnostic()?;
        while let Some(entry) = entries.next_entry().await.into_diagnostic()? {
            let src_path = entry.path();
            let dst_path = dst.join(entry.file_name());
            if src_path.is_dir() {
                copy_dir_recursive(src_path, dst_path).await?;
            } else {
                tokio::fs::copy(&src_path, &dst_path)
                    .await
                    .into_diagnostic()?;
            }
        }
        Ok(())
    })
}

/// Compare two version strings, preferring semver ordering and falling back
/// to lexicographic comparison for non-semver strings (e.g. git describe output).
fn strip_v(s: &str) -> &str {
    s.strip_prefix('v').unwrap_or(s)
}

fn compare_versions(a: &str, b: &str) -> std::cmp::Ordering {
    match (
        semver::Version::parse(strip_v(a)),
        semver::Version::parse(strip_v(b)),
    ) {
        (Ok(va), Ok(vb)) => va.cmp(&vb),
        _ => a.cmp(b),
    }
}

/// Compute a lowercase hex-encoded SHA-256 digest of `data`.
fn hex_sha256(data: &[u8]) -> String {
    let mut hasher = Sha256::new();
    hasher.update(data);
    hasher
        .finalize()
        .iter()
        .map(|b| format!("{b:02x}"))
        .collect()
}

/// Format a byte count as a human-readable string (e.g. "1.4 MB").
fn human_size(bytes: u64) -> String {
    const KIB: u64 = 1024;
    const MIB: u64 = KIB * 1024;
    const GIB: u64 = MIB * 1024;
    if bytes >= GIB {
        format!("{:.1} GB", bytes as f64 / GIB as f64)
    } else if bytes >= MIB {
        format!("{:.1} MB", bytes as f64 / MIB as f64)
    } else if bytes >= KIB {
        format!("{:.1} KB", bytes as f64 / KIB as f64)
    } else {
        format!("{bytes} B")
    }
}

/// Escape the five XML predefined characters in a string.
fn xml_escape(s: &str) -> String {
    s.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&apos;")
}

/// Generate an Atom 1.0 feed listing all known releases.
///
/// - `base_url`: when provided (already stripped of trailing `/`), used to
///   build `<link>` and `<id>` elements with absolute URLs.  When absent,
///   a `urn:` based ID is used and no `<link>` elements are emitted.
/// - `changelog_sections`: map from version string to Markdown release-note
///   body.  When a matching entry is found it is rendered to HTML and included
///   as a `<content type="html">` element in the Atom entry.
fn generate_atom_feed(
    project_name: &str,
    versions: &[VersionInfo],
    base_url: Option<&str>,
    changelog_sections: &std::collections::HashMap<String, String>,
) -> String {
    let now: DateTime<Utc> = Utc::now();

    // The feed's <updated> is the most-recent entry date, or now as fallback.
    let feed_updated = versions.iter().filter_map(|v| v.date).max().unwrap_or(now);

    let feed_updated_str = feed_updated.to_rfc3339_opts(SecondsFormat::Secs, true);

    // Feed-level <id> and self-link.
    let feed_id = match base_url {
        Some(base) => format!("{base}/{ATOM_FEED_FILENAME}"),
        None => format!("urn:abbaye:feed:{}", xml_escape(project_name)),
    };

    let self_link = match base_url {
        Some(base) => format!(
            "  <link rel=\"self\" href=\"{}/{ATOM_FEED_FILENAME}\"/>\n",
            xml_escape(base)
        ),
        None => String::new(),
    };
    let alt_link = match base_url {
        Some(base) => format!("  <link href=\"{}\"/>\n", xml_escape(base)),
        None => String::new(),
    };

    let entries: String = versions
        .iter()
        .map(|vi| {
            let entry_date = vi.date.unwrap_or(now);
            let entry_date_str = entry_date.to_rfc3339_opts(SecondsFormat::Secs, true);
            let v_escaped = xml_escape(&vi.version);

            let entry_id = match base_url {
                Some(base) => format!("{base}/{v_escaped}/"),
                None => format!(
                    "urn:abbaye:release:{}:{v_escaped}",
                    xml_escape(project_name)
                ),
            };

            let entry_link = match base_url {
                Some(base) => format!("    <link href=\"{base}/{v_escaped}/\"/>\n"),
                None => String::new(),
            };

            // Render the changelog section (if any) to HTML, then XML-escape
            // it for embedding inside <content type="html">.
            let content_element = match changelog_sections.get(&vi.version) {
                Some(md) if !md.is_empty() => {
                    let html = render_markdown_html(md);
                    format!(
                        "    <content type=\"html\">{}</content>\n",
                        xml_escape(&html)
                    )
                }
                _ => String::new(),
            };

            format!(
                "  <entry>\n\
                 \x20   <title>{v_escaped}</title>\n\
                 \x20   <id>{entry_id}</id>\n\
                 \x20   <updated>{entry_date_str}</updated>\n\
                 {entry_link}\
                 {content_element}\
                 \x20 </entry>"
            )
        })
        .collect::<Vec<_>>()
        .join("\n");

    format!(
        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
         <feed xmlns=\"http://www.w3.org/2005/Atom\">\n\
         \x20 <title>{name} Releases</title>\n\
         {self_link}\
         {alt_link}\
         \x20 <updated>{feed_updated_str}</updated>\n\
         \x20 <id>{feed_id}</id>\n\
         {entries}\n\
         </feed>\n",
        name = xml_escape(project_name),
    )
}

/// Create or replace the `latest` symlink in `output_dir`, pointing to
/// `version_dir_name`.
///
/// On non-Unix platforms a meta-refresh redirect page is written instead.
fn update_latest_symlink(output_dir: &Path, version_dir_name: &str) -> Result<()> {
    let link = output_dir.join("latest");

    #[cfg(unix)]
    {
        // Remove any stale symlink or file before (re-)creating it.
        if link.exists() || link.is_symlink() {
            std::fs::remove_file(&link).into_diagnostic()?;
        }
        std::os::unix::fs::symlink(version_dir_name, &link).into_diagnostic()?;
    }

    #[cfg(not(unix))]
    {
        std::fs::create_dir_all(&link).into_diagnostic()?;
        std::fs::write(
            link.join("index.html"),
            format!(
                "<!DOCTYPE html><html><head>\
                <meta http-equiv=\"refresh\" content=\"0;url=../{version_dir_name}/\">\
                </head></html>"
            ),
        )
        .into_diagnostic()?;
    }

    Ok(())
}

/// Register templates for each configured output format, supporting theme overrides.
///
/// For each `format` in `formats` and each `(base_name, html_builtin, gmi_builtin)`
/// tuple in `templates`, registers a Tera template named `"{base_name}.{ext}"` —
/// first checking for a user override at `theme_path / "{base_name}.{ext}.j2"`,
/// otherwise falling back to the corresponding builtin constant.
///
/// After registering the format-specific templates, also loads any extra `.j2`
/// files from the theme directory that weren't explicitly registered (see
/// [`load_extra_theme_templates`]).
pub(crate) fn register_format_templates(
    tera: &mut Tera,
    theme_path: &Path,
    formats: &[OutputFormat],
    templates: &[(&str, &str, &str)],
) -> Result<()> {
    // Register the shared HTML base template so child templates can
    // {% extends "base.html" %}.  A theme override at
    // theme/base.html.j2 takes precedence when present.
    let base_theme = theme_path.join("base.html.j2");
    if base_theme.is_file() {
        tera.add_template_file(&base_theme, Some("base.html"))
            .into_diagnostic()?;
    } else {
        tera.add_raw_template("base.html", TEMPLATE_BASE_HTML)
            .into_diagnostic()?;
    }

    for format in formats {
        let ext = format.extension();
        for (template_base, builtin_html, builtin_gmi) in templates {
            let name = format!("{template_base}.{ext}");
            let builtin = match format {
                OutputFormat::Html => builtin_html,
                OutputFormat::Gemtext => builtin_gmi,
            };
            let theme_file = theme_path.join(format!("{template_base}.{ext}.j2"));
            if theme_file.is_file() {
                tera.add_template_file(&theme_file, Some(&name))
                    .into_diagnostic()?;
            } else {
                tera.add_raw_template(&name, builtin).into_diagnostic()?;
            }
        }
    }

    let skip_names: Vec<String> = formats
        .iter()
        .flat_map(|fmt| {
            let ext = fmt.extension();
            templates
                .iter()
                .map(move |(base, _, _)| format!("{base}.{ext}"))
        })
        .collect();
    let skip_refs: Vec<&str> = skip_names.iter().map(|s| s.as_str()).collect();
    load_extra_theme_templates(tera, theme_path, &skip_refs)?;
    Ok(())
}

/// Scans `theme_path` for any `*.j2` files whose stem (the name without the
/// `.j2` suffix, e.g. `"base.html"`) is **not** already listed in `skip`, and
/// loads each one into `tera` under that stem name.
///
/// This makes user-supplied helper or base templates - e.g. a `base.html.j2`
/// referenced by `{% extends "base.html" %}` in a customised main template -
/// available at render time without the caller needing to enumerate them.
pub(crate) fn load_extra_theme_templates(
    tera: &mut tera::Tera,
    theme_path: &std::path::Path,
    skip: &[&str],
) -> miette::Result<()> {
    let entries = match std::fs::read_dir(theme_path) {
        Ok(e) => e,
        Err(_) => return Ok(()), // theme dir absent - nothing to do
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("j2") {
            continue;
        }
        let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
            continue;
        };
        if skip.contains(&stem) {
            continue;
        }
        tera.add_template_file(&path, Some(stem)).map_err(|e| {
            miette::miette!("failed to load theme template {}: {e}", path.display())
        })?;
    }
    Ok(())
}