changxi 0.3.0

use crate::core::models::{ContentElement, StyledText, TextStyle};
use crate::core::parser::{ChapterInfo, Parser};
use crate::error::EpubError;
use quick_xml::XmlVersion;
use quick_xml::events::Event;
use quick_xml::reader::Reader;
use std::collections::HashMap;
use std::io::{Read, Seek};
use std::path::Path;
use zip::ZipArchive;

pub struct EpubParser;

impl EpubParser {
    pub fn normalize_path(path: &str) -> String {
        let mut components = Vec::new();
        for component in path.split('/') {
            match component {
                "." | "" => {}
                ".." => {
                    components.pop();
                }
                _ => components.push(component),
            }
        }
        components.join("/")
    }

    fn parse_ncx(&self, content: &str, ncx_path: &str) -> Vec<ChapterInfo> {
        let mut reader = Reader::from_str(content);
        let mut chapters = Vec::new();
        let mut buf = Vec::new();
        let mut level = 0;
        let mut tag_stack = Vec::new();
        let mut titles: HashMap<String, String> = HashMap::new();

        let base_path = Path::new(ncx_path).parent().unwrap_or(Path::new(""));

        loop {
            if let Ok(event) = reader.read_event_into(&mut buf) {
                match event {
                    Event::Start(ref e) | Event::Empty(ref e) => {
                        let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
                        let is_empty = matches!(event, Event::Empty(_));
                        match name.as_str() {
                            "navPoint" => {
                                let mut id = String::new();
                                for attr in e.attributes().flatten() {
                                    if attr.key.local_name().as_ref() == b"id" {
                                        id = attr
                                            .normalized_value(XmlVersion::Implicit1_0)
                                            .unwrap_or_default()
                                            .into_owned();
                                    }
                                }
                                if !is_empty {
                                    tag_stack.push(("navPoint".to_string(), id));
                                    level += 1;
                                }
                            }
                            "navLabel" => {
                                if !is_empty {
                                    tag_stack.push(("navLabel".to_string(), String::new()));
                                }
                            }
                            "text" => {
                                if !is_empty {
                                    tag_stack.push(("text".to_string(), String::new()));
                                }
                            }
                            "content" => {
                                let mut src = String::new();
                                for attr in e.attributes().flatten() {
                                    if attr.key.local_name().as_ref() == b"src" {
                                        src = attr
                                            .normalized_value(XmlVersion::Implicit1_0)
                                            .unwrap_or_default()
                                            .into_owned();
                                    }
                                }
                                if let Some((_tag, id)) =
                                    tag_stack.iter().rev().find(|(t, _)| t == "navPoint")
                                {
                                    let full_href = if base_path.as_os_str().is_empty() {
                                        src
                                    } else {
                                        base_path.join(src).to_string_lossy().into_owned()
                                    };
                                    let title = titles.get(id).cloned().unwrap_or_default();
                                    chapters.push(ChapterInfo {
                                        href: full_href,
                                        id: id.clone(),
                                        title,
                                        level: level - 1,
                                    });
                                }
                                if !is_empty {
                                    tag_stack.push(("content".to_string(), String::new()));
                                }
                            }
                            _ => {
                                if !is_empty {
                                    tag_stack.push((name, String::new()));
                                }
                            }
                        }
                    }
                    Event::Text(ref e) => {
                        if let Some(("text", _)) = tag_stack.last().map(|(t, i)| (t.as_str(), i)) {
                            let text = reader.decoder().decode(e).unwrap_or_default().into_owned();
                            if let Some((_tag, id)) =
                                tag_stack.iter().rev().find(|(t, _)| t == "navPoint")
                            {
                                titles.entry(id.clone()).or_default().push_str(&text);

                                // Update title for chapters already pushed with this ID
                                for chapter in chapters.iter_mut().rev() {
                                    if &chapter.id == id {
                                        chapter.title.push_str(&text);
                                    }
                                }
                            }
                        }
                    }
                    event => match event {
                        Event::End(ref e) => {
                            let name =
                                String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
                            if name == "text"
                                && let Some((_tag, id)) =
                                    tag_stack.iter().rev().find(|(t, _)| t == "navPoint")
                                    && let Some(title) = titles.get_mut(id) {
                                        let trimmed = title.trim().to_owned();
                                        *title = trimmed.clone();
                                        for chapter in chapters.iter_mut().rev() {
                                            if &chapter.id == id {
                                                chapter.title = trimmed.clone();
                                            }
                                        }
                                    }
                            tag_stack.pop();
                            if name == "navPoint" {
                                level -= 1;
                            }
                        }
                        Event::Eof => break,
                        _ => (),
                    },
                }
            } else {
                break;
            }
            buf.clear();
        }
        chapters
    }

