pubmed_parser/pmc/parser/

metadata.rs

use crate::common::{HistoryDate, PublicationDate};
use crate::pmc::domain::{FundingInfo, JournalMeta, SupplementaryMaterial};

use super::xml_utils;

/// Extract journal metadata.
///
/// Returns a [`JournalMeta`] without volume/issue — those belong to the article level
/// per the JATS DTD and are extracted separately via [`extract_volume`] / [`extract_issue`].
pub fn extract_journal_info(content: &str) -> JournalMeta {
    let title = xml_utils::extract_text_between(content, "<journal-title>", "</journal-title>")
        .unwrap_or_else(|| "Unknown Journal".to_string());

    let abbreviation = xml_utils::extract_text_between(
        content,
        "<journal-id journal-id-type=\"iso-abbrev\">",
        "</journal-id>",
    );

    // Extract ISSNs
    let mut issn_print = None;
    let mut issn_electronic = None;
    let mut pos = 0;
    while let Some(issn_start) = content[pos..].find("<issn") {
        let issn_start = pos + issn_start;
        if let Some(issn_end) = content[issn_start..].find("</issn>") {
            let issn_end = issn_start + issn_end;
            let issn_section = &content[issn_start..issn_end];

            if let Some(content_start) = issn_section.find(">") {
                let issn_value = &issn_section[content_start + 1..];

                if issn_section.contains("pub-type=\"epub\"") {
                    issn_electronic = Some(issn_value.to_string());
                } else if issn_section.contains("pub-type=\"ppub\"") {
                    issn_print = Some(issn_value.to_string());
                }
            }
            pos = issn_end;
        } else {
            break;
        }
    }

    let publisher =
        xml_utils::extract_text_between(content, "<publisher-name>", "</publisher-name>");

    JournalMeta {
        title,
        abbreviation,
        issn_print,
        issn_electronic,
        publisher,
    }
}

/// Extract volume number from `<volume>` element.
pub fn extract_volume(content: &str) -> Option<String> {
    xml_utils::extract_text_between(content, "<volume>", "</volume>")
}

/// Extract issue number from `<issue>` element.
pub fn extract_issue(content: &str) -> Option<String> {
    xml_utils::extract_text_between(content, "<issue>", "</issue>")
}

/// Extract structured publication dates from `<pub-date>` elements.
///
/// Returns a `Vec<PublicationDate>` with `pub_type` attribute preserved.
pub fn extract_pub_dates(content: &str) -> Vec<PublicationDate> {
    let mut dates = Vec::new();

    let mut pos = 0;
    while let Some(pd_start) = content[pos..].find("<pub-date") {
        let pd_start = pos + pd_start;
        if let Some(pd_end) = content[pd_start..].find("</pub-date>") {
            let pd_end = pd_start + pd_end + "</pub-date>".len();
            let pd_section = &content[pd_start..pd_end];

            let pub_type = xml_utils::extract_attribute_value(pd_section, "pub-type")
                .or_else(|| xml_utils::extract_attribute_value(pd_section, "date-type"));

            let year = xml_utils::extract_text_between(pd_section, "<year>", "</year>")
                .and_then(|y| y.parse::<u16>().ok());
            let month = xml_utils::extract_text_between(pd_section, "<month>", "</month>")
                .and_then(|m| m.parse::<u8>().ok());
            let day = xml_utils::extract_text_between(pd_section, "<day>", "</day>")
                .and_then(|d| d.parse::<u8>().ok());

            dates.push(PublicationDate {
                pub_type,
                year,
                month,
                day,
            });

            pos = pd_end;
        } else {
            break;
        }
    }

    dates
}

/// Extract publication date in YYYY-MM-DD format
pub fn extract_pub_date(content: &str) -> String {
    if let Some(year) = xml_utils::extract_text_between_ref(content, "<year>", "</year>") {
        if let Some(month) = xml_utils::extract_text_between_ref(content, "<month>", "</month>") {
            if let Some(day) = xml_utils::extract_text_between_ref(content, "<day>", "</day>") {
                return format!(
                    "{}-{:02}-{:02}",
                    year,
                    month.parse::<u32>().unwrap_or(1),
                    day.parse::<u32>().unwrap_or(1)
                );
            }
            return format!("{}-{:02}", year, month.parse::<u32>().unwrap_or(1));
        }
        return year.to_string();
    }
    "Unknown Date".to_string()
}

