lore_engine/engine/

folder_tree.rs

//! Folder tree builder for the sidebar.
//!
//! Takes a flat list of pages and produces a flattened depth-annotated tree
//! suitable for rendering in a single `ListView`. Pure engine code — no Qt.

use serde::Serialize;
use std::collections::{BTreeMap, BTreeSet, HashSet};

use crate::types::PageListEntry;

/// A single row in the flattened tree output.
#[derive(Debug, Serialize, Clone)]
pub struct TreeRow {
    pub slug: String,
    pub title: String,
    pub depth: usize,
    pub is_folder: bool,
    pub is_placeholder: bool,
    pub is_expanded: bool,
    pub file_path: Option<String>,
}

/// Build a flattened tree from a list of pages.
///
/// `expanded` is the set of folder paths currently expanded.
/// Returns rows in display order: at each level, folders first (alpha-sorted),
/// then pages (alpha-sorted by title). Only emits children of expanded folders.
pub fn build_tree(pages: &[PageListEntry], expanded: &HashSet<String>) -> Vec<TreeRow> {
    // Group pages by their folder path.
    // Key = folder path (empty string for root), Value = list of pages in that folder.
    let mut folder_pages: BTreeMap<String, Vec<&PageListEntry>> = BTreeMap::new();
    let mut all_folder_paths: BTreeSet<String> = BTreeSet::new();

    for page in pages {
        let folder = if let Some(ref fp) = page.file_path {
            let fp_normalized = fp.replace('\\', "/");
            match fp_normalized.rfind('/') {
                Some(pos) => {
                    let folder = fp_normalized[..pos].to_string();
                    // Register this folder and all intermediate parents
                    register_folder_hierarchy(&folder, &mut all_folder_paths);
                    folder
                }
                None => String::new(), // root-level file
            }
        } else {
            String::new() // placeholders go to root
        };

        folder_pages.entry(folder).or_default().push(page);
    }

    // Sort pages within each folder by title (case-insensitive)
    for pages_in_folder in folder_pages.values_mut() {
        pages_in_folder.sort_by(|a, b| {
            a.title
                .to_lowercase()
                .cmp(&b.title.to_lowercase())
                .then_with(|| a.title.cmp(&b.title))
        });
    }

    // Build the tree depth-first
    let mut result = Vec::new();
    emit_level(
        "", // parent path (empty = root level)
        0,
        &all_folder_paths,
        &folder_pages,
        expanded,
        &mut result,
    );

    result
}

/// Collect all unique folder paths from a page list.
/// Used to populate `expanded_folders` for "expand all" behavior.
pub fn collect_all_folders(pages: &[PageListEntry]) -> HashSet<String> {
    let mut folders = HashSet::new();
    for page in pages {
        if let Some(ref fp) = page.file_path {
            let fp_normalized = fp.replace('\\', "/");
            if let Some(pos) = fp_normalized.rfind('/') {
                let folder = fp_normalized[..pos].to_string();
                register_folder_hierarchy(&folder, &mut folders);
            }
        }
    }
    folders
}

/// Register a folder and all its ancestors into a set.
/// Works with both `BTreeSet` and `HashSet` via the `InsertSet` trait.
fn register_folder_hierarchy(folder: &str, set: &mut impl InsertSet) {
    if folder.is_empty() || set.has(folder) {
        return;
    }
    set.add(folder.to_string());
    if let Some(pos) = folder.rfind('/') {
        register_folder_hierarchy(&folder[..pos], set);
    }
}

/// Trait for sets that support insert + contains (`BTreeSet`, `HashSet`).
trait InsertSet {
    fn add(&mut self, value: String);
    fn has(&self, value: &str) -> bool;
}

impl InsertSet for BTreeSet<String> {
    fn add(&mut self, value: String) { self.insert(value); }
    fn has(&self, value: &str) -> bool { self.contains(value) }
}

impl InsertSet for HashSet<String> {
    fn add(&mut self, value: String) { self.insert(value); }
    fn has(&self, value: &str) -> bool { self.contains(value) }
}

/// Recursively emit rows for a given level of the tree.
fn emit_level(
    parent: &str,
    depth: usize,
    all_folders: &BTreeSet<String>,
    folder_pages: &BTreeMap<String, Vec<&PageListEntry>>,
    expanded: &HashSet<String>,
    result: &mut Vec<TreeRow>,
) {
    // Find child folders at this level
    let child_folders: Vec<&String> = all_folders
        .iter()
        .filter(|f| is_direct_child(f, parent))
        .collect();

    // Emit folder rows first (already sorted since BTreeSet is ordered)
    for folder_path in &child_folders {
        let folder_name = match folder_path.rfind('/') {
            Some(pos) => &folder_path[pos + 1..],
            None => folder_path.as_str(),
        };

        let is_expanded = expanded.contains(folder_path.as_str());

        result.push(TreeRow {
            slug: String::new(),
            title: folder_name.to_string(),
            depth,
            is_folder: true,
            is_placeholder: false,
            is_expanded,
            file_path: Some((*folder_path).clone()),
        });

        // If expanded, recurse into children
        if is_expanded {
            emit_level(folder_path, depth + 1, all_folders, folder_pages, expanded, result);
        }
    }

    // Emit page rows at this level
    let folder_key = parent.to_string();
    if let Some(pages) = folder_pages.get(&folder_key) {
        for page in pages {
            result.push(TreeRow {
                slug: page.slug.clone(),
                title: page.title.clone(),
                depth,
                is_folder: false,
                is_placeholder: page.is_placeholder,
                is_expanded: false,
                file_path: page.file_path.clone(),
            });
        }
    }
}

