use std::any::Any;
use std::collections::HashMap;
use std::ops::Range;
use std::rc::Rc;

use ariadne::Label;
use ariadne::Report;
use ariadne::ReportKind;
use blockquote_style::AuthorPos::After;
use blockquote_style::AuthorPos::Before;
use blockquote_style::BlockquoteStyle;
use regex::Match;
use regex::Regex;
use runtime_fmt::rt_format;

use crate::compiler::compiler::Compiler;
use crate::compiler::compiler::Target::HTML;
use crate::document::document::Document;
use crate::document::element::ContainerElement;
use crate::document::element::ElemKind;
use crate::document::element::Element;
use crate::parser::parser::ParserState;
use crate::parser::rule::Rule;
use crate::parser::source::Cursor;
use crate::parser::source::Source;
use crate::parser::source::Token;
use crate::parser::source::VirtualSource;
use crate::parser::style::StyleHolder;
use crate::parser::util::parse_paragraph;
use crate::parser::util::process_escaped;
use crate::parser::util::Property;
use crate::parser::util::PropertyParser;

#[derive(Debug)]
pub struct Blockquote {
	pub(self) location: Token,
	pub(self) content: Vec<Box<dyn Element>>,
	pub(self) author: Option<String>,
	pub(self) cite: Option<String>,
	pub(self) url: Option<String>,
	/// Style of the blockquote
	pub(self) style: Rc<blockquote_style::BlockquoteStyle>,
}

impl Element for Blockquote {
	fn location(&self) -> &Token { &self.location }

	fn kind(&self) -> ElemKind { ElemKind::Block }

	fn element_name(&self) -> &'static str { "Blockquote" }

	fn compile(&self, compiler: &Compiler, document: &dyn Document) -> Result<String, String> {
		match compiler.target() {
			HTML => {
				let mut result = r#"<div class="blockquote-content">"#.to_string();
				let format_author = || -> Result<String, runtime_fmt::Error> {
					let mut result = String::new();
					if self.cite.is_some() || self.author.is_some() {
						result += r#"<p class="blockquote-author">"#;
						match (&self.author, &self.cite) {
							(Some(author), Some(cite)) => {
								result += rt_format!(
									self.style.format[0].as_str(),
									author,
									format!("<cite>{}</cite>", Compiler::sanitize(HTML, cite)),
								)?
								.as_str();
							}
							(Some(author), None) => {
								result += rt_format!(
									self.style.format[1].as_str(),
									Compiler::sanitize(HTML, author),
								)?
								.as_str()
							}
							(None, Some(cite)) => {
								result += rt_format!(
									self.style.format[2].as_str(),
									format!("<cite>{}</cite>", Compiler::sanitize(HTML, cite)),
								)?
								.as_str()
							}
							(None, None) => panic!(""),
						}
						result += "</p>";
					}
					Ok(result)
				};

				if let Some(url) = &self.url {
					result += format!(r#"<blockquote cite="{}">"#, Compiler::sanitize(HTML, url))
						.as_str();
				} else {
					result += "<blockquote>";
				}
				if self.style.author_pos == Before {
					result += format_author().as_str();
				}

				result += "<p>";
				for elem in &self.content {
					result += elem.compile(compiler, document)?.as_str();
				}
				result += "</p></blockquote>";
				if self.style.author_pos == After {
					result += format_author().as_str();
				}

				result += "</div>";
				Ok(result)
			}
			_ => todo!(""),
		}
	}

	fn as_container(&self) -> Option<&dyn ContainerElement> { Some(self) }
}

impl ContainerElement for Blockquote {
	fn contained(&self) -> &Vec<Box<dyn Element>> { &self.content }