    fn parse_nav(&self, content: &str, nav_path: &str) -> Vec<ChapterInfo> {
        let mut reader = Reader::from_str(content);
        reader.config_mut().trim_text(true);
        let mut chapters = Vec::new();
        let mut buf = Vec::new();
        let mut level = 0;
        let mut tag_stack = Vec::new();
        let mut in_nav_toc = false;

        let base_path = Path::new(nav_path).parent().unwrap_or(Path::new(""));

        loop {
            match reader.read_event_into(&mut buf) {
                Ok(event) => match event {
                    Event::Start(ref e) | Event::Empty(ref e) => {
                        let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
                        let is_empty = matches!(event, Event::Empty(_));
                        match name.as_str() {
                            "nav" => {
                                for attr in e.attributes().flatten() {
                                    let attr_name = String::from_utf8_lossy(attr.key.as_ref());
                                    if (attr_name == "epub:type" || attr_name == "type")
                                        && attr
                                            .normalized_value(XmlVersion::Implicit1_0)
                                            .unwrap_or_default()
                                            == "toc"
                                    {
                                        in_nav_toc = true;
                                    }
                                }
                            }
                            "ol" if in_nav_toc => level += 1,
                            "a" if in_nav_toc => {
                                let mut href = String::new();
                                for attr in e.attributes().flatten() {
                                    if attr.key.local_name().as_ref() == b"href" {
                                        href = attr
                                            .normalized_value(XmlVersion::Implicit1_0)
                                            .unwrap_or_default()
                                            .into_owned();
                                    }
                                }
                                let full_href = if base_path.as_os_str().is_empty() {
                                    href
                                } else {
                                    base_path.join(href).to_string_lossy().into_owned()
                                };
                                chapters.push(ChapterInfo {
                                    href: full_href,
                                    id: format!("nav-{}", chapters.len()),
                                    title: String::new(),
                                    level: level - 1,
                                });
                            }
                            _ => (),
                        }
                        if !is_empty {
                            tag_stack.push(name);
                        } else if name == "nav" {
                            in_nav_toc = false;
                        } else if name == "ol" && in_nav_toc {
                            level -= 1;
                        }
                    }
                    Event::Text(ref e)
                        if in_nav_toc && tag_stack.last().map(|s| s.as_str()) == Some("a") =>
                    {
                        let text = reader.decoder().decode(e).unwrap_or_default().into_owned();
                        if let Some(last_chapter) = chapters.last_mut() {
                            last_chapter.title.push_str(&text);
                        }
                    }
                    Event::End(ref e) => {
                        let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
                        tag_stack.pop();
                        match name.as_str() {
                            "nav" => in_nav_toc = false,
                            "ol" if in_nav_toc => level -= 1,
                            _ => (),
                        }
                    }
                    Event::Eof => break,
                    _ => (),
                },
                Err(_) => break,
            }
            buf.clear();
        }
        chapters
    }
}

