Chapter 13: Internal Linking, Navigation, and Table of Contents Generation

use std::collections::HashMap;
use std::path::PathBuf;
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};

// New struct for Table of Contents entries
#[derive(Debug, Serialize, Clone)]
pub struct TocEntry {
    pub level: u32,
    pub text: String,
    pub id: String, // Anchor ID for the heading
}

// New struct for Navigation entries
#[derive(Debug, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct NavEntry {
    pub title: String,
    pub url: String,
    pub weight: i32,
    pub children: Vec<NavEntry>,
    #[serde(skip)] // Don't serialize menu name itself
    pub menu_name: Option<String>,
}

impl NavEntry {
    pub fn new(title: String, url: String, weight: i32, menu_name: Option<String>) -> Self {
        NavEntry {
            title,
            url,
            weight,
            children: Vec::new(),
            menu_name,
        }
    }
}

// Existing Frontmatter struct, add new fields for navigation
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(default)] // Allows missing fields to use their default values
pub struct Frontmatter {
    pub title: String,
    pub date: Option<DateTime<Utc>>,
    pub draft: bool,
    pub description: Option<String>,
    pub slug: Option<String>,
    pub weight: i32, // For ordering in navigation
    pub keywords: Vec<String>,
    pub tags: Vec<String>,
    pub categories: Vec<String>,
    pub author: String,
    pub show_reading_time: bool,
    pub show_table_of_contents: bool,
    pub show_comments: bool,
    pub toc: bool, // Legacy or explicit TOC control
    pub menu: Vec<String>, // New: Specifies which menus this page belongs to
    pub template: Option<String>, // Optional template override
}

impl Default for Frontmatter {
    fn default() -> Self {
        Frontmatter {
            title: "Untitled".to_string(),
            date: Some(Utc::now()),
            draft: false,
            description: None,
            slug: None,
            weight: 0,
            keywords: Vec::new(),
            tags: Vec::new(),
            categories: Vec::new(),
            author: "AI Expert".to_string(),
            show_reading_time: true,
            show_table_of_contents: true,
            show_comments: false,
            toc: true,
            menu: Vec::new(), // Default to no menus
            template: None,
        }
    }
}

// Existing Page struct, add toc and updated_content fields
#[derive(Debug, Clone)]
pub struct Page {
    pub file_path: PathBuf, // Original path relative to content dir
    pub relative_path: PathBuf, // Relative path from content root, used for slug generation
    pub frontmatter: Frontmatter,
    pub markdown_content: String, // Original markdown
    pub rendered_html: String, // HTML after initial markdown conversion (before link resolution)
    pub final_html: String, // HTML after link resolution and component processing
    pub url_path: String, // Final public URL path (e.g., /posts/my-post/)
    pub toc: Vec<TocEntry>, // Table of Contents for this page
    pub collection: String, // e.g., "posts", "pages", "topics"
}

impl Page {
    pub fn new(
        file_path: PathBuf,
        relative_path: PathBuf,
        frontmatter: Frontmatter,
        markdown_content: String,
        rendered_html: String,
        url_path: String,
        collection: String,
    ) -> Self {
        Page {
            file_path,
            relative_path,
            frontmatter,
            markdown_content,
            rendered_html,
            final_html: String::new(), // Will be populated later
            url_path,
            toc: Vec::new(), // Will be populated during processing
            collection,
        }
    }

    /// Returns the canonical slug for the page, prioritizing frontmatter slug.
    pub fn get_slug(&self) -> String {
        if let Some(slug) = &self.frontmatter.slug {
            slug.clone()
        } else {
            // Derive from file_path, e.g., "my-post.md" -> "my-post"
            self.relative_path
                .file_stem()
                .and_then(|s| s.to_str())
                .unwrap_or("untitled")
                .to_string()
        }
    }
}

# Cargo.toml
[dependencies]
# ... other dependencies
pulldown-cmark = "0.10"
pulldown-cmark-to-md = "0.4" # Add this for slugify
regex = "1.10" # For link rewriting later
lazy_static = "1.4" # For regex global
log = "0.4"