/// Check if `folder` is a direct child of `parent`.
/// E.g., "notes" is a direct child of "" (root), "notes/sub" is a direct child of "notes".
fn is_direct_child(folder: &str, parent: &str) -> bool {
    if parent.is_empty() {
        // Direct child of root: no '/' in the folder path
        !folder.contains('/')
    } else {
        // Must start with "parent/" and have no further '/' after that
        match folder.strip_prefix(parent) {
            Some(rest) => {
                rest.starts_with('/') && !rest[1..].contains('/')
            }
            None => false,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::PageListEntry;

    fn entry(slug: &str, title: &str, file_path: Option<&str>) -> PageListEntry {
        PageListEntry {
            slug: slug.to_string(),
            title: title.to_string(),
            is_placeholder: file_path.is_none(),
            file_path: file_path.map(|s| s.to_string()),
        }
    }

    #[test]
    fn flat_pages_no_folders() {
        let pages = vec![
            entry("bravo", "Bravo", Some("Bravo.md")),
            entry("alpha", "Alpha", Some("Alpha.md")),
        ];
        let expanded = HashSet::new();
        let tree = build_tree(&pages, &expanded);

        assert_eq!(tree.len(), 2);
        assert_eq!(tree[0].title, "Alpha");
        assert_eq!(tree[1].title, "Bravo");
        assert!(!tree[0].is_folder);
        assert_eq!(tree[0].depth, 0);
    }

    #[test]
    fn folder_collapsed_hides_children() {
        let pages = vec![
            entry("notes/hello", "Hello", Some("notes/Hello.md")),
            entry("root-page", "Root Page", Some("Root Page.md")),
        ];
        let expanded = HashSet::new(); // notes folder NOT expanded
        let tree = build_tree(&pages, &expanded);

        // Should show: folder "notes" (collapsed) + "Root Page"
        assert_eq!(tree.len(), 2);
        assert!(tree[0].is_folder);
        assert_eq!(tree[0].title, "notes");
        assert!(!tree[0].is_expanded);
        assert_eq!(tree[1].title, "Root Page");
    }

    #[test]
    fn folder_expanded_shows_children() {
        let pages = vec![
            entry("notes/hello", "Hello", Some("notes/Hello.md")),
            entry("root-page", "Root Page", Some("Root Page.md")),
        ];
        let mut expanded = HashSet::new();
        expanded.insert("notes".to_string());
        let tree = build_tree(&pages, &expanded);

        // Should show: folder "notes" (expanded), "Hello" (depth 1), "Root Page" (depth 0)
        assert_eq!(tree.len(), 3);
        assert!(tree[0].is_folder);
        assert_eq!(tree[0].title, "notes");
        assert!(tree[0].is_expanded);
        assert_eq!(tree[1].title, "Hello");
        assert_eq!(tree[1].depth, 1);
        assert_eq!(tree[2].title, "Root Page");
        assert_eq!(tree[2].depth, 0);
    }

    #[test]
    fn nested_folders() {
        let pages = vec![
            entry("a/b/deep", "Deep", Some("a/b/Deep.md")),
            entry("a/shallow", "Shallow", Some("a/Shallow.md")),
        ];
        let mut expanded = HashSet::new();
        expanded.insert("a".to_string());
        expanded.insert("a/b".to_string());
        let tree = build_tree(&pages, &expanded);

        // a (folder, depth 0) → a/b (folder, depth 1) → Deep (depth 2) → Shallow (depth 1)
        assert_eq!(tree.len(), 4);
        assert_eq!(tree[0].title, "a");
        assert_eq!(tree[0].depth, 0);
        assert!(tree[0].is_folder);
        assert_eq!(tree[1].title, "b");
        assert_eq!(tree[1].depth, 1);
        assert!(tree[1].is_folder);
        assert_eq!(tree[2].title, "Deep");
        assert_eq!(tree[2].depth, 2);
        assert_eq!(tree[3].title, "Shallow");
        assert_eq!(tree[3].depth, 1);
    }

    #[test]
    fn placeholders_at_root() {
        let pages = vec![
            entry("notes/real", "Real", Some("notes/Real.md")),
            entry("phantom", "Phantom", None), // placeholder
        ];
        let expanded = HashSet::new();
        let tree = build_tree(&pages, &expanded);

        // notes (folder), Phantom (placeholder at root)
        assert_eq!(tree.len(), 2);
        assert!(tree[0].is_folder);
        assert_eq!(tree[1].title, "Phantom");
        assert!(tree[1].is_placeholder);
        assert_eq!(tree[1].depth, 0);
    }

    #[test]
    fn folders_sorted_before_pages() {
        let pages = vec![
            entry("zebra", "Zebra", Some("Zebra.md")),
            entry("archive/old", "Old", Some("archive/Old.md")),
            entry("alpha", "Alpha", Some("Alpha.md")),
        ];
        let expanded = HashSet::new();
        let tree = build_tree(&pages, &expanded);

        // archive (folder), Alpha (page), Zebra (page)
        assert_eq!(tree.len(), 3);
        assert!(tree[0].is_folder);
        assert_eq!(tree[0].title, "archive");
        assert_eq!(tree[1].title, "Alpha");
        assert_eq!(tree[2].title, "Zebra");
    }

    #[test]
    fn collect_all_folders_works() {
        let pages = vec![
            entry("a/b/c", "C", Some("a/b/C.md")),
            entry("x/y", "Y", Some("x/Y.md")),
        ];
        let folders = collect_all_folders(&pages);
        assert!(folders.contains("a"));
        assert!(folders.contains("a/b"));
        assert!(folders.contains("x"));
        assert_eq!(folders.len(), 3);
    }
}