impl Parser for EpubParser {
    fn find_opf_path<R: Read + Seek>(
        &self,
        archive: &mut ZipArchive<R>,
    ) -> Result<String, EpubError> {
        let mut container_file = archive.by_name("META-INF/container.xml")?;
        let mut content = String::new();
        container_file.read_to_string(&mut content)?;

        let mut reader = Reader::from_str(&content);
        reader.config_mut().trim_text(true);

        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf)? {
                Event::Start(ref e) | Event::Empty(ref e)
                    if e.local_name().as_ref() == b"rootfile" =>
                {
                    for attr in e.attributes() {
                        let attr = attr?;
                        if attr.key.local_name().as_ref() == b"full-path" {
                            return Ok(attr
                                .normalized_value(XmlVersion::Implicit1_0)?
                                .into_owned());
                        }
                    }
                }
                Event::Eof => break,
                _ => (),
            }
            buf.clear();
        }

        Err(EpubError::OpfNotFound)
    }

    fn parse_opf<R: Read + Seek>(
        &self,
        archive: &mut ZipArchive<R>,
        opf_path: &str,
    ) -> Result<
        (
            String,
            String,
            Vec<ChapterInfo>,
            HashMap<String, String>,
            Option<String>,
        ),
        EpubError,
    > {
        let content = {
            let mut opf_file = archive.by_name(opf_path)?;
            let mut content = String::new();
            opf_file.read_to_string(&mut content)?;
            content
        };

        let mut reader = Reader::from_str(&content);
        reader.config_mut().trim_text(true);

        let mut title = String::from("Unknown Title");
        let mut author = String::from("Unknown Author");
        let mut manifest = std::collections::HashMap::new();
        let mut images = std::collections::HashMap::new();
        let mut spine = Vec::new();
        let mut cover_id = None;
        let mut ncx_id = None;
        let mut nav_path = None;

        let mut buf = Vec::new();
        let mut in_metadata = false;
        let mut current_tag = String::new();

        loop {
            match reader.read_event_into(&mut buf)? {
                Event::Start(ref e) | Event::Empty(ref e) => {
                    let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
                    match name.as_str() {
                        "metadata" => in_metadata = true,
                        "title" if in_metadata => current_tag = "title".to_string(),
                        "creator" if in_metadata => current_tag = "creator".to_string(),
                        "meta" if in_metadata => {
                            let mut name_attr = String::new();
                            let mut content_attr = String::new();
                            for attr in e.attributes() {
                                let attr = attr?;
                                match attr.key.local_name().as_ref() {
                                    b"name" => {
                                        name_attr = attr
                                            .normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned()
                                    }
                                    b"content" => {
                                        content_attr = attr
                                            .normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned()
                                    }
                                    _ => (),
                                }
                            }
                            if name_attr == "cover" {
                                cover_id = Some(content_attr);
                            }
                        }
                        "item" => {
                            let mut id = String::new();
                            let mut href = String::new();
                            let mut media_type = String::new();
                            let mut properties = String::new();
                            for attr in e.attributes() {
                                let attr = attr?;
                                match attr.key.local_name().as_ref() {
                                    b"id" => {
                                        id = attr
                                            .normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned()
                                    }
                                    b"href" => {
                                        href = attr
                                            .normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned()
                                    }
                                    b"media-type" => {
                                        media_type = attr
                                            .normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned()
                                    }
                                    b"properties" => {
                                        properties = attr
                                            .normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned()
                                    }
                                    _ => (),
                                }
                            }
                            if !id.is_empty() && !href.is_empty() {
                                if media_type.starts_with("image/") {
                                    images.insert(id.clone(), href.clone());
                                }
                                if properties.contains("nav") {
                                    nav_path = Some(href.clone());
                                }
                                manifest.insert(id, href);
                            }
                        }
                        "spine" => {
                            for attr in e.attributes() {
                                let attr = attr?;
                                if attr.key.local_name().as_ref() == b"toc" {
                                    ncx_id = Some(
                                        attr.normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned(),
                                    );
                                }
                            }
                        }
                        "itemref" => {
                            for attr in e.attributes() {
                                let attr = attr?;
                                if attr.key.local_name().as_ref() == b"idref" {
                                    spine.push(
                                        attr.normalized_value(XmlVersion::Implicit1_0)?
                                            .into_owned(),
                                    );
                                }
                            }
                        }
                        _ => (),
                    }
                }
                Event::End(ref e) => {
                    let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
                    if name == "metadata" {
                        in_metadata = false;
                    }
                    current_tag.clear();
                }
                Event::Text(ref e) if in_metadata => match current_tag.as_str() {
                    "title" => title = reader.decoder().decode(e)?.into_owned(),
                    "creator" => author = reader.decoder().decode(e)?.into_owned(),
                    _ => (),
                },
                Event::Text(_) => {}
                Event::Eof => break,
                _ => (),
            }
            buf.clear();
        }

        let base_path = Path::new(opf_path).parent().unwrap_or(Path::new(""));

        // Resolve image paths
        let images = images
            .into_iter()
            .map(|(id, href)| {
                let full_href = if base_path.as_os_str().is_empty() {
                    href
                } else {
                    base_path.join(href).to_string_lossy().into_owned()
                };
                (id, full_href)
            })
            .collect();

        let mut chapter_info = Vec::new();

        if let Some(nav_href) = nav_path {
            let full_nav_path = if base_path.as_os_str().is_empty() {
                nav_href
            } else {
                base_path.join(nav_href).to_string_lossy().into_owned()
            };

            if let Ok(mut nav_file) = archive.by_name(&full_nav_path) {
                let mut nav_content = String::new();
                if nav_file.read_to_string(&mut nav_content).is_ok() {
                    chapter_info = self.parse_nav(&nav_content, &full_nav_path);
                }
            }
        }

        if chapter_info.is_empty()
            && let Some(id) = ncx_id
            && let Some(href) = manifest.get(&id)
        {
            let full_ncx_path = if base_path.as_os_str().is_empty() {
                href.clone()
            } else {
                base_path.join(href).to_string_lossy().into_owned()
            };

            if let Ok(mut ncx_file) = archive.by_name(&full_ncx_path) {
                let mut ncx_content = String::new();
                if ncx_file.read_to_string(&mut ncx_content).is_ok() {
                    chapter_info = self.parse_ncx(&ncx_content, &full_ncx_path);
                }
            }
        }

        // Fallback to spine if TOC is missing or empty
        if chapter_info.is_empty() {
            chapter_info = spine
                .into_iter()
                .filter_map(|id| {
                    manifest.get(&id).map(|href| {
                        let full_href = if base_path.as_os_str().is_empty() {
                            href.clone()
                        } else {
                            base_path.join(href).to_string_lossy().into_owned()
                        };
                        ChapterInfo {
                            href: full_href,
                            id,
                            title: String::new(),
                            level: 0,
                        }
                    })
                })
                .collect();
        }

        Ok((title, author, chapter_info, images, cover_id))
    }

    fn parse_chapter_content(
        &self,
        html: &str,
        index: usize,
        chapter_href: &str,
    ) -> (String, Vec<ContentElement>) {
        let mut reader = Reader::from_str(html);
        let mut elements = Vec::new();
        let mut buf = Vec::new();
        let mut html_title = String::new();
        let mut first_h1 = String::new();

        let mut style_stack: Vec<TextStyle> = Vec::new();
        let mut current_style = TextStyle::default();
        let mut current_text_spans: Vec<StyledText> = Vec::new();
        let mut tag_stack: Vec<String> = Vec::new();

        let base_path = Path::new(chapter_href).parent().unwrap_or(Path::new(""));

        loop {
            match reader.read_event_into(&mut buf) {
                Ok(event) => match event {
                    Event::Start(ref e) | Event::Empty(ref e) => {
                        let name = String::from_utf8_lossy(e.local_name().as_ref()).to_lowercase();
                        let is_empty = matches!(event, Event::Empty(_));

                        match name.as_str() {
                            "title" | "h1" | "style" | "script" => {
                                if !is_empty {
                                    tag_stack.push(name.clone());
                                }
                            }
                            "img" => {
                                if !current_text_spans.is_empty() {
                                    elements.push(ContentElement::Text(current_text_spans.clone()));
                                    current_text_spans.clear();
                                }
                                e.attributes().for_each(|attr| {
                                    if let Ok(attr) = attr
                                        && attr.key.local_name().as_ref() == b"src"
                                        && let Ok(src) =
                                            reader.decoder().decode(attr.value.as_ref())
                                    {
                                        let full_path = if base_path.as_os_str().is_empty() {
                                            src.into_owned()
                                        } else {
                                            base_path
                                                .join(src.as_ref())
                                                .to_string_lossy()
                                                .into_owned()
                                        };
                                        let clean_path = Self::normalize_path(&full_path);
                                        elements.push(ContentElement::Image(clean_path));
                                    }
                                });
                                if !is_empty {
                                    tag_stack.push(name);
                                }
                            }
                            "p" | "div" | "blockquote" | "li" | "h2" | "h3" | "h4" | "h5"
                            | "h6" => {
                                if !current_text_spans.is_empty() {
                                    elements.push(ContentElement::Text(current_text_spans.clone()));
                                    current_text_spans.clear();
                                }
                                if !is_empty {
                                    tag_stack.push(name);
                                }
                            }
                            "br" => {
                                if !current_text_spans.is_empty() {
                                    elements.push(ContentElement::Text(current_text_spans.clone()));
                                    current_text_spans.clear();
                                }
                                if !is_empty {
                                    tag_stack.push(name);
                                }
                            }
                            "b" | "strong" => {
                                if !is_empty {
                                    style_stack.push(current_style.clone());
                                    current_style.bold = true;
                                    tag_stack.push(name);
                                }
                            }
                            "i" | "em" => {
                                if !is_empty {
                                    style_stack.push(current_style.clone());
                                    current_style.italic = true;
                                    tag_stack.push(name);
                                }
                            }
                            "u" | "ins" => {
                                if !is_empty {
                                    style_stack.push(current_style.clone());
                                    current_style.underline = true;
                                    tag_stack.push(name);
                                }
                            }
                            "s" | "strike" | "del" => {
                                if !is_empty {
                                    style_stack.push(current_style.clone());
                                    current_style.strikethrough = true;
                                    tag_stack.push(name);
                                }
                            }
                            _ => {
                                if !is_empty {
                                    tag_stack.push(name);
                                }
                            }
                        }
                    }
                    Event::Text(ref e) => {
                        let decoded = reader.decoder().decode(e).unwrap_or_default();
                        let current_tag = tag_stack.last().map(|s| s.as_str()).unwrap_or("");

                        match current_tag {
                            "title" => html_title = decoded.trim().to_owned(),
                            "h1" if first_h1.is_empty() => first_h1 = decoded.trim().to_owned(),
                            "style" | "script" => {}
                            _ => {
                                let text = decoded;
                                if !text.trim().is_empty()
                                    || (!text.is_empty() && !current_text_spans.is_empty())
                                {
                                    current_text_spans.push(StyledText {
                                        text: text.into_owned(),
                                        style: current_style.clone(),
                                    });
                                }
                            }
                        }
                    }
                    Event::End(ref e) => {
                        let name = String::from_utf8_lossy(e.local_name().as_ref()).to_lowercase();
                        tag_stack.pop();

                        match name.as_str() {
                            "b" | "strong" | "i" | "em" | "u" | "ins" | "s" | "strike" | "del" => {
                                if let Some(s) = style_stack.pop() {
                                    current_style = s;
                                }
                            }
                            "p" | "div" | "blockquote" | "li" | "h1" | "h2" | "h3" | "h4"
                            | "h5" | "h6" => {
                                if !current_text_spans.is_empty() {
                                    elements.push(ContentElement::Text(current_text_spans.clone()));
                                    current_text_spans.clear();
                                }

                                // Add a blank line (whitespace) after paragraph elements
                                if name.as_str() == "p" && !elements.is_empty() {
                                    elements.push(ContentElement::BlankLine);
                                }
                            }
                            _ => {}
                        }
                    }
                    Event::Eof => break,
                    _ => (),
                },
                Err(_) => break,
            }
            buf.clear();
        }

        if !current_text_spans.is_empty() {
            elements.push(ContentElement::Text(current_text_spans));
        }

        let title = if !first_h1.is_empty() {
            first_h1
        } else if !html_title.is_empty() {
            html_title
        } else {
            format!("Chapter {}", index + 1)
        };

        if let Some(ContentElement::Text(spans)) = elements.first_mut() {
            if let Some(first_span) = spans.first_mut()
                && first_span.text.trim_start().starts_with(&title)
            {
                let trimmed = first_span.text.trim_start();
                first_span.text = trimmed[title.len()..].trim_start().to_string();
            }
            spans.retain(|s| !s.text.is_empty());
        }

        // Remove empty text elements
        elements.retain(|e| {
            if let ContentElement::Text(spans) = e {
                !spans.is_empty()
            } else {
                true
            }
        });

        (title, elements)
    }
}