use pulldown_cmark::{Parser, Event, Tag, Options, CowStr};
use pulldown_cmark_to_md::slugify; // Import slugify
use std::collections::HashMap;
use std::path::PathBuf;
use log::{warn, info};
use regex::Regex;
use lazy_static::lazy_static;

use crate::content::{Frontmatter, Page, TocEntry}; // Import TocEntry

/// Parses frontmatter from a string.
pub fn parse_frontmatter(content: &str) -> Result<(Frontmatter, &str), String> {
    // ... (existing parse_frontmatter code) ...
    // (Assuming this function is already implemented from previous chapters)
    // Example placeholder:
    if content.starts_with("+++") {
        if let Some(end_idx) = content[3..].find("+++") {
            let frontmatter_str = &content[3..3 + end_idx];
            let remaining_content = &content[3 + end_idx + 3..];
            match toml::from_str::<Frontmatter>(frontmatter_str) {
                Ok(fm) => return Ok((fm, remaining_content)),
                Err(e) => return Err(format!("Failed to parse frontmatter: {}", e)),
            }
        }
    } else if content.starts_with("---") {
        if let Some(end_idx) = content[3..].find("---") {
            let frontmatter_str = &content[3..3 + end_idx];
            let remaining_content = &content[3 + end_idx + 3..];
            match serde_yaml::from_str::<Frontmatter>(frontmatter_str) {
                Ok(fm) => return Ok((fm, remaining_content)),
                Err(e) => return Err(format!("Failed to parse frontmatter: {}", e)),
            }
        }
    }
    // If no frontmatter, return default and full content
    Ok((Frontmatter::default(), content))
}


/// Converts Markdown content to HTML, extracts ToC entries, and identifies raw internal links.
pub fn markdown_to_html(markdown: &str) -> (String, Vec<TocEntry>) {
    let mut options = Options::empty();
    options.insert(Options::ENABLE_TABLES);
    options.insert(Options::ENABLE_FOOTNOTES);
    options.insert(Options::ENABLE_STRIKETHROUGH);
    options.insert(Options::ENABLE_TASKLISTS);
    options.insert(Options::ENABLE_SMART_PUNCTUATION);

    let parser = Parser::new_ext(markdown, options);

    let mut html_output = String::new();
    let mut toc_entries: Vec<TocEntry> = Vec::new();
    let mut current_heading_text = String::new();
    let mut heading_levels: HashMap<String, u32> = HashMap::new(); // To track duplicate slugs

    // This is a custom event iterator that processes events and collects data
    let mut events: Vec<Event> = Vec::new();

    for event in parser {
        match event {
            Event::Start(Tag::Heading(level, _, _)) => {
                current_heading_text.clear();
                events.push(Event::Start(Tag::Heading(level, None, Vec::new()))); // Push a dummy start tag for now
            }
            Event::Text(text) => {
                current_heading_text.push_str(&text);
                events.push(Event::Text(text));
            }
            Event::End(Tag::Heading(level, _, _)) => {
                let mut id = slugify(&current_heading_text);
                // Handle duplicate IDs
                let count = heading_levels.entry(id.clone()).or_insert(0);
                *count += 1;
                if *count > 1 {
                    id = format!("{}-{}", id, count - 1); // Append -1, -2 etc.
                }

                toc_entries.push(TocEntry {
                    level: level as u32,
                    text: current_heading_text.clone(),
                    id: id.clone(),
                });

                // Replace the dummy start tag with the actual one, including the generated ID
                if let Some(Event::Start(Tag::Heading(_, _, _))) = events.last_mut() {
                    *events.last_mut().unwrap() = Event::Start(Tag::Heading(level, Some(CowStr::from(id)), Vec::new()));
                } else {
                    // This should ideally not happen if logic is correct, but good for debugging
                    warn!("Failed to find matching start tag for heading: {}", current_heading_text);
                }
                events.push(Event::End(Tag::Heading(level, None, Vec::new())));
            }
            _ => events.push(event), // Push all other events as is
        }
    }

    pulldown_cmark::html::push_html(&mut html_output, events.into_iter());

    (html_output, toc_entries)
}

