//! Markdown conversion utilities for BodyElement arrays.
//!
//! Provides bidirectional conversion between structured BodyElement[] and markdown strings.

use crate::db::models::BodyElement;

/// Convert a slice of BodyElements to a markdown string.
///
/// Handles:
/// - Headings: `# heading` through `###### heading` based on level
/// - Paragraphs: plain text with blank lines between
/// - Code blocks: ````language\ncontent\n````
/// - Lists: ordered (1. 2. 3.) and unordered (- - -)
/// - Charts: rendered as fenced JSON with chart type
/// - Images: rendered as markdown image syntax
pub fn body_to_markdown(elements: &[BodyElement]) -> String {
    elements
        .iter()
        .filter_map(|elem| match elem {
            BodyElement::Heading { level, text } => {
                let hashes = "#".repeat((*level).min(6) as usize);
                Some(format!("{} {}", hashes, text))
            }
            BodyElement::Paragraph { text } => Some(text.clone()),
            BodyElement::Code { language, content } => {
                let lang = language.as_deref().unwrap_or("");
                Some(format!("```{}\n{}\n```", lang, content))
            }
            BodyElement::List { ordered, items } => {
                let list: Vec<String> = items
                    .iter()
                    .enumerate()
                    .map(|(i, item)| {
                        if *ordered {
                            format!("{}. {}", i + 1, item)
                        } else {
                            format!("- {}", item)
                        }
                    })
                    .collect();
                Some(list.join("\n"))
            }
            BodyElement::Chart {
                chart_type,
                title,
                data,
                config: _,
            } => {
                // Render chart as a fenced block with metadata
                let title_str = title
                    .as_ref()
                    .map(|t| format!(" - {}", t))
                    .unwrap_or_default();
                let data_str = serde_json::to_string_pretty(data).unwrap_or_default();
                Some(format!(
                    "```chart:{:?}{}\n{}\n```",
                    chart_type, title_str, data_str
                ))
            }
            BodyElement::Image { src, alt, caption } => {
                let alt_text = alt.as_deref().unwrap_or("image");
                let caption_str = caption
                    .as_ref()
                    .map(|c| format!("\n*{}*", c))
                    .unwrap_or_default();
                Some(format!("![{}]({}){}", alt_text, src, caption_str))
            }
            // Markdown elements output their content directly - it's already markdown
            BodyElement::Markdown { content } => Some(content.clone()),
        })
        .collect::<Vec<_>>()
        .join("\n\n")
}

/// Parse a markdown string into a vector of BodyElements.
///
/// Handles:
/// - Headings: lines starting with # through ######
/// - Code blocks: ````language ... ````
/// - Ordered lists: lines starting with 1. 2. etc.
/// - Unordered lists: lines starting with - or *
/// - Paragraphs: all other non-empty lines
pub fn markdown_to_body(markdown: &str) -> Vec<BodyElement> {
    let mut elements = Vec::new();
    let lines: Vec<&str> = markdown.lines().collect();
    let mut i = 0;

    while i < lines.len() {
        let line = lines[i];
        let trimmed = line.trim();

        // Skip empty lines
        if trimmed.is_empty() {
            i += 1;
            continue;
        }

        // Check for code blocks
        if trimmed.starts_with("```") {
            let language = trimmed.trim_start_matches('`').trim();
            let language = if language.is_empty() {
                None
            } else {
                Some(language.to_string())
            };

            let mut content_lines = Vec::new();
            i += 1;

            // Collect content until closing ```
            while i < lines.len() && !lines[i].trim().starts_with("```") {
                content_lines.push(lines[i]);
                i += 1;
            }

            // Skip the closing ```
            if i < lines.len() {
                i += 1;
            }

            elements.push(BodyElement::Code {
                language,
                content: content_lines.join("\n"),
            });
            continue;
        }

        // Check for headings
        if trimmed.starts_with('#') {
            let level = trimmed.chars().take_while(|&c| c == '#').count() as u8;
            let text = trimmed.trim_start_matches('#').trim().to_string();
            elements.push(BodyElement::Heading { level, text });
            i += 1;
            continue;
        }

        // Check for unordered lists (- or *)
        if trimmed.starts_with("- ") || trimmed.starts_with("* ") {
            let mut items = Vec::new();
            while i < lines.len() {
                let current = lines[i].trim();
                if current.starts_with("- ") || current.starts_with("* ") {
                    items.push(current[2..].to_string());
                    i += 1;
                } else if current.is_empty() {
                    i += 1;
                    break;
                } else {
                    break;
                }
            }
            elements.push(BodyElement::List {
                ordered: false,
                items,
            });
            continue;
        }

        // Check for ordered lists (1. 2. etc.)
        if let Some(rest) = try_parse_ordered_list_item(trimmed) {
            let mut items = Vec::new();
            items.push(rest.to_string());
            i += 1;

            while i < lines.len() {
                let current = lines[i].trim();
                if let Some(item_rest) = try_parse_ordered_list_item(current) {
                    items.push(item_rest.to_string());
                    i += 1;
                } else if current.is_empty() {
                    i += 1;
                    break;
                } else {
                    break;
                }
            }
            elements.push(BodyElement::List {
                ordered: true,
                items,
            });
            continue;
        }

        // Default: paragraph (collect consecutive non-empty lines)
        let mut para_lines = Vec::new();
        while i < lines.len() {
            let current = lines[i].trim();
            if current.is_empty()
                || current.starts_with('#')
                || current.starts_with("```")
                || current.starts_with("- ")
                || current.starts_with("* ")
                || try_parse_ordered_list_item(current).is_some()
            {
                break;
            }
            para_lines.push(current);
            i += 1;
        }

        if !para_lines.is_empty() {
            elements.push(BodyElement::Paragraph {
                text: para_lines.join(" "),
            });
        }
    }

    elements
}

