guidebook 0.1.73

use anyhow::Result;
use pulldown_cmark::{Event, Parser, Tag, TagEnd};
use std::fs;
use std::path::Path;

#[derive(Debug, Clone)]
pub struct Summary {
    /// Title from # heading in SUMMARY.md (kept for compatibility)
    #[allow(dead_code)]
    pub title: Option<String>,
    pub items: Vec<SummaryItem>,
}

#[derive(Debug, Clone)]
pub enum SummaryItem {
    /// A chapter with a link
    Link {
        title: String,
        path: Option<String>,
        children: Vec<SummaryItem>,
    },
    /// A separator (horizontal rule)
    Separator,
    /// A part header (unlinked heading)
    PartTitle(String),
}

impl Summary {
    pub fn parse(book_dir: &Path) -> Result<Self> {
        let summary_path = book_dir.join("SUMMARY.md");
        let content = fs::read_to_string(&summary_path)?;
        parse_summary(&content)
    }
}

/// Parse SUMMARY.md content into a Summary structure
/// Uses pulldown-cmark to parse Markdown structure (like HonKit)
pub fn parse_summary(content: &str) -> Result<Summary> {
    let mut title = None;
    let mut items = Vec::new();
    let parser = Parser::new(content);

    // State tracking
    let mut in_list_stack: Vec<Vec<SummaryItem>> = Vec::new(); // Stack of list items at each depth
    let mut current_link: Option<(String, Option<String>)> = None; // (title, path)
    let mut current_text = String::new();
    let mut in_heading = false;
    let mut heading_level = 0;
    let mut pending_item_text = String::new(); // Text for plain items (no link)

    for event in parser {
        match event {
            // Heading (# Title, ## Part, ### Part)
            Event::Start(Tag::Heading { level, .. }) => {
                in_heading = true;
                heading_level = level as usize;
                current_text.clear();
            }
            Event::End(TagEnd::Heading(_)) => {
                in_heading = false;
                let text = current_text.trim().to_string();
                if heading_level == 1 {
                    // # Title
                    title = Some(text);
                } else if heading_level == 2 || heading_level == 3 {
                    // ## Part or ### Part
                    items.push(SummaryItem::PartTitle(text));
                }
                current_text.clear();
            }

            // List start/end
            Event::Start(Tag::List(_)) => {
                // Before starting nested list, flush any pending link from parent item
                if !in_list_stack.is_empty() {
                    if let Some((link_title, link_path)) = current_link.take() {
                        if let Some(current_list) = in_list_stack.last_mut() {
                            current_list.push(SummaryItem::Link {
                                title: link_title,
                                path: link_path,
                                children: Vec::new(),
                            });
                        }
                    } else if !pending_item_text.is_empty() {
                        // Plain text item
                        if let Some(current_list) = in_list_stack.last_mut() {
                            current_list.push(SummaryItem::Link {
                                title: pending_item_text.trim().to_string(),
                                path: None,
                                children: Vec::new(),
                            });
                        }
                        pending_item_text.clear();
                    }
                }
                in_list_stack.push(Vec::new());
            }
            Event::End(TagEnd::List(_)) => {
                if let Some(completed_items) = in_list_stack.pop() {
                    if in_list_stack.is_empty() {
                        // Top-level list completed, add to items
                        items.extend(completed_items);
                    } else {
                        // Nested list completed, attach as children to last item in parent
                        if let Some(parent_list) = in_list_stack.last_mut() {
                            if let Some(SummaryItem::Link { children, .. }) = parent_list.last_mut()
                            {
                                *children = completed_items;
                            }
                        }
                    }
                }
            }

            // List item
            Event::Start(Tag::Item) => {
                current_link = None;
                current_text.clear();
                pending_item_text.clear();
            }
            Event::End(TagEnd::Item) => {
                // Only add item here if it wasn't already added when nested list started
                if let Some(current_list) = in_list_stack.last_mut() {
                    if let Some((link_title, link_path)) = current_link.take() {
                        current_list.push(SummaryItem::Link {
                            title: link_title,
                            path: link_path,
                            children: Vec::new(),
                        });
                    } else if !pending_item_text.is_empty() {
                        // Plain text item (no link)
                        current_list.push(SummaryItem::Link {
                            title: pending_item_text.trim().to_string(),
                            path: None,
                            children: Vec::new(),
                        });
                    }
                }
                current_text.clear();
                pending_item_text.clear();
            }

            // Link — the FIRST link in a list item wins; additional links in
            // the same item are ignored (previously a second link silently
            // overwrote the first, dropping its navigation entry entirely)
            Event::Start(Tag::Link { dest_url, .. }) if current_link.is_none() => {
                current_text.clear();
                let path = dest_url.to_string();
                let path = if path.is_empty() || path == "#" {
                    None
                } else {
                    // Normalize path: remove leading ./ (but keep / for root-relative paths)
                    Some(path.trim_start_matches("./").to_string())
                };
                current_link = Some((String::new(), path));
            }
            Event::End(TagEnd::Link) => {
                if let Some((ref mut link_title, _)) = current_link {
                    // Only the first link's text becomes the title
                    if link_title.is_empty() {
                        *link_title = current_text.trim().to_string();
                    }
                }
                current_text.clear();
            }

            // Horizontal rule (separator)
            Event::Rule => {
                items.push(SummaryItem::Separator);
            }

            // Text content
            Event::Text(text) => {
                if in_heading {
                    current_text.push_str(&text);
                } else if !in_list_stack.is_empty() {
                    current_text.push_str(&text);
                    // Also track for plain items (text outside links)
                    if current_link.is_none() {
                        pending_item_text.push_str(&text);
                    }
                }
            }
            Event::Code(code) => {
                if in_heading {
                    current_text.push_str(&code);
                } else if !in_list_stack.is_empty() {
                    current_text.push_str(&code);
                    if current_link.is_none() {
                        pending_item_text.push_str(&code);
                    }
                }
            }

            _ => {}
        }
    }

    Ok(Summary { title, items })
}

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

    #[test]
    fn test_parse_simple_summary() {
        let content = r#"# Summary

* [Introduction](README.md)
* [Chapter 1](chapter1.md)
    * [Section 1.1](chapter1/section1.md)
    * [Section 1.2](chapter1/section2.md)
* [Chapter 2](chapter2.md)
"#;

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.title, Some("Summary".to_string()));
        assert_eq!(summary.items.len(), 3);
    }

    #[test]
    fn test_parse_nested_summary() {
        let content = r#"# Summary

* [表紙](README.md)
* 顧客画面
    * ポートフォリオ
        * [TOP](Customer/AssetStatus/PortfolioTop.md)
        * [国内株式現物](./Customer/AssetStatus/PortfolioStock.md)
"#;

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.items.len(), 2);

        // Verify children structure
        if let SummaryItem::Link {
            title, children, ..
        } = &summary.items[1]
        {
            assert_eq!(title, "顧客画面");
            assert_eq!(
                children.len(),
                1,
                "顧客画面 should have 1 child (ポートフォリオ)"
            );

            if let SummaryItem::Link {
                title: child_title,
                children: grandchildren,
                ..
            } = &children[0]
            {
                assert_eq!(child_title, "ポートフォリオ");
                assert_eq!(
                    grandchildren.len(),
                    2,
                    "ポートフォリオ should have 2 children (TOP, 国内株式現物)"
                );
            } else {
                panic!("Expected Link for ポートフォリオ");
            }
        } else {
            panic!("Expected Link for 顧客画面");
        }
    }

    #[test]
    fn test_parse_2space_indent() {
        // Test 2-space indentation (like kcsta-trade-bff)
        let content = r#"# Summary

* [Introduction](README.md)
* [Chapter 1](chapter1.md)
  * [Section 1.1](chapter1/section1.md)
  * [Section 1.2](chapter1/section2.md)
    * [Subsection 1.2.1](chapter1/section2/sub1.md)
* [Chapter 2](chapter2.md)
"#;

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.items.len(), 3, "Should have 3 top-level items");

        // Verify Chapter 1 has 2 children
        if let SummaryItem::Link {
            title, children, ..
        } = &summary.items[1]
        {
            assert_eq!(title, "Chapter 1");
            assert_eq!(children.len(), 2, "Chapter 1 should have 2 children");

            // Verify Section 1.2 has 1 child (Subsection 1.2.1)
            if let SummaryItem::Link {
                title: sec_title,
                children: sec_children,
                ..
            } = &children[1]
            {
                assert_eq!(sec_title, "Section 1.2");
                assert_eq!(sec_children.len(), 1, "Section 1.2 should have 1 child");
            } else {
                panic!("Expected Link for Section 1.2");
            }
        } else {
            panic!("Expected Link for Chapter 1");
        }
    }

    #[test]
    fn test_parse_4space_indent() {
        // Test 4-space indentation (traditional)
        let content = r#"# Summary

* [Introduction](README.md)
* [Chapter 1](chapter1.md)
    * [Section 1.1](chapter1/section1.md)
    * [Section 1.2](chapter1/section2.md)
        * [Subsection 1.2.1](chapter1/section2/sub1.md)
* [Chapter 2](chapter2.md)
"#;

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.items.len(), 3, "Should have 3 top-level items");

        // Verify Chapter 1 has 2 children
        if let SummaryItem::Link {
            title, children, ..
        } = &summary.items[1]
        {
            assert_eq!(title, "Chapter 1");
            assert_eq!(children.len(), 2, "Chapter 1 should have 2 children");

            // Verify Section 1.2 has 1 child (Subsection 1.2.1)
            if let SummaryItem::Link {
                title: sec_title,
                children: sec_children,
                ..
            } = &children[1]
            {
                assert_eq!(sec_title, "Section 1.2");
                assert_eq!(sec_children.len(), 1, "Section 1.2 should have 1 child");
            } else {
                panic!("Expected Link for Section 1.2");
            }
        } else {
            panic!("Expected Link for Chapter 1");
        }
    }

    #[test]
    fn test_parse_mixed_indent() {
        // Test mixed indentation (2 and 4 spaces in same file)
        // With pulldown-cmark, this should work correctly
        let content = r#"# Summary

* [Item 1](item1.md)
  * [Item 1.1](item1-1.md)
* [Item 2](item2.md)
    * [Item 2.1](item2-1.md)
"#;

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.items.len(), 2, "Should have 2 top-level items");

        // Verify Item 1 has 1 child
        if let SummaryItem::Link {
            title, children, ..
        } = &summary.items[0]
        {
            assert_eq!(title, "Item 1");
            assert_eq!(children.len(), 1, "Item 1 should have 1 child");
        } else {
            panic!("Expected Link for Item 1");
        }

        // Verify Item 2 has 1 child
        if let SummaryItem::Link {
            title, children, ..
        } = &summary.items[1]
        {
            assert_eq!(title, "Item 2");
            assert_eq!(children.len(), 1, "Item 2 should have 1 child");
        } else {
            panic!("Expected Link for Item 2");
        }
    }

    #[test]
    fn test_parse_tab_indent() {
        // Test tab indentation
        let content =
            "# Summary\n\n* [Item 1](item1.md)\n\t* [Item 1.1](item1-1.md)\n* [Item 2](item2.md)\n";

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.items.len(), 2, "Should have 2 top-level items");

        if let SummaryItem::Link {
            title, children, ..
        } = &summary.items[0]
        {
            assert_eq!(title, "Item 1");
            assert_eq!(
                children.len(),
                1,
                "Item 1 should have 1 child (tab-indented)"
            );
        } else {
            panic!("Expected Link for Item 1");
        }
    }

    #[test]
    fn test_parse_absolute_paths() {
        // Test absolute paths (leading /) - preserved for root-relative handling
        let content = r#"# Summary

* [Relative](chapter1.md)
* [With Dot Slash](./chapter2.md)
* [Absolute](/chapter3.md)
* [Absolute Nested](/dir/chapter4.md)
"#;

        let summary = parse_summary(content).unwrap();
        assert_eq!(summary.items.len(), 4);

        // Verify paths are normalized (./ removed, but / preserved for root-relative paths)
        if let SummaryItem::Link { path, .. } = &summary.items[0] {
            assert_eq!(path.as_deref(), Some("chapter1.md"));
        }
        if let SummaryItem::Link { path, .. } = &summary.items[1] {
            assert_eq!(path.as_deref(), Some("chapter2.md"), "./ should be removed");
        }
        if let SummaryItem::Link { path, .. } = &summary.items[2] {
            assert_eq!(
                path.as_deref(),
                Some("/chapter3.md"),
                "Leading / should be preserved for root-relative paths"
            );
        }
        if let SummaryItem::Link { path, .. } = &summary.items[3] {
            assert_eq!(
                path.as_deref(),
                Some("/dir/chapter4.md"),
                "Leading / should be preserved for root-relative paths"
            );
        }
    }

    // ── Fuzz-like edge case tests ──

    #[test]
    fn test_fuzz_empty_input() {
        let result = parse_summary("");
        assert!(result.is_ok());
    }

    #[test]
    fn test_fuzz_only_whitespace() {
        let result = parse_summary("   \n\n\t\t\n   ");
        assert!(result.is_ok());
    }

    #[test]
    fn test_fuzz_only_heading() {
        let result = parse_summary("# Summary");
        assert!(result.is_ok());
    }

    #[test]
    fn test_fuzz_broken_links() {
        let inputs = vec![
            "* []()",
            "* [title]()",
            "* [](path.md)",
            "* [broken",
            "* broken](link.md)",
            "* [link](path with spaces.md)",
            "* [](javascript:alert(1))",
            "* [🎉](emoji.md)",
        ];
        for input in inputs {
            let result = parse_summary(input);
            assert!(result.is_ok(), "Should not panic on: {}", input);
        }
    }

    #[test]
    fn test_fuzz_deep_nesting() {
        let mut content = String::from("# Summary\n");
        for i in 0..20 {
            let indent = "  ".repeat(i);
            content.push_str(&format!("{}* [Level {}](l{}.md)\n", indent, i, i));
        }
        let result = parse_summary(&content);
        assert!(result.is_ok());
    }

    #[test]
    fn test_fuzz_null_bytes() {
        let content = "# Summary\n* [Test\0](file\0.md)\n";
        let result = parse_summary(content);
        assert!(result.is_ok());
    }

    #[test]
    fn test_fuzz_very_long_line() {
        let long_title = "A".repeat(10000);
        let content = format!("* [{}](test.md)\n", long_title);
        let result = parse_summary(&content);
        assert!(result.is_ok());
    }

    #[test]
    fn test_first_link_wins_with_two_links_in_item() {
        // Regression: a second link in the same item overwrote the first,
        // silently dropping its navigation entry
        let content = "# Summary\n\n* [Old](old.md) → [New](new.md)\n";
        let summary = parse_summary(content).unwrap();
        let links: Vec<(String, Option<String>)> = summary
            .items
            .iter()
            .filter_map(|i| match i {
                SummaryItem::Link { title, path, .. } => Some((title.clone(), path.clone())),
                _ => None,
            })
            .collect();
        assert_eq!(links.len(), 1);
        assert_eq!(links[0].0, "Old");
        assert_eq!(links[0].1.as_deref(), Some("old.md"));
    }

    #[test]
    fn test_trailing_text_after_link_does_not_break_title() {
        let content = "# Summary\n\n* [Page](page.md) (draft)\n";
        let summary = parse_summary(content).unwrap();
        match &summary.items[0] {
            SummaryItem::Link { title, path, .. } => {
                assert_eq!(title, "Page");
                assert_eq!(path.as_deref(), Some("page.md"));
            }
            other => panic!("unexpected item: {:?}", other),
        }
    }
}