	fn push(&mut self, elem: Box<dyn Element>) -> Result<(), String> {
		if elem.kind() == ElemKind::Block {
			return Err("Cannot add block element inside a blockquote".to_string());
		}

		self.content.push(elem);
		Ok(())
	}
}

#[auto_registry::auto_registry(registry = "rules", path = "crate::elements::blockquote")]
pub struct BlockquoteRule {
	start_re: Regex,
	continue_re: Regex,
	properties: PropertyParser,
}

impl BlockquoteRule {
	pub fn new() -> Self {
		let mut props = HashMap::new();
		props.insert(
			"author".to_string(),
			Property::new(false, "Quote author".to_string(), None),
		);
		props.insert(
			"cite".to_string(),
			Property::new(false, "Quote source".to_string(), None),
		);
		props.insert(
			"url".to_string(),
			Property::new(false, "Quote source url".to_string(), None),
		);

		Self {
			start_re: Regex::new(r"(?:^|\n)>(?:\[((?:\\.|[^\\\\])*?)\])?\s*(.*)").unwrap(),
			continue_re: Regex::new(r"(?:^|\n)>(\s*)(.*)").unwrap(),
			properties: PropertyParser { properties: props },
		}
	}

	fn parse_properties(
		&self,
		m: Match,
	) -> Result<(Option<String>, Option<String>, Option<String>), String> {
		let processed = process_escaped('\\', "]", m.as_str());
		let pm = self.properties.parse(processed.as_str())?;

		let author = pm
			.get("author", |_, s| -> Result<String, ()> { Ok(s.to_string()) })
			.map(|(_, s)| s)
			.ok();
		let cite = pm
			.get("cite", |_, s| -> Result<String, ()> { Ok(s.to_string()) })
			.map(|(_, s)| s)
			.ok();
		let url = pm
			.get("url", |_, s| -> Result<String, ()> { Ok(s.to_string()) })
			.map(|(_, s)| s)
			.ok();

		Ok((author, cite, url))
	}
}

impl Rule for BlockquoteRule {
	fn name(&self) -> &'static str { "Blockquote" }

	fn previous(&self) -> Option<&'static str> { Some("List") }

	fn next_match(&self, _state: &ParserState, cursor: &Cursor) -> Option<(usize, Box<dyn Any>)> {
		self.start_re
			.find_at(cursor.source.content(), cursor.pos)
			.map_or(None, |m| {
				Some((m.start(), Box::new([false; 0]) as Box<dyn Any>))
			})
	}

	fn on_match<'a>(
		&self,
		state: &ParserState,
		document: &'a (dyn Document<'a> + 'a),
		cursor: Cursor,
		_match_data: Box<dyn Any>,
	) -> (Cursor, Vec<Report<'_, (Rc<dyn Source>, Range<usize>)>>) {
		let mut reports = vec![];

		let content = cursor.source.content();
		let mut end_cursor = cursor.clone();
		loop {
			if let Some(captures) = self.start_re.captures_at(content, end_cursor.pos) {
				if captures.get(0).unwrap().start() != end_cursor.pos {
					break;
				}
				// Advance cursor
				end_cursor = end_cursor.at(captures.get(0).unwrap().end());

				// Properties
				let mut author = None;
				let mut cite = None;
				let mut url = None;
				if let Some(properties) = captures.get(1) {
					match self.parse_properties(properties) {
						Err(err) => {
							reports.push(
								Report::build(
									ReportKind::Warning,
									cursor.source.clone(),
									properties.start(),
								)
								.with_message("Invalid Blockquote Properties")
								.with_label(
									Label::new((cursor.source.clone(), properties.range()))
										.with_message(err)
										.with_color(state.parser.colors().warning),
								)
								.finish(),
							);
							break;
						}
						Ok(props) => (author, cite, url) = props,
					}
				}

				// Content
				let entry_start = captures.get(0).unwrap().start();
				let mut entry_content = captures.get(2).unwrap().as_str().to_string();
				let mut spacing: Option<(Range<usize>, &str)> = None;
				while let Some(captures) = self.continue_re.captures_at(content, end_cursor.pos) {
					// Advance cursor
					end_cursor = end_cursor.at(captures.get(0).unwrap().end());

					// Spacing
					let current_spacing = captures.get(1).unwrap().as_str();
					if let Some(spacing) = &spacing {
						if spacing.1 != current_spacing {
							reports.push(
								Report::build(
									ReportKind::Warning,
									cursor.source.clone(),
									captures.get(1).unwrap().start(),
								)
								.with_message("Invalid Blockquote Spacing")
								.with_label(
									Label::new((
										cursor.source.clone(),
										captures.get(1).unwrap().range(),
									))
									.with_message("Spacing for blockquote entries do not match")
									.with_color(state.parser.colors().warning),
								)
								.with_label(
									Label::new((cursor.source.clone(), spacing.0.clone()))
										.with_message("Previous spacing")
										.with_color(state.parser.colors().warning),
								)
								.finish(),
							);
						}
					} else {
						spacing = Some((captures.get(1).unwrap().range(), current_spacing));
					}

					entry_content += " ";
					entry_content += captures.get(2).unwrap().as_str();
				}

				// Parse entry content
				let token = Token::new(entry_start..end_cursor.pos, end_cursor.source.clone());
				let entry_src = Rc::new(VirtualSource::new(
					token.clone(),
					"Blockquote Entry".to_string(),
					entry_content,
				));
				let parsed_content = match parse_paragraph(state, entry_src, document) {
					Err(err) => {
						reports.push(
							Report::build(ReportKind::Warning, token.source(), token.range.start)
								.with_message("Unable to Parse Blockquote Entry")
								.with_label(
									Label::new((token.source(), token.range.clone()))
										.with_message(err)
										.with_color(state.parser.colors().warning),
								)
								.finish(),
						);
						break;
					}
					Ok(mut paragraph) => std::mem::replace(&mut paragraph.content, vec![]),
				};

				// Get style
				let style = state
					.shared
					.styles
					.borrow()
					.current(blockquote_style::STYLE_KEY)
					.downcast_rc::<BlockquoteStyle>()
					.unwrap();

				state.push(
					document,
					Box::new(Blockquote {
						location: Token::new(
							entry_start..end_cursor.pos,
							end_cursor.source.clone(),
						),
						content: parsed_content,
						author,
						cite,
						url,
						style,
					}),
				);
			} else {
				break;
			}
		}

		(end_cursor, reports)
	}