/// Try to parse an ordered list item (e.g., "1. Item text")
/// Returns the text after the number and period, or None if not a list item.
fn try_parse_ordered_list_item(s: &str) -> Option<&str> {
    let mut chars = s.char_indices();

    // Must start with a digit
    let (_, first) = chars.next()?;
    if !first.is_ascii_digit() {
        return None;
    }

    // Consume remaining digits
    let mut last_digit_end = 1;
    for (idx, c) in chars.by_ref() {
        if c.is_ascii_digit() {
            last_digit_end = idx + 1;
        } else if c == '.' {
            // Found the period - check for space after
            let rest = &s[last_digit_end + 1..];
            let rest = rest.trim_start();
            if !rest.is_empty() || s.ends_with(". ") {
                return Some(rest);
            }
            return None;
        } else {
            return None;
        }
    }

    None
}

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

    #[test]
    fn test_body_to_markdown_heading() {
        let elements = vec![BodyElement::Heading {
            level: 2,
            text: "Hello World".to_string(),
        }];
        assert_eq!(body_to_markdown(&elements), "## Hello World");
    }

    #[test]
    fn test_body_to_markdown_paragraph() {
        let elements = vec![BodyElement::Paragraph {
            text: "This is a paragraph.".to_string(),
        }];
        assert_eq!(body_to_markdown(&elements), "This is a paragraph.");
    }

    #[test]
    fn test_body_to_markdown_code() {
        let elements = vec![BodyElement::Code {
            language: Some("rust".to_string()),
            content: "fn main() {}".to_string(),
        }];
        assert_eq!(
            body_to_markdown(&elements),
            "```rust\nfn main() {}\n```"
        );
    }

    #[test]
    fn test_body_to_markdown_list() {
        let elements = vec![BodyElement::List {
            ordered: false,
            items: vec!["Item 1".to_string(), "Item 2".to_string()],
        }];
        assert_eq!(body_to_markdown(&elements), "- Item 1\n- Item 2");
    }

    #[test]
    fn test_markdown_to_body_heading() {
        let md = "## Hello World";
        let elements = markdown_to_body(md);
        assert_eq!(elements.len(), 1);
        match &elements[0] {
            BodyElement::Heading { level, text } => {
                assert_eq!(*level, 2);
                assert_eq!(text, "Hello World");
            }
            _ => panic!("Expected Heading"),
        }
    }

    #[test]
    fn test_markdown_to_body_code() {
        let md = "```rust\nfn main() {}\n```";
        let elements = markdown_to_body(md);
        assert_eq!(elements.len(), 1);
        match &elements[0] {
            BodyElement::Code { language, content } => {
                assert_eq!(language.as_deref(), Some("rust"));
                assert_eq!(content, "fn main() {}");
            }
            _ => panic!("Expected Code"),
        }
    }

    #[test]
    fn test_roundtrip() {
        let original = vec![
            BodyElement::Heading {
                level: 1,
                text: "Title".to_string(),
            },
            BodyElement::Paragraph {
                text: "Some text here.".to_string(),
            },
            BodyElement::List {
                ordered: false,
                items: vec!["A".to_string(), "B".to_string()],
            },
        ];

        let markdown = body_to_markdown(&original);
        let parsed = markdown_to_body(&markdown);

        assert_eq!(parsed.len(), 3);
    }
}