/// Extract DOI from article metadata
pub fn extract_doi(content: &str) -> Option<String> {
    let mut pos = 0;
    while let Some(id_start) = content[pos..].find(r#"<article-id pub-id-type="doi""#) {
        let id_start = pos + id_start;
        if let Some(content_start) = content[id_start..].find(">") {
            let content_start = id_start + content_start + 1;
            if let Some(content_end) = content[content_start..].find("</article-id>") {
                let content_end = content_start + content_end;
                return Some(content[content_start..content_end].trim().to_string());
            }
        }
        pos = id_start + 1;
    }
    None
}

/// Extract PMID from article metadata
pub fn extract_pmid(content: &str) -> Option<String> {
    let mut pos = 0;
    while let Some(id_start) = content[pos..].find(r#"<article-id pub-id-type="pmid""#) {
        let id_start = pos + id_start;
        if let Some(content_start) = content[id_start..].find(">") {
            let content_start = id_start + content_start + 1;
            if let Some(content_end) = content[content_start..].find("</article-id>") {
                let content_end = content_start + content_end;
                return Some(content[content_start..content_end].trim().to_string());
            }
        }
        pos = id_start + 1;
    }
    None
}

/// Extract article type from article metadata
pub fn extract_article_type(content: &str) -> Option<String> {
    // Look for article-type attribute in article tag
    if let Some(article_start) = content.find("<article")
        && let Some(article_end) = content[article_start..].find(">")
    {
        let article_tag = &content[article_start..article_start + article_end];
        if let Some(type_start) = article_tag.find("article-type=\"") {
            let type_start = type_start + 14; // Length of "article-type=\""
            if let Some(type_end) = article_tag[type_start..].find('"') {
                return Some(article_tag[type_start..type_start + type_end].to_string());
            }
        }
    }

    // Fallback: look in article-categories
    xml_utils::extract_text_between(content, "<subject>", "</subject>")
}

/// Extract keywords from article metadata
pub fn extract_keywords(content: &str) -> Vec<String> {
    let mut keywords = Vec::new();

    if let Some(kwd_start) = content.find("<kwd-group")
        && let Some(kwd_end) = content[kwd_start..].find("</kwd-group>")
    {
        let kwd_section = &content[kwd_start..kwd_start + kwd_end];

        let mut pos = 0;
        while let Some(kwd_start) = kwd_section[pos..].find("<kwd>") {
            let kwd_start = pos + kwd_start + 5; // Length of "<kwd>"
            if let Some(kwd_end) = kwd_section[kwd_start..].find("</kwd>") {
                let raw_keyword = kwd_section[kwd_start..kwd_start + kwd_end].trim();
                // Only strip XML tags if the keyword actually contains tags
                if raw_keyword.contains('<') {
                    let keyword = xml_utils::strip_xml_tags(raw_keyword);
                    if !keyword.is_empty() {
                        keywords.push(keyword);
                    }
                } else if !raw_keyword.is_empty() {
                    keywords.push(raw_keyword.to_string());
                }
                pos = kwd_start + kwd_end;
            } else {
                break;
            }
        }
    }

    keywords
}

/// Extract funding information
pub fn extract_funding(content: &str) -> Vec<FundingInfo> {
    let mut funding = Vec::new();

    if let Some(funding_start) = content.find("<funding-group>")
        && let Some(funding_end) = content[funding_start..].find("</funding-group>")
    {
        let funding_section =
            &content[funding_start..funding_start + funding_end + "</funding-group>".len()];

        // Extract funding statement (applies to the funding group as a whole)
        let statement = xml_utils::extract_text_between(
            funding_section,
            "<funding-statement>",
            "</funding-statement>",
        );

        let mut pos = 0;
        while let Some(award_start) = funding_section[pos..].find("<award-group") {
            let award_start = pos + award_start;
            if let Some(award_end) = funding_section[award_start..].find("</award-group>") {
                let award_end = award_start + award_end;
                let award_section = &funding_section[award_start..award_end];

                let source = xml_utils::extract_text_between(
                    award_section,
                    "<funding-source>",
                    "</funding-source>",
                )
                .unwrap_or_else(|| "Unknown Source".to_string());

                let award_id =
                    xml_utils::extract_text_between(award_section, "<award-id>", "</award-id>");

                funding.push(FundingInfo {
                    source,
                    award_id,
                    statement: statement.clone(),
                });
                pos = award_end;
            } else {
                break;
            }
        }
    }

    funding
}

