docx-reader 0.1.1

use serde::ser::{SerializeStruct, Serializer};
use serde::Serialize;

use super::*;
use crate::types::*;

#[derive(Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Paragraph {
	pub id: String,
	pub children: Vec<ParagraphChild>,
	pub property: ParagraphProperty,
	pub has_numbering: bool,
}

impl Default for Paragraph {
	fn default() -> Self {
		Self {
			id: crate::generate_para_id(),
			children: Vec::new(),
			property: ParagraphProperty::new(),
			has_numbering: false,
		}
	}
}

#[derive(Debug, Clone, PartialEq)]
pub enum ParagraphChild {
	Run(Box<Run>),
	Insert(Insert),
	Delete(Delete),
	Hyperlink(Hyperlink),
	StructuredDataTag(Box<StructuredDataTag>),
}

impl Serialize for ParagraphChild {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		match *self {
			ParagraphChild::Run(ref r) => {
				let mut t = serializer.serialize_struct("Run", 2)?;
				t.serialize_field("type", "run")?;
				t.serialize_field("data", r)?;
				t.end()
			}
			ParagraphChild::Insert(ref r) => {
				let mut t = serializer.serialize_struct("Insert", 2)?;
				t.serialize_field("type", "insert")?;
				t.serialize_field("data", r)?;
				t.end()
			}
			ParagraphChild::Delete(ref r) => {
				let mut t = serializer.serialize_struct("Delete", 2)?;
				t.serialize_field("type", "delete")?;
				t.serialize_field("data", r)?;
				t.end()
			}
			ParagraphChild::Hyperlink(ref r) => {
				let mut t = serializer.serialize_struct("hyperlink", 2)?;
				t.serialize_field("type", "hyperlink")?;
				t.serialize_field("data", r)?;
				t.end()
			}
			ParagraphChild::StructuredDataTag(ref r) => {
				let mut t = serializer.serialize_struct("StructuredDataTag", 2)?;
				t.serialize_field("type", "structuredDataTag")?;
				t.serialize_field("data", r)?;
				t.end()
			}
		}
	}
}

impl Paragraph {
	pub fn new() -> Paragraph {
		Default::default()
	}

	pub fn id(mut self, id: impl Into<String>) -> Self {
		self.id = id.into();
		self
	}

	pub fn children(&self) -> &Vec<ParagraphChild> {
		&self.children
	}

	pub fn add_run(mut self, run: Run) -> Paragraph {
		self.children.push(ParagraphChild::Run(Box::new(run)));
		self
	}

	pub fn add_hyperlink(mut self, link: Hyperlink) -> Self {
		self.children.push(ParagraphChild::Hyperlink(link));
		self
	}

	pub fn add_structured_data_tag(mut self, t: StructuredDataTag) -> Self {
		self.children
			.push(ParagraphChild::StructuredDataTag(Box::new(t)));
		self
	}

	pub fn add_insert(mut self, insert: Insert) -> Paragraph {
		self.children.push(ParagraphChild::Insert(insert));
		self
	}

	pub fn add_delete(mut self, delete: Delete) -> Paragraph {
		self.children.push(ParagraphChild::Delete(delete));
		self
	}

	pub fn align(mut self, alignment_type: AlignmentType) -> Paragraph {
		self.property = self.property.align(alignment_type);
		self
	}

	pub fn style(mut self, style_id: &str) -> Paragraph {
		self.property = self.property.style(style_id);
		self
	}

	pub fn keep_next(mut self, v: bool) -> Self {
		self.property = self.property.keep_next(v);
		self
	}

	pub fn keep_lines(mut self, v: bool) -> Self {
		self.property = self.property.keep_lines(v);
		self
	}

	pub fn outline_lvl(mut self, v: usize) -> Self {
		self.property = self.property.outline_lvl(v);
		self
	}

	pub fn page_break_before(mut self, v: bool) -> Self {
		self.property = self.property.page_break_before(v);
		self
	}

	pub fn widow_control(mut self, v: bool) -> Self {
		self.property = self.property.widow_control(v);
		self
	}

	pub fn section_property(mut self, s: SectionProperty) -> Self {
		self.property = self.property.section_property(s);
		self
	}

	pub fn add_tab(mut self, t: Tab) -> Self {
		self.property = self.property.add_tab(t);
		self
	}

	pub fn indent(
		mut self,
		left: Option<i32>,
		special_indent: Option<SpecialIndentType>,
		end: Option<i32>,
		start_chars: Option<i32>,
	) -> Paragraph {
		self.property = self.property.indent(left, special_indent, end, start_chars);
		self
	}

	pub fn hanging_chars(mut self, chars: i32) -> Paragraph {
		self.property = self.property.hanging_chars(chars);
		self
	}

	pub fn first_line_chars(mut self, chars: i32) -> Paragraph {
		self.property = self.property.first_line_chars(chars);
		self
	}

	pub fn numbering(mut self, id: NumberingId, level: IndentLevel) -> Self {
		self.property = self.property.numbering(id, level);
		self.has_numbering = true;
		self
	}

	pub fn size(mut self, size: usize) -> Self {
		self.property.run_property = self.property.run_property.size(size);
		self
	}

	pub fn bold(mut self) -> Self {
		self.property.run_property = self.property.run_property.bold();
		self
	}

	pub fn italic(mut self) -> Self {
		self.property.run_property = self.property.run_property.italic();
		self
	}

	pub fn fonts(mut self, f: RunFonts) -> Self {
		self.property.run_property = self.property.run_property.fonts(f);
		self
	}

	pub fn run_property(mut self, p: RunProperty) -> Self {
		self.property.run_property = p;
		self
	}

	pub fn line_spacing(mut self, spacing: LineSpacing) -> Self {
		self.property = self.property.line_spacing(spacing);
		self
	}

	pub fn character_spacing(mut self, spacing: i32) -> Self {
		self.property = self.property.character_spacing(spacing);
		self
	}

	pub fn delete(mut self, author: impl Into<String>, date: impl Into<String>) -> Self {
		self.property.run_property.del = Some(Delete::new().author(author).date(date));
		self
	}

	pub fn insert(mut self, author: impl Into<String>, date: impl Into<String>) -> Self {
		self.property.run_property.ins = Some(Insert::new_with_empty().author(author).date(date));
		self
	}

	pub fn paragraph_property_change(mut self, p: ParagraphPropertyChange) -> Self {
		self.property = self.property.paragraph_property_change(p);
		self
	}

	pub fn raw_text(&self) -> String {
		let mut s = "".to_string();
		// For now support only run and ins.
		for c in self.children.iter() {
			match c {
				ParagraphChild::Insert(i) => {
					for c in i.children.iter() {
						if let InsertChild::Run(r) = c {
							for c in r.children.iter() {
								if let RunChild::Text(t) = c {
									s.push_str(&t.text);
								}
							}
						}
					}
				}
				ParagraphChild::Run(run) => {
					for c in run.children.iter() {
						if let RunChild::Text(t) = c {
							s.push_str(&t.text);
						}
					}
				}
				_ => {}
			}
		}
		s
	}
}