/// Rewrites internal links in the HTML content.
/// It takes a map of source content paths to their final public URLs.
pub fn rewrite_internal_links(html: &str, url_map: &HashMap<PathBuf, String>) -> String {
    // Regex to find href attributes in <a> tags
    lazy_static! {
        static ref LINK_RE: Regex = Regex::new(r#"<a\s+(?:[^>]*?\s+)?href=["']([^"']+)["']"#).unwrap();
    }

    LINK_RE.replace_all(html, |caps: &regex::Captures| {
        let original_href = &caps[1];
        
        // Check if the link looks like an internal content path (e.g., ends with .md or starts with /content/)
        // This is a simplification; a more robust solution might use a custom link syntax.
        // For now, let's assume any link starting with '/' or not having a scheme (http/https)
        // AND matching a known content path should be resolved.
        
        // Let's assume links starting with '/' and ending with '.md' are internal references
        // e.g., `/posts/my-post.md` or `../other-post.md`
        // We'll normalize these to `PathBuf` relative to the content root.
        
        let mut resolved_href = original_href.to_string();

        // Simple check: if it ends with .md, try to resolve it.
        // A more advanced system would use `ref` or `relref` shortcodes.
        if original_href.ends_with(".md") {
            // Attempt to resolve based on content directory structure
            // This needs context of the current page's path. For now, we'll
            // assume all paths in `url_map` are relative to the content root.
            // A perfect solution would need the source_path of the current page being processed.
            
            // For this implementation, we'll assume `original_href` is already
            // a path relative to the content root, e.g., "posts/my-article.md"
            // or starts with "/" and then a content path.
            let mut content_path_buf = PathBuf::from(original_href.trim_start_matches('/'));

            // If the link is just a filename (e.g., "other-page.md"), we might need
            // more context to find it. For now, we assume full relative paths from content root.
            if let Some(url) = url_map.get(&content_path_buf) {
                resolved_href = url.clone();
                info!("Rewrote internal link '{}' to '{}'", original_href, resolved_href);
            } else {
                warn!("Could not resolve internal link: '{}'. File not found in content map.", original_href);
            }
        } else if original_href.starts_with('/') && !original_href.starts_with("//") {
            // This could be an absolute path to another content page or a static asset.
            // For content pages, we need to map `/my-page` to `/my-page/`.
            // Let's assume if it matches an entry in url_map (after stripping trailing slash for comparison), it's a content page.
            let mut potential_path = PathBuf::from(original_href.trim_start_matches('/'));
            if potential_path.extension().is_none() { // If it's a directory-like path, e.g., /posts/my-post
                potential_path = potential_path.join("index.md"); // Assume index.md for content
            }

            if let Some(url) = url_map.get(&potential_path) {
                resolved_href = url.clone();
                info!("Rewrote internal link '{}' to '{}'", original_href, resolved_href);
            } else {
                // It might be a static asset or a link we don't manage, leave as is.
                // Or log if it's expected to be a content link but isn't found.
            }
        }
        
        format!(r#"href="{resolved_href}""#)
    }).to_string()
}

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::fs;
use std::error::Error;
use log::{info, warn, error};
use crate::content::{Page, Frontmatter, NavEntry};
use crate::processor;
use crate::template_engine::TemplateEngine;
use rayon::prelude::*; // For parallel processing

// Configuration structure (from previous chapters)
#[derive(Debug, Clone)]
pub struct SiteConfig {
    pub content_dir: PathBuf,
    pub output_dir: PathBuf,
    pub templates_dir: PathBuf,
    pub static_dir: Option<PathBuf>,
    pub base_url: String,
}

impl Default for SiteConfig {
    fn default() -> Self {
        SiteConfig {
            content_dir: PathBuf::from("content"),
            output_dir: PathBuf::from("public"),
            templates_dir: PathBuf::from("templates"),
            static_dir: Some(PathBuf::from("static")),
            base_url: "/".to_string(),
        }
    }
}

pub struct Site {
    pub config: SiteConfig,
    pub pages: Vec<Page>,
    pub template_engine: TemplateEngine,
    pub page_url_map: HashMap<PathBuf, String>, // Maps source content path to final URL
    pub navigation_menus: HashMap<String, Vec<NavEntry>>, // Stores grouped navigation entries
}

impl Site {
    pub fn new(config: SiteConfig) -> Result<Self, Box<dyn Error>> {
        let template_engine = TemplateEngine::new(&config.templates_dir)?;
        Ok(Site {
            config,
            pages: Vec::new(),
            template_engine,
            page_url_map: HashMap::new(),
            navigation_menus: HashMap::new(),
        })
    }

    /// Scans content directory, parses frontmatter and markdown, and populates `self.pages`.
    pub fn load_content(&mut self) -> Result<(), Box<dyn Error>> {
        info!("Loading content from: {:?}", self.config.content_dir);
        let content_dir = &self.config.content_dir;

        let mut raw_pages = Vec::new();
        for entry in fs::read_dir(content_dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_file() && path.extension().map_or(false, |ext| ext == "md") {
                raw_pages.push(path);
            } else if path.is_dir() {
                // Recursively find markdown files in subdirectories
                self.walk_dir_for_markdown(&path, content_dir, &mut raw_pages)?;
            }
        }

        // Process pages in parallel
        let processed_pages: Vec<Page> = raw_pages.into_par_iter().filter_map(|path| {
            match self.process_single_content_file(&path, content_dir) {
                Ok(page) => Some(page),
                Err(e) => {
                    error!("Failed to process content file {:?}: {}", path, e);
                    None
                }
            }
        }).collect();

        for page in processed_pages {
            // Populate the URL map during initial load
            self.page_url_map.insert(page.relative_path.clone(), page.url_path.clone());
            self.pages.push(page);
        }

        info!("Loaded {} content pages.", self.pages.len());
        Ok(())
    }

    fn walk_dir_for_markdown(&self, dir: &Path, base_dir: &Path, files: &mut Vec<PathBuf>) -> Result<(), Box<dyn Error>> {
        for entry in fs::read_dir(dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_file() && path.extension().map_or(false, |ext| ext == "md") {
                files.push(path);
            } else if path.is_dir() {
                self.walk_dir_for_markdown(&path, base_dir, files)?;
            }
        }
        Ok(())
    }

    fn process_single_content_file(&self, path: &Path, content_dir: &Path) -> Result<Page, Box<dyn Error>> {
        let content = fs::read_to_string(path)?;
        let (frontmatter, markdown_body) = processor::parse_frontmatter(&content)?;

        // Determine collection (e.g., "posts" for content/posts/my-post.md)
        let relative_path = path.strip_prefix(content_dir)?.to_path_buf();
        let collection = relative_path.parent()
                                      .and_then(|p| p.file_name())
                                      .and_then(|s| s.to_str())
                                      .unwrap_or("").to_string();

        // Generate URL path (e.g., /posts/my-post/ or /about/)
        let mut url_path = self.config.base_url.clone();
        if !collection.is_empty() {
            url_path.push_str(&collection);
            url_path.push('/');
        }
        url_path.push_str(&frontmatter.get_slug());
        url_path.push('/'); // Ensure trailing slash for directory-like URLs

        let (rendered_html, toc_entries) = processor::markdown_to_html(markdown_body);

        let mut page = Page::new(
            path.to_path_buf(),
            relative_path,
            frontmatter,
            markdown_body.to_string(),
            rendered_html,
            url_path,
            collection,
        );
        page.toc = toc_entries; // Assign the extracted ToC entries

        Ok(page)
    }

    /// Performs a second pass to resolve internal links in all pages.
    pub fn resolve_internal_links(&mut self) {
        info!("Resolving internal links for all pages...");
        // This needs to happen *after* all pages are loaded and `page_url_map` is complete.
        for page in &mut self.pages {
            page.final_html = processor::rewrite_internal_links(&page.rendered_html, &self.page_url_map);
        }
        info!("Internal links resolved.");
    }

    /// Builds the hierarchical navigation menus based on page frontmatter.
    pub fn build_navigation_menus(&mut self) {
        info!("Building navigation menus...");
        let mut menu_map: HashMap<String, Vec<NavEntry>> = HashMap::new();

        // First, collect all pages that belong to any menu
        for page in &self.pages {
            if page.frontmatter.draft {
                continue; // Skip draft pages from navigation
            }
            for menu_name in &page.frontmatter.menu {
                let entry = NavEntry::new(
                    page.frontmatter.title.clone(),
                    page.url_path.clone(),
                    page.frontmatter.weight,
                    Some(menu_name.clone()),
                );
                menu_map.entry(menu_name.clone()).or_default().push(entry);
            }
        }

        // Sort each menu by weight and title
        for (_menu_name, entries) in menu_map.iter_mut() {
            entries.sort_by(|a, b| a.weight.cmp(&b.weight).then_with(|| a.title.cmp(&b.title)));
            // For now, we're not building a deep hierarchy based on URL paths.
            // A more advanced system would parse URL paths to create nested `NavEntry` children.
            // For example, /docs/chapter1/ and /docs/chapter1/section1/
            // would result in chapter1 having section1 as a child.
            // This is a complex task and usually requires explicit parent/child metadata in frontmatter
            // or a very specific URL structure. We'll keep it flat for now.
        }

        self.navigation_menus = menu_map;
        info!("Navigation menus built: {:?}", self.navigation_menus.keys().collect::<Vec<&String>>());
    }


    /// Renders all pages using Tera templates.
    pub fn render_pages(&mut self) -> Result<(), Box<dyn Error>> {
        info!("Rendering {} pages...", self.pages.len());
        fs::create_dir_all(&self.config.output_dir)?;

        for page in &self.pages {
            if page.frontmatter.draft {
                info!("Skipping draft page: {:?}", page.file_path);
                continue;
            }

            let output_path = self.config.output_dir.join(
                page.url_path.trim_start_matches(&self.config.base_url)
                              .trim_end_matches('/')
            ).join("index.html"); // Ensure output is always index.html inside a directory

            fs::create_dir_all(output_path.parent().unwrap())?;

            let mut context = tera::Context::new();
            context.insert("page", &page);
            context.insert("site_config", &self.config);
            context.insert("current_url_path", &page.url_path);

            // Add navigation menus to the context
            context.insert("navigation", &self.navigation_menus);

            // Conditionally add ToC to context
            if page.frontmatter.show_table_of_contents && !page.toc.is_empty() {
                context.insert("toc", &page.toc);
            } else {
                context.insert("toc", &Vec::<NavEntry>::new()); // Empty ToC
            }

            let template_name = page.frontmatter.template.as_ref().unwrap_or(&"default.html".to_string()).clone();
            
            match self.template_engine.render(&template_name, &context) {
                Ok(rendered_content) => {
                    fs::write(&output_path, rendered_content)?;
                    info!("Rendered: {:?} -> {:?}", page.file_path, output_path);
                }
                Err(e) => {
                    error!("Failed to render page {:?} with template {}: {}", page.file_path, template_name, e);
                }
            }
        }
        Ok(())
    }

    /// Copies static assets.
    pub fn copy_static_assets(&self) -> Result<(), Box<dyn Error>> {
        if let Some(static_dir) = &self.config.static_dir {
            if static_dir.exists() && static_dir.is_dir() {
                info!("Copying static assets from: {:?}", static_dir);
                let output_static_dir = &self.config.output_dir;

                for entry in walkdir::WalkDir::new(static_dir) {
                    let entry = entry?;
                    let path = entry.path();
                    if path.is_file() {
                        let relative_path = path.strip_prefix(static_dir)?;
                        let dest_path = output_static_dir.join(relative_path);
                        fs::create_dir_all(dest_path.parent().unwrap())?;
                        fs::copy(path, &dest_path)?;
                        info!("Copied static asset: {:?} -> {:?}", path, dest_path);
                    }
                }
                info!("Static assets copied.");
            } else {
                warn!("Static directory {:?} does not exist or is not a directory. Skipping.", static_dir);
            }
        }
        Ok(())
    }
}

use env_logger::Env;
use std::error::Error;
use std::path::PathBuf;
use crate::site::{Site, SiteConfig}; // Import SiteConfig

mod content;
mod processor;
mod site;
mod template_engine;
mod utils;

fn main() -> Result<(), Box<dyn Error>> {
    // Initialize logging
    env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();

    info!("Starting SSG build process...");

    let config = SiteConfig {
        content_dir: PathBuf::from("content"),
        output_dir: PathBuf::from("public"),
        templates_dir: PathBuf::from("templates"),
        static_dir: Some(PathBuf::from("static")),
        base_url: "/".to_string(),
    };

    let mut site = Site::new(config)?;

    // 1. Load all content and populate the page_url_map
    site.load_content()?;

    // 2. After all content is loaded and URLs are known, resolve internal links
    site.resolve_internal_links();

    // 3. Build navigation menus from all page frontmatter
    site.build_navigation_menus();

    // 4. Render pages with updated HTML (resolved links), ToC, and navigation data
    site.render_pages()?;

    // 5. Copy static assets
    site.copy_static_assets()?;

    info!("SSG build process completed successfully!");

    Ok(())
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ page.frontmatter.title }} - My Rust SSG Site</title>
    <meta name="description" content="{{ page.frontmatter.description | default(value='') }}">
    <link rel="stylesheet" href="/styles.css"> {# Example static asset #}
</head>
<body>
    <header>
        <h1><a href="{{ site_config.base_url }}">My Awesome Rust SSG</a></h1>
        <nav class="main-nav">
            <ul>
                {% if navigation.main %}
                    {% for nav_item in navigation.main %}
                        <li><a href="{{ nav_item.url }}">{{ nav_item.title }}</a></li>
                    {% endfor %}
                {% endif %}
            </ul>
        </nav>
        {% if navigation.sidebar %}
            <nav class="sidebar-nav">
                <h3>Docs</h3>
                <ul>
                    {% for nav_item in navigation.sidebar %}
                        <li><a href="{{ nav_item.url }}">{{ nav_item.title }}</a></li>
                    {% endfor %}
                </ul>
            </nav>
        {% endif %}
    </header>

    <main>
        <article>
            <h2>{{ page.frontmatter.title }}</h2>
            {% if page.frontmatter.author %}
                <p>By: {{ page.frontmatter.author }}</p>
            {% endif %}
            {% if page.frontmatter.date %}
                <p>Published: {{ page.frontmatter.date | date(format="%Y-%m-%d") }}</p>
            {% endif %}

            {% if page.frontmatter.show_table_of_contents and toc %}
                <aside class="table-of-contents">
                    <h3>Table of Contents</h3>
                    <ul>
                        {% for entry in toc %}
                            <li class="toc-level-{{ entry.level }}">
                                <a href="#{{ entry.id }}">{{ entry.text }}</a>
                            </li>
                        {% endfor %}
                    </ul>
                </aside>
            {% endif %}

            <div class="content-body">
                {{ page.final_html | safe }} {# Render the HTML with resolved links #}
            </div>
        </article>
    </main>

    <footer>
        <p>&copy; 2026 My Rust SSG. All rights reserved.</p>
    </footer>
</body>
</html>

+++
title = "My First Blog Post"
date = 2026-03-01T10:00:00Z
description = "This is my very first post on the Rust SSG."
slug = "my-first-post"
menu = ["main"]
weight = 10
show_table_of_contents = true
+++

# Welcome to My Blog

This is the introductory section of my first blog post. It's great to be here.

## Getting Started

To get started, you might want to read about [Another Post](/posts/second-post.md).
You can also check out our [About Us](/about/) page.

### Installation

Follow these steps:
1.  Install Rust.
2.  Clone the repository.

## Advanced Topics

We'll cover more advanced topics later.

### Debugging Tips

Some useful debugging tips.

+++
title = "My Second Blog Post"
date = 2026-03-02T11:30:00Z
description = "A follow-up post."
slug = "second-post"
menu = ["main"]
weight = 20
+++

# Second Post

This is the second post. You can go back to the [First Post](/posts/first-post.md).

+++
title = "About Us"
date = 2026-01-15T09:00:00Z
description = "Learn about our mission."
slug = "about"
menu = ["main", "sidebar"]
weight = 5
+++

# About Our Project

This static site generator is built with Rust.

## Our Mission

To provide developers with a powerful and flexible tool.

## The Team

We are a small, dedicated team.