/// Extract conflict of interest statement
pub fn extract_conflict_of_interest(content: &str) -> Option<String> {
    // Look for conflict of interest in fn-group
    if let Some(fn_start) = content.find("<fn-group")
        && let Some(fn_end) = content[fn_start..].find("</fn-group>")
    {
        let fn_section = &content[fn_start..fn_start + fn_end];

        // Look for conflict or competing interest
        let mut pos = 0;
        while let Some(fn_start) = fn_section[pos..].find("<fn") {
            let fn_start = pos + fn_start;
            if let Some(fn_end) = fn_section[fn_start..].find("</fn>") {
                let fn_end = fn_start + fn_end;
                let fn_content = &fn_section[fn_start..fn_end];

                if (fn_content.contains("conflict") || fn_content.contains("competing"))
                    && let Some(p_start) = fn_content.find("<p>")
                    && let Some(p_end) = fn_content[p_start..].find("</p>")
                {
                    let coi = &fn_content[p_start + 3..p_start + p_end];
                    return Some(xml_utils::strip_xml_tags(coi));
                }
                pos = fn_end;
            } else {
                break;
            }
        }
    }

    // Look for conflict statement in dedicated section
    if let Some(coi_start) = content.find("<sec")
        && let Some(coi_end) = content[coi_start..].find("</sec>")
    {
        let coi_section = &content[coi_start..coi_start + coi_end];
        if (coi_section.contains("conflict") || coi_section.contains("competing"))
            && let Some(title_start) = coi_section.find("<title>")
            && let Some(title_end) = coi_section[title_start..].find("</title>")
        {
            let title = &coi_section[title_start + 7..title_start + title_end];
            if (title.to_lowercase().contains("conflict")
                || title.to_lowercase().contains("competing"))
                && let Some(p_start) = coi_section.find("<p>")
                && let Some(p_end) = coi_section[p_start..].find("</p>")
            {
                let coi = &coi_section[p_start + 3..p_start + p_end];
                return Some(xml_utils::strip_xml_tags(coi));
            }
        }
    }

    None
}

/// Extract acknowledgments
///
/// Strips XML tags and decodes XML entities (e.g., `&#231;` → `ç`).
pub fn extract_acknowledgments(content: &str) -> Option<String> {
    xml_utils::extract_text_between(content, "<ack>", "</ack>")
        .map(|ack| xml_utils::strip_xml_tags(&ack))
        .map(|s| xml_utils::decode_xml_entities(&s).into_owned())
}

/// Extract data availability statement
pub fn extract_data_availability(content: &str) -> Option<String> {
    // Look for data availability in dedicated section
    if let Some(data_start) = content.find("<sec")
        && let Some(data_end) = content[data_start..].find("</sec>")
    {
        let data_section = &content[data_start..data_start + data_end];
        if data_section.contains("data") && data_section.contains("availab") {
            return Some(xml_utils::strip_xml_tags(data_section));
        }
    }

    // Look for data availability statement in supplementary material
    if let Some(supp_start) = content.find("<supplementary-material")
        && let Some(supp_end) = content[supp_start..].find("</supplementary-material>")
    {
        let supp_section = &content[supp_start..supp_start + supp_end];
        if supp_section.contains("data") && supp_section.contains("availab") {
            return Some(xml_utils::strip_xml_tags(supp_section));
        }
    }

    None
}

