Documentation
// Copyright © 2026 Stephan Kunz
//! Epilog section types: `EpilogNode`, `EpilogComment`, `XmlEpilog`.

use core::ops::Range;

use crate::helpers::{find_bytes, skip_whitespace};

/// A node that may appear in the document epilog (after the root element).
pub enum EpilogNode<'xml> {
	/// A comment: `<!-- … -->`.
	Comment(EpilogComment<'xml>),
}

/// A comment in the document epilog (after the root element).
#[derive(Clone)]
pub struct EpilogComment<'xml> {
	xml_text: &'xml str,
	range: Range<usize>,
}

impl<'xml> EpilogComment<'xml> {
	/// Comment body with `<!--` and `-->` stripped.
	pub fn text(&self) -> &'xml str {
		let s = &self.xml_text[self.range.clone()];
		s.strip_prefix("<!--")
			.and_then(|r| r.strip_suffix("-->"))
			.unwrap_or(s)
	}

	/// Byte range of this node in the source text.
	pub fn range(&self) -> Range<usize> {
		self.range.clone()
	}
}

/// Iterator over comment nodes in the document epilog (after the root element).
///
/// Whitespace is skipped. Any other content causes the iterator to stop.
/// Malformed input causes the iterator to stop rather than error.
pub struct XmlEpilog<'xml> {
	pub(crate) xml_text: &'xml str,
	pub(crate) pos: usize,
}

impl<'xml> Iterator for XmlEpilog<'xml> {
	type Item = EpilogNode<'xml>;

	fn next(&mut self) -> Option<Self::Item> {
		let b = self.xml_text.as_bytes();
		self.pos = skip_whitespace(self.xml_text, self.pos);
		if self.pos >= b.len() {
			return None;
		}
		if b[self.pos] != b'<' {
			return None;
		}
		if b.get(self.pos + 1..self.pos + 4) == Some(b"!--") {
			let end = find_bytes(b, self.pos + 4, b"-->")? + 3;
			let range = self.pos..end;
			self.pos = end;
			return Some(EpilogNode::Comment(EpilogComment {
				xml_text: self.xml_text,
				range,
			}));
		}
		None // anything else — stop
	}
}

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

	const fn is_normal<T: Sized + Send + Sync>() {}

	#[test]
	const fn normal_types() {
		is_normal::<EpilogComment>();
		is_normal::<&EpilogComment>();
		is_normal::<XmlEpilog>();
		is_normal::<&XmlEpilog>();
	}

	#[test]
	fn comment_text_strips_markers() {
		let src = "<!-- after root -->";
		let c = EpilogComment {
			xml_text: src,
			range: 0..src.len(),
		};
		assert_eq!(c.text(), " after root ");
		assert_eq!(c.range(), 0..src.len());
	}

	#[test]
	fn epilog_yields_one_comment() {
		let xml = "<!-- one -->";
		let mut iter = XmlEpilog { xml_text: xml, pos: 0 };
		let EpilogNode::Comment(c) = iter.next().unwrap();
		assert_eq!(c.text(), " one ");
		assert!(iter.next().is_none());
	}

	#[test]
	fn epilog_stops_on_non_comment() {
		let xml = "<extra/>";
		let mut iter = XmlEpilog { xml_text: xml, pos: 0 };
		assert!(iter.next().is_none());
	}

	#[test]
	fn epilog_stops_on_malformed_comment() {
		let xml = "<!-- unclosed";
		let mut iter = XmlEpilog { xml_text: xml, pos: 0 };
		assert!(iter.next().is_none());
	}
}