use printpdf::{
    BuiltinFont, Mm, Op, PdfDocument, PdfFontHandle, PdfPage, PdfSaveOptions, Point, Pt, TextItem,
};
use pulldown_cmark::{Event, HeadingLevel, Options, Parser, Tag, TagEnd};

use crate::Error;
use crate::layout::{
    BLOCK_GAP_MM, BODY_PT, H1_PT, H2_PT, H3_PT, HEADING_GAP_MM, LIST_INDENT_MM, MARGIN, MONO_PT,
    PAGE_H, PAGE_W, QUOTE_INDENT_MM, content_bottom_mm, content_top_mm, content_width_mm,
    line_height_mm, text_width_mm,
};

pub fn render_article(html: &str, title: &str, url: Option<&str>) -> Result<Vec<u8>, Error> {
    let markdown = pter::convert(html);
    let markdown = markdown.trim();
    if markdown.is_empty() {
        return Err(Error::Empty);
    }

    let mut r = Renderer::new(title);
    if !title.trim().is_empty() {
        r.draw_heading(title, H1_PT);
        if let Some(u) = url {
            r.draw_paragraph(
                u,
                Style {
                    italic: true,
                    ..Style::default()
                },
            );
        }
        r.block_gap();
    }
    r.render_markdown(markdown);
    r.finish()
}

#[derive(Copy, Clone, Default)]
struct Style {
    bold: bool,
    italic: bool,
    mono: bool,
    size_pt: f32,
    left_indent_mm: f32,
    bullet: Option<char>,
    number: Option<u64>,
}

impl Style {
    fn body() -> Self {
        Self {
            size_pt: BODY_PT,
            ..Self::default()
        }
    }
}

struct Renderer {
    title: String,
    /// Pages already flushed. The page currently being filled lives in `ops`.
    pages: Vec<PdfPage>,
    /// Content operations for the page being filled.
    ops: Vec<Op>,
    y_mm: f32,
}

impl Renderer {
    fn new(title: &str) -> Self {
        let doc_title = if title.trim().is_empty() {
            "Balanced Breakfast"
        } else {
            title
        };
        Self {
            title: doc_title.to_string(),
            pages: Vec::new(),
            ops: Vec::new(),
            y_mm: content_top_mm(),
        }
    }

    fn finish(mut self) -> Result<Vec<u8>, Error> {
        // Flush the page still being filled.
        self.pages
            .push(PdfPage::new(PAGE_W, PAGE_H, std::mem::take(&mut self.ops)));
        let mut doc = PdfDocument::new(&self.title);
        doc.with_pages(self.pages);
        let mut warnings = Vec::new();
        Ok(doc.save(&PdfSaveOptions::default(), &mut warnings))
    }