/// Extract supplementary materials
pub fn extract_supplementary_materials(content: &str) -> Vec<SupplementaryMaterial> {
    let mut materials = Vec::new();

    let mut pos = 0;
    while let Some(supp_start) = content[pos..].find("<supplementary-material") {
        let supp_start = pos + supp_start;
        if let Some(supp_end) = content[supp_start..].find("</supplementary-material>") {
            let supp_end = supp_start + supp_end;
            let supp_content = &content[supp_start..supp_end];

            let id = xml_utils::extract_attribute_value(supp_content, "id").unwrap_or_else(|| {
                let supp_num = materials.len() + 1;
                format!("supp_{supp_num}")
            });

            let label = xml_utils::extract_text_between(supp_content, "<label>", "</label>");
            let caption = xml_utils::extract_text_between(supp_content, "<caption>", "</caption>")
                .and_then(|caption_content| {
                    // First try to extract just the title from caption
                    xml_utils::extract_text_between(&caption_content, "<title>", "</title>")
                        .or_else(|| {
                            // If no title, extract all content and strip tags
                            Some(xml_utils::strip_xml_tags(&caption_content))
                        })
                })
                .unwrap_or_else(|| "No caption available".to_string());

            let content_type = xml_utils::extract_attribute_value(supp_content, "content-type");
            let href = xml_utils::extract_attribute_value(supp_content, "href")
                .or_else(|| xml_utils::extract_attribute_value(supp_content, "xlink:href"))
                .or_else(|| {
                    // Look for href in nested media tags
                    if let Some(media_start) = supp_content.find("<media") {
                        if let Some(media_end) = supp_content[media_start..].find(">") {
                            let media_tag = &supp_content[media_start..media_start + media_end + 1];
                            xml_utils::extract_attribute_value(media_tag, "xlink:href")
                                .or_else(|| xml_utils::extract_attribute_value(media_tag, "href"))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                });

            materials.push(SupplementaryMaterial {
                id,
                content_type,
                title: Some(caption),
                description: label,
                href,
            });
            pos = supp_end;
        } else {
            break;
        }
    }

    materials
}

/// Extract article title
pub fn extract_title(content: &str) -> String {
    xml_utils::extract_text_between_ref(content, "<article-title>", "</article-title>")
        .map(|s| s.to_string())
        .unwrap_or_else(|| "Unknown Title".to_string())
}

/// Extract article subtitle from `<title-group>/<subtitle>`
pub fn extract_subtitle(content: &str) -> Option<String> {
    let title_group = xml_utils::extract_element_content(content, "title-group")?;
    xml_utils::extract_text_between(&title_group, "<subtitle>", "</subtitle>")
        .map(|s| xml_utils::strip_xml_tags(&s))
        .filter(|s| !s.is_empty())
}

/// Extract article language
pub fn extract_language(content: &str) -> Option<String> {
    // Look for language in article tag
    if let Some(article_start) = content.find("<article")
        && let Some(article_end) = content[article_start..].find(">")
    {
        let article_tag = &content[article_start..article_start + article_end];
        if let Some(lang) = xml_utils::extract_attribute_value(article_tag, "xml:lang") {
            return Some(lang);
        }
    }
    None
}

/// Extract article identifiers (DOI, PMID, PMC ID, etc.)
pub fn extract_article_ids(content: &str) -> Vec<(String, String)> {
    let mut ids = Vec::new();

    let id_tags = xml_utils::find_all_tags(content, "article-id");
    for id_tag in id_tags {
        if let Some(id_type) = xml_utils::extract_attribute_value(&id_tag, "pub-id-type")
            && let Some(id_value) = xml_utils::extract_element_content(&id_tag, "article-id")
        {
            ids.push((id_type, id_value.trim().to_string()));
        }
    }

    ids
}

/// Extract copyright information
///
/// Decodes XML entities (e.g., `&#169;` → `©`).
pub fn extract_copyright(content: &str) -> Option<String> {
    xml_utils::extract_text_between(content, "<copyright-statement>", "</copyright-statement>")
        .or_else(|| {
            xml_utils::extract_text_between(content, "<copyright-year>", "</copyright-year>")
        })
        .map(|s| xml_utils::decode_xml_entities(&s).into_owned())
}

/// Extract license information
pub fn extract_license(content: &str) -> Option<String> {
    xml_utils::extract_element_content(content, "license")
        .map(|license_content| xml_utils::strip_xml_tags(&license_content))
}

/// Extract abstract text from article metadata
///
/// Handles both simple abstracts (`<abstract><p>...</p></abstract>`)
/// and structured abstracts with sections (`<abstract><sec><title>Background</title><p>...</p></sec>...</abstract>`).
pub fn extract_abstract(content: &str) -> Option<String> {
    let abstract_content = xml_utils::extract_element_content(content, "abstract")?;

    // Collect all paragraph text, stripping XML tags
    let paragraphs = xml_utils::extract_all_text_between(&abstract_content, "<p", "</p>");
    if paragraphs.is_empty() {
        // Fallback: strip all tags from abstract content
        let text = xml_utils::strip_xml_tags(&abstract_content);
        if text.is_empty() {
            return None;
        }
        return Some(text);
    }

    let text = paragraphs
        .iter()
        .map(|p| {
            // Each paragraph may start with attributes like `id="Par1">`
            // Find the closing `>` of the opening tag remnant and take content after it
            let content = if let Some(gt_pos) = p.find('>') {
                &p[gt_pos + 1..]
            } else {
                p
            };
            xml_utils::strip_xml_tags(content)
        })
        .filter(|s| !s.is_empty())
        .collect::<Vec<_>>()
        .join(" ");

    if text.is_empty() { None } else { Some(text) }
}

/// Extract publication history dates from `<history>` element
///
/// Parses `<date date-type="received">`, `<date date-type="accepted">`, etc.
pub fn extract_history_dates(content: &str) -> Vec<HistoryDate> {
    let mut dates = Vec::new();

    let history_content = match xml_utils::extract_element_content(content, "history") {
        Some(c) => c,
        None => return dates,
    };

    let date_tags = xml_utils::find_all_tags(&history_content, "date");
    for date_tag in &date_tags {
        let date_type = match xml_utils::extract_attribute_value(date_tag, "date-type") {
            Some(dt) => dt,
            None => continue,
        };

        let year = xml_utils::extract_text_between(date_tag, "<year>", "</year>")
            .and_then(|y| y.parse::<u16>().ok());
        let month = xml_utils::extract_text_between(date_tag, "<month>", "</month>")
            .and_then(|m| m.parse::<u8>().ok());
        let day = xml_utils::extract_text_between(date_tag, "<day>", "</day>")
            .and_then(|d| d.parse::<u8>().ok());

        dates.push(HistoryDate {
            date_type,
            year,
            month,
            day,
        });
    }

    dates
}

/// Extract article categories from `<article-categories>/<subj-group>/<subject>`
pub fn extract_categories(content: &str) -> Vec<String> {
    let mut categories = Vec::new();

    let categories_content = match xml_utils::extract_element_content(content, "article-categories")
    {
        Some(c) => c,
        None => return categories,
    };

    let subjects =
        xml_utils::extract_all_text_between(&categories_content, "<subject>", "</subject>");
    for subject in subjects {
        let cleaned = xml_utils::strip_xml_tags(&subject);
        if !cleaned.is_empty() {
            categories.push(cleaned);
        }
    }

    categories
}

/// Extract license URL from `<license xlink:href="...">` attribute
/// or from `<ali:license_ref>` element content
pub fn extract_license_url(content: &str) -> Option<String> {
    // Try <license xlink:href="..."> first
    if let Some(license_start) = content.find("<license")
        && let Some(tag_end) = content[license_start..].find('>')
    {
        let license_tag = &content[license_start..license_start + tag_end + 1];
        let url = xml_utils::extract_attribute_value(license_tag, "xlink:href")
            .or_else(|| xml_utils::extract_attribute_value(license_tag, "href"));
        if url.is_some() {
            return url;
        }
    }

    // Fallback: extract URL from <ali:license_ref> element content
    xml_utils::extract_element_content(content, "ali:license_ref")
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

/// Extract first page number from `<fpage>` element
///
/// Handles `<fpage>` with or without attributes (e.g., `<fpage seq="b">54</fpage>`).
pub fn extract_fpage(content: &str) -> Option<String> {
    xml_utils::extract_element_content(content, "fpage")
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

/// Extract last page number from `<lpage>` element
///
/// Handles `<lpage>` with or without attributes.
pub fn extract_lpage(content: &str) -> Option<String> {
    xml_utils::extract_element_content(content, "lpage")
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

/// Extract electronic location identifier from `<elocation-id>` element
pub fn extract_elocation_id(content: &str) -> Option<String> {
    xml_utils::extract_text_between(content, "<elocation-id>", "</elocation-id>")
}

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

    #[test]
    fn test_extract_title() {
        let content = r#"<article-title>Test Article Title</article-title>"#;
        let title = extract_title(content);
        assert_eq!(title, "Test Article Title");
    }

    #[test]
    fn test_extract_doi() {
        let content = r#"<article-id pub-id-type="doi">10.1234/test.doi</article-id>"#;
        let doi = extract_doi(content);
        assert_eq!(doi, Some("10.1234/test.doi".to_string()));
    }

    #[test]
    fn test_extract_pmid() {
        let content = r#"<article-id pub-id-type="pmid">12345678</article-id>"#;
        let pmid = extract_pmid(content);
        assert_eq!(pmid, Some("12345678".to_string()));
    }

    #[test]
    fn test_extract_keywords() {
        let content = r#"
        <kwd-group>
            <kwd>keyword1</kwd>
            <kwd>keyword2</kwd>
            <kwd>keyword3</kwd>
        </kwd-group>
        "#;

        let keywords = extract_keywords(content);
        assert_eq!(keywords, vec!["keyword1", "keyword2", "keyword3"]);
    }

    #[test]
    fn test_extract_keywords_with_nested_tags() {
        let content = r#"
        <kwd-group>
            <kwd><italic toggle="yes">Prevotella copri</italic></kwd>
            <kwd>normal keyword</kwd>
            <kwd><bold>important</bold> keyword</kwd>
        </kwd-group>
        "#;

        let keywords = extract_keywords(content);
        assert_eq!(
            keywords,
            vec!["Prevotella copri", "normal keyword", "important keyword"]
        );
    }

    #[test]
    fn test_extract_pub_date() {
        let content_full = r#"<year>2023</year><month>12</month><day>25</day>"#;
        assert_eq!(extract_pub_date(content_full), "2023-12-25");

        let content_year_month = r#"<year>2023</year><month>12</month>"#;
        assert_eq!(extract_pub_date(content_year_month), "2023-12");

        let content_year_only = r#"<year>2023</year>"#;
        assert_eq!(extract_pub_date(content_year_only), "2023");

        let content_no_date = r#"<title>No date here</title>"#;
        assert_eq!(extract_pub_date(content_no_date), "Unknown Date");
    }

    #[test]
    fn test_extract_article_type() {
        let content = r#"<article article-type="research-article">Content</article>"#;
        let article_type = extract_article_type(content);
        assert_eq!(article_type, Some("research-article".to_string()));
    }

    #[test]
    fn test_extract_language() {
        let content = r#"<article xml:lang="en">Content</article>"#;
        let language = extract_language(content);
        assert_eq!(language, Some("en".to_string()));
    }

    #[test]
    fn test_extract_article_ids() {
        let content = r#"
        <article-id pub-id-type="doi">10.1234/test</article-id>
        <article-id pub-id-type="pmid">12345</article-id>
        <article-id pub-id-type="pmc">PMC123456</article-id>
        "#;

        let ids = extract_article_ids(content);
        assert_eq!(ids.len(), 3);
        assert!(ids.contains(&("doi".to_string(), "10.1234/test".to_string())));
        assert!(ids.contains(&("pmid".to_string(), "12345".to_string())));
        assert!(ids.contains(&("pmc".to_string(), "PMC123456".to_string())));
    }

    #[test]
    fn test_extract_acknowledgments() {
        let content = r#"<ack><p>We thank the contributors for their valuable input.</p></ack>"#;
        let ack = extract_acknowledgments(content);
        assert_eq!(
            ack,
            Some("We thank the contributors for their valuable input.".to_string())
        );
    }

    #[test]
    fn test_extract_abstract_simple() {
        let content = r#"<abstract><p>This is a simple abstract.</p></abstract>"#;
        let result = extract_abstract(content);
        assert_eq!(result, Some("This is a simple abstract.".to_string()));
    }

    #[test]
    fn test_extract_abstract_structured() {
        let content = r#"
        <abstract id="Abs1">
            <sec>
                <title>Background</title>
                <p>Background text.</p>
            </sec>
            <sec>
                <title>Methods</title>
                <p>Methods text.</p>
            </sec>
        </abstract>
        "#;
        let result = extract_abstract(content);
        assert!(result.is_some());
        let text = result.unwrap();
        assert!(text.contains("Background text."));
        assert!(text.contains("Methods text."));
    }

    #[test]
    fn test_extract_abstract_with_attributes() {
        let content = r#"<abstract><p id="Par1">Text with id attribute.</p></abstract>"#;
        let result = extract_abstract(content);
        assert_eq!(result, Some("Text with id attribute.".to_string()));
    }

    #[test]
    fn test_extract_abstract_missing() {
        let content = r#"<title>No abstract here</title>"#;
        let result = extract_abstract(content);
        assert!(result.is_none());
    }

    #[test]
    fn test_extract_history_dates() {
        let content = r#"
        <history>
            <date date-type="received">
                <day>21</day>
                <month>2</month>
                <year>2019</year>
            </date>
            <date date-type="accepted">
                <day>23</day>
                <month>4</month>
                <year>2019</year>
            </date>
        </history>
        "#;
        let dates = extract_history_dates(content);
        assert_eq!(dates.len(), 2);

        assert_eq!(dates[0].date_type, "received");
        assert_eq!(dates[0].year, Some(2019));
        assert_eq!(dates[0].month, Some(2));
        assert_eq!(dates[0].day, Some(21));

        assert_eq!(dates[1].date_type, "accepted");
        assert_eq!(dates[1].year, Some(2019));
        assert_eq!(dates[1].month, Some(4));
        assert_eq!(dates[1].day, Some(23));
    }

    #[test]
    fn test_extract_history_dates_compact() {
        let content = r#"
        <history>
<date date-type="received"><day>09</day><month>5</month><year>2023</year></date>
<date date-type="accepted"><day>29</day><month>6</month><year>2023</year></date>
</history>
        "#;
        let dates = extract_history_dates(content);
        assert_eq!(dates.len(), 2);
        assert_eq!(dates[0].date_type, "received");
        assert_eq!(dates[0].year, Some(2023));
        assert_eq!(dates[0].month, Some(5));
        assert_eq!(dates[0].day, Some(9));
    }

    #[test]
    fn test_extract_history_dates_missing() {
        let content = r#"<article-meta><title>No history</title></article-meta>"#;
        let dates = extract_history_dates(content);
        assert!(dates.is_empty());
    }

    #[test]
    fn test_extract_categories() {
        let content = r#"
        <article-categories>
            <subj-group subj-group-type="heading">
                <subject>Original Article</subject>
            </subj-group>
        </article-categories>
        "#;
        let categories = extract_categories(content);
        assert_eq!(categories, vec!["Original Article"]);
    }

    #[test]
    fn test_extract_categories_multiple() {
        let content = r#"
        <article-categories>
            <subj-group subj-group-type="heading">
                <subject>Research Article</subject>
            </subj-group>
            <subj-group subj-group-type="discipline">
                <subject>Biology</subject>
                <subject>Medicine</subject>
            </subj-group>
        </article-categories>
        "#;
        let categories = extract_categories(content);
        assert_eq!(categories.len(), 3);
        assert!(categories.contains(&"Research Article".to_string()));
        assert!(categories.contains(&"Biology".to_string()));
        assert!(categories.contains(&"Medicine".to_string()));
    }

    #[test]
    fn test_extract_categories_missing() {
        let content = r#"<title>No categories</title>"#;
        let categories = extract_categories(content);
        assert!(categories.is_empty());
    }

    #[test]
    fn test_extract_license_url() {
        let content = r#"<license license-type="open-access" xlink:href="http://creativecommons.org/licenses/by-nc-nd/3.0/"><license-p>Text</license-p></license>"#;
        let url = extract_license_url(content);
        assert_eq!(
            url,
            Some("http://creativecommons.org/licenses/by-nc-nd/3.0/".to_string())
        );
    }

    #[test]
    fn test_extract_license_url_missing() {
        let content = r#"<license><license-p>No URL</license-p></license>"#;
        let url = extract_license_url(content);
        assert!(url.is_none());
    }

    #[test]
    fn test_extract_fpage_lpage() {
        let content = r#"<fpage>1865</fpage><lpage>1868</lpage>"#;
        assert_eq!(extract_fpage(content), Some("1865".to_string()));
        assert_eq!(extract_lpage(content), Some("1868".to_string()));
    }

    #[test]
    fn test_extract_elocation_id() {
        let content = r#"<elocation-id>e12345</elocation-id>"#;
        assert_eq!(extract_elocation_id(content), Some("e12345".to_string()));
    }

    #[test]
    fn test_extract_elocation_id_missing() {
        let content = r#"<fpage>100</fpage>"#;
        assert!(extract_elocation_id(content).is_none());
    }
}