	fn register_styles(&self, holder: &mut StyleHolder) {
		holder.set_current(Rc::new(BlockquoteStyle::default()));
	}
}

mod blockquote_style {
	use serde::Deserialize;
	use serde::Serialize;

	use crate::impl_elementstyle;

	pub static STYLE_KEY: &'static str = "style.blockquote";

	#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
	pub enum AuthorPos {
		Before,
		After,
		None,
	}

	#[derive(Debug, Serialize, Deserialize)]
	pub struct BlockquoteStyle {
		pub author_pos: AuthorPos,
		pub format: [String; 3],
	}

	impl Default for BlockquoteStyle {
		fn default() -> Self {
			Self {
				author_pos: AuthorPos::After,
				format: [
					"A{author}, {cite}".into(),
					"B{author}".into(),
					"C{cite}".into(),
				],
			}
		}
	}

	impl_elementstyle!(BlockquoteStyle, STYLE_KEY);
}

#[cfg(test)]
mod tests {
	use crate::elements::paragraph::Paragraph;
	use crate::elements::style::Style;
	use crate::elements::text::Text;
	use crate::parser::langparser::LangParser;
	use crate::parser::parser::Parser;
	use crate::parser::source::SourceFile;
	use crate::validate_document;

	use super::*;

	#[test]
	pub fn parser() {
		let source = Rc::new(SourceFile::with_content(
			"".to_string(),
			r#"
BEFORE
>[author=A, cite=B, url=C] Some entry
> contin**ued here
> **
AFTER
"#
			.to_string(),
			None,
		));
		let parser = LangParser::default();
		let state = ParserState::new(&parser, None);
		let (doc, _) = parser.parse(state, source, None);

		validate_document!(doc.content().borrow(), 0,
			Paragraph { Text{ content == "BEFORE" }; };
			Blockquote {
				author == Some("A".to_string()),
				cite == Some("B".to_string()),
				url == Some("C".to_string())
			} {
				Text { content == "Some entry contin" };
				Style;
				Text { content == "ued here " };
				Style;
			};
			Paragraph { Text{ content == "AFTER" }; };
		);
	}
}