    fn render_markdown(&mut self, md: &str) {
        let opts = Options::ENABLE_STRIKETHROUGH;
        let parser = Parser::new_ext(md, opts);
        let mut style_stack: Vec<Style> = vec![Style::body()];
        let mut list_stack: Vec<Option<u64>> = Vec::new();
        let mut buf = String::new();

        for event in parser {
            match event {
                Event::Start(tag) => match tag {
                    Tag::Heading { level, .. } => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        self.block_gap_heading();
                        let pt = match level {
                            HeadingLevel::H1 => H1_PT,
                            HeadingLevel::H2 => H2_PT,
                            _ => H3_PT,
                        };
                        style_stack.push(Style {
                            size_pt: pt,
                            bold: true,
                            ..*style_stack.last().unwrap()
                        });
                    }
                    Tag::Paragraph => {
                        // nothing; paragraph text flushes on End(Paragraph)
                    }
                    Tag::BlockQuote(_) => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        self.block_gap();
                        let mut s = *style_stack.last().unwrap();
                        s.italic = true;
                        s.left_indent_mm += QUOTE_INDENT_MM;
                        style_stack.push(s);
                    }
                    Tag::List(start) => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        self.block_gap();
                        list_stack.push(start);
                    }
                    Tag::Item => {
                        let mut s = *style_stack.last().unwrap();
                        s.left_indent_mm += LIST_INDENT_MM;
                        match list_stack.last_mut() {
                            Some(Some(n)) => {
                                s.number = Some(*n);
                                *n += 1;
                            }
                            _ => s.bullet = Some('\u{2022}'),
                        }
                        style_stack.push(s);
                    }
                    Tag::Emphasis => {
                        let mut s = *style_stack.last().unwrap();
                        s.italic = true;
                        style_stack.push(s);
                    }
                    Tag::Strong => {
                        let mut s = *style_stack.last().unwrap();
                        s.bold = true;
                        style_stack.push(s);
                    }
                    Tag::CodeBlock(_) => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        self.block_gap();
                        let mut s = *style_stack.last().unwrap();
                        s.mono = true;
                        s.size_pt = MONO_PT;
                        style_stack.push(s);
                    }
                    Tag::Link { .. } | Tag::Image { .. } => {
                        // Render link text inline; drop images entirely.
                    }
                    _ => {}
                },
                Event::End(end) => match end {
                    TagEnd::Heading(_) => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        style_stack.pop();
                    }
                    TagEnd::Paragraph => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        self.block_gap();
                    }
                    TagEnd::BlockQuote(_) | TagEnd::CodeBlock => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        self.block_gap();
                        style_stack.pop();
                    }
                    TagEnd::List(_) => {
                        list_stack.pop();
                    }
                    TagEnd::Item => {
                        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                        style_stack.pop();
                    }
                    TagEnd::Emphasis | TagEnd::Strong => {
                        // Style-scoped runs are simplified: we buffer per-paragraph
                        // as a single run of the outer style, so nested bold/italic
                        // is lost. This is a v1 limitation.
                        style_stack.pop();
                    }
                    _ => {}
                },
                Event::Text(t) | Event::Code(t) => {
                    if !buf.is_empty() && !buf.ends_with(char::is_whitespace) {
                        buf.push(' ');
                    }
                    buf.push_str(&t);
                }
                Event::SoftBreak => buf.push(' '),
                Event::HardBreak => {
                    self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
                }
                _ => {}
            }
        }
        self.flush_paragraph(&mut buf, *style_stack.last().unwrap());
    }

    fn flush_paragraph(&mut self, buf: &mut String, style: Style) {
        let text = buf.trim();
        if text.is_empty() {
            buf.clear();
            return;
        }
        self.draw_paragraph(text, style);
        buf.clear();
    }

    fn draw_heading(&mut self, text: &str, pt: f32) {
        let style = Style {
            size_pt: pt,
            bold: true,
            ..Style::default()
        };
        self.draw_paragraph(text, style);
    }

    fn draw_paragraph(&mut self, text: &str, style: Style) {
        let leader = if let Some(n) = style.number {
            format!("{n}. ")
        } else if let Some(c) = style.bullet {
            format!("{c}  ")
        } else {
            String::new()
        };

        let line_h = line_height_mm(if style.size_pt > 0.0 {
            style.size_pt
        } else {
            BODY_PT
        });
        let text_indent = style.left_indent_mm;
        let text_width = content_width_mm() - text_indent;

        let mut first = true;
        for line in wrap(text, style, text_width) {
            self.ensure_room(line_h);
            let x = MARGIN.0 + text_indent;
            let font = Self::font_for(style);
            let baseline_y = self.y_mm - style.size_pt * 25.4 / 72.0;

            if first && !leader.is_empty() {
                self.draw_text(&leader, style.size_pt, x - LIST_INDENT_MM, baseline_y, font);
            }
            self.draw_text(&line, style.size_pt, x, baseline_y, font);
            self.y_mm -= line_h;
            first = false;
        }
    }

    /// Emit a single positioned text run into the current page. The origin is
    /// the page's bottom-left corner and `baseline_mm` is the text baseline,
    /// matching the geometry the layout math assumes.
    fn draw_text(
        &mut self,
        text: &str,
        size_pt: f32,
        x_mm: f32,
        baseline_mm: f32,
        font: BuiltinFont,
    ) {
        self.ops.push(Op::StartTextSection);
        self.ops.push(Op::SetFont {
            font: PdfFontHandle::Builtin(font),
            size: Pt(size_pt),
        });
        self.ops.push(Op::SetTextCursor {
            pos: Point::new(Mm(x_mm), Mm(baseline_mm)),
        });
        self.ops.push(Op::ShowText {
            items: vec![TextItem::Text(text.to_string())],
        });
        self.ops.push(Op::EndTextSection);
    }

    fn font_for(style: Style) -> BuiltinFont {
        if style.mono {
            BuiltinFont::Courier
        } else if style.bold {
            BuiltinFont::HelveticaBold
        } else if style.italic {
            BuiltinFont::HelveticaOblique
        } else {
            BuiltinFont::Helvetica
        }
    }

    fn ensure_room(&mut self, needed_mm: f32) {
        if self.y_mm - needed_mm < content_bottom_mm() {
            let ops = std::mem::take(&mut self.ops);
            self.pages.push(PdfPage::new(PAGE_W, PAGE_H, ops));
            self.y_mm = content_top_mm();
        }
    }

    fn block_gap(&mut self) {
        self.y_mm -= BLOCK_GAP_MM;
    }

    fn block_gap_heading(&mut self) {
        self.y_mm -= HEADING_GAP_MM;
    }
}

fn wrap(text: &str, style: Style, max_width_mm: f32) -> Vec<String> {
    let mut lines: Vec<String> = Vec::new();
    let mut cur = String::new();
    for word in text.split_whitespace() {
        // A single token wider than the column can never fit on any line; break it
        // on character boundaries so it wraps instead of running off the page edge.
        if text_width_mm(word, style.size_pt, style.bold, style.mono) > max_width_mm {
            if !cur.is_empty() {
                lines.push(std::mem::take(&mut cur));
            }
            let mut pieces = hard_break(word, style, max_width_mm);
            // Keep the trailing piece in `cur` so the next word can share its line.
            if let Some(last) = pieces.pop() {
                lines.append(&mut pieces);
                cur = last;
            }
            continue;
        }
        let candidate = if cur.is_empty() {
            word.to_string()
        } else {
            format!("{cur} {word}")
        };
        if text_width_mm(&candidate, style.size_pt, style.bold, style.mono) > max_width_mm
            && !cur.is_empty()
        {
            lines.push(std::mem::take(&mut cur));
            cur.push_str(word);
        } else {
            cur = candidate;
        }
    }
    if !cur.is_empty() {
        lines.push(cur);
    }
    if lines.is_empty() {
        lines.push(String::new());
    }
    lines
}

/// Break a single token wider than the column into character-boundary pieces that
/// each fit within `max_width_mm`. A char wider than the column on its own still
/// gets its own piece (nothing narrower exists), so a piece is never empty.
fn hard_break(word: &str, style: Style, max_width_mm: f32) -> Vec<String> {
    let mut pieces = Vec::new();
    let mut cur = String::new();
    for ch in word.chars() {
        cur.push(ch);
        if text_width_mm(&cur, style.size_pt, style.bold, style.mono) > max_width_mm
            && cur.chars().count() > 1
        {
            cur.pop();
            pieces.push(std::mem::take(&mut cur));
            cur.push(ch);
        }
    }
    if !cur.is_empty() {
        pieces.push(cur);
    }
    pieces
}

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

    #[test]
    fn wraps_long_paragraph() {
        let text = "one two three four five six seven eight nine ten eleven twelve";
        let lines = wrap(text, Style::body(), 30.0);
        assert!(lines.len() > 1);
        for l in &lines {
            assert!(!l.is_empty());
        }
    }

    #[test]
    fn wrap_single_word_never_empties() {
        let lines = wrap("hello", Style::body(), 200.0);
        assert_eq!(lines, vec!["hello".to_string()]);
    }

    #[test]
    fn wrap_hard_breaks_overlong_token() {
        // A single token far wider than the column must be split, and no resulting
        // line may exceed the column width.
        let long = "supercalifragilisticexpialidocioussupercalifragilistic";
        let lines = wrap(long, Style::body(), 20.0);
        assert!(
            lines.len() > 1,
            "an over-wide token should wrap onto several lines"
        );
        let style = Style::body();
        for l in &lines {
            assert!(!l.is_empty());
            assert!(
                text_width_mm(l, style.size_pt, style.bold, style.mono) <= 20.0,
                "line {l:?} exceeds the column width",
            );
        }
        // No characters are lost across the break.
        assert_eq!(lines.concat(), long);
    }

    #[test]
    fn empty_body_is_error() {
        let out = render_article("<p></p>", "t", None);
        assert!(matches!(out, Err(Error::Empty)));
    }

    #[test]
    fn end_to_end_produces_pdf_bytes() {
        let html = r"
            <h1>Hello</h1>
            <p>This is a <strong>bold</strong> paragraph with an <em>italic</em> word.</p>
            <ul><li>one</li><li>two</li></ul>
            <blockquote>Quoted material.</blockquote>
        ";
        let bytes = render_article(html, "Test Article", Some("https://example.com/a")).unwrap();
        assert!(bytes.starts_with(b"%PDF"));
        assert!(bytes.len() > 1000);
    }

    #[test]
    fn long_article_produces_multiple_pages() {
        let mut html = String::from("<h1>Long</h1>");
        for i in 0..200 {
            html.push_str(&format!(
                "<p>Paragraph number {i}. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.</p>"
            ));
        }
        let bytes = render_article(&html, "Long", None).unwrap();
        assert!(bytes.starts_with(b"%PDF"));
        // Very rough sanity check that the doc grew past a single page's worth
        assert!(bytes.len() > 8000);
    }
}