use super::consts::ManipulatorType;
use super::id_vec::IdBackedVec;
use super::manipulator_group::ManipulatorGroup;
use super::manipulator_point::ManipulatorPoint;

use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use dyn_any::{DynAny, StaticType};
use glam::{DAffine2, DVec2};
use kurbo::{BezPath, PathEl, Shape};
use serde::{Deserialize, Serialize};

/// [Subpath] represents a single vector path, containing many [ManipulatorGroups].
/// For each closed shape we keep a [Subpath] which contains the [ManipulatorGroup]s (handles and anchors) that define that shape.
// TODO Add "closed" bool to subpath
#[derive(PartialEq, Clone, Debug, Default, Serialize, Deserialize, DynAny)]
pub struct Subpath(IdBackedVec<ManipulatorGroup>);

impl Subpath {
	// ** INITIALIZATION **

	/// Create a new [Subpath] with no [ManipulatorGroup]s.
	pub const fn new() -> Self {
		Subpath(IdBackedVec::new())
	}

	/// Construct a [Subpath] from a point iterator
	pub fn from_points(points: impl Iterator<Item = DVec2>, closed: bool) -> Self {
		let manipulator_groups = points.map(ManipulatorGroup::new_with_anchor);

		let mut p_line = Subpath(IdBackedVec::default());

		p_line.0.push_range(manipulator_groups);
		if closed {
			p_line.0.push(ManipulatorGroup::closed());
		}

		p_line
	}

	/// Create a new [Subpath] from a [kurbo Shape](Shape).
	/// This exists to smooth the transition away from Kurbo
	pub fn from_kurbo_shape<T: Shape>(shape: &T) -> Self {
		shape.path_elements(0.1).into()
	}

	// ** PRIMITIVE CONSTRUCTION **

	/// constructs a rectangle with `p1` as the lower left and `p2` as the top right
	pub fn new_rect(p1: DVec2, p2: DVec2) -> Self {
		Subpath(
			vec![
				ManipulatorGroup::new_with_anchor(p1),
				ManipulatorGroup::new_with_anchor(DVec2::new(p1.x, p2.y)),
				ManipulatorGroup::new_with_anchor(p2),
				ManipulatorGroup::new_with_anchor(DVec2::new(p2.x, p1.y)),
				ManipulatorGroup::closed(),
			]
			.into_iter()
			.collect(),
		)
	}

	pub fn new_ellipse(p1: DVec2, p2: DVec2) -> Self {
		let x_height = DVec2::new((p2.x - p1.x).abs(), 0.);
		let y_height = DVec2::new(0., (p2.y - p1.y).abs());
		let center = (p1 + p2) * 0.5;
		let top = center + y_height * 0.5;
		let bottom = center - y_height * 0.5;
		let left = center + x_height * 0.5;
		let right = center - x_height * 0.5;

		// Constant explained here https://stackoverflow.com/a/27863181
		let curve_constant = 0.55228_3;
		let handle_offset_x = x_height * curve_constant * 0.5;
		let handle_offset_y = y_height * curve_constant * 0.5;

		Subpath(
			vec![
				ManipulatorGroup::new_with_handles(top, Some(top + handle_offset_x), Some(top - handle_offset_x)),
				ManipulatorGroup::new_with_handles(right, Some(right + handle_offset_y), Some(right - handle_offset_y)),
				ManipulatorGroup::new_with_handles(bottom, Some(bottom - handle_offset_x), Some(bottom + handle_offset_x)),
				ManipulatorGroup::new_with_handles(left, Some(left - handle_offset_y), Some(left + handle_offset_y)),
				ManipulatorGroup::closed(),
			]
			.into_iter()
			.collect(),
		)
	}

	/// constructs an ngon
	/// `radius` is the distance from the `center` to any vertex, or the radius of the circle the ngon may be inscribed inside
	/// `sides` is the number of sides
	pub fn new_ngon(center: DVec2, sides: u64, radius: f64) -> Self {
		let mut manipulator_groups = vec![];
		for i in 0..sides {
			let angle = (i as f64) * core::f64::consts::TAU / (sides as f64);
			let center = center + DVec2::ONE * radius;
			let position = ManipulatorGroup::new_with_anchor(DVec2::new(center.x + radius * f64::cos(angle), center.y + radius * f64::sin(angle)) * 0.5);

			manipulator_groups.push(position);
		}
		manipulator_groups.push(ManipulatorGroup::closed());

		Subpath(manipulator_groups.into_iter().collect())
	}

	/// Constructs a line from `p1` to `p2`
	pub fn new_line(p1: DVec2, p2: DVec2) -> Self {
		Subpath(vec![ManipulatorGroup::new_with_anchor(p1), ManipulatorGroup::new_with_anchor(p2)].into_iter().collect())
	}

	/// Constructs a set of lines from `p1` to `pN`
	pub fn new_poly_line<T: Into<glam::DVec2>>(points: Vec<T>) -> Self {
		let manipulator_groups = points.into_iter().map(|point| ManipulatorGroup::new_with_anchor(point.into()));
		let mut p_line = Subpath(IdBackedVec::default());
		p_line.0.push_range(manipulator_groups);
		p_line
	}

	pub fn new_spline<T: Into<glam::DVec2>>(points: Vec<T>) -> Self {
		let mut new = Self::default();
		// shadow `points`
		let points: Vec<DVec2> = points.into_iter().map(Into::<glam::DVec2>::into).collect();

		// Number of points = number of points to find handles for
		let n = points.len();

		// matrix coefficients a, b and c (see https://mathworld.wolfram.com/CubicSpline.html)
		// because the 'a' coefficients are all 1 they need not be stored
		// this algorithm does a variation of the above algorithm.
		// Instead of using the traditional cubic: a + bt + ct^2 + dt^3, we use the bezier cubic.

		let mut b = vec![DVec2::new(4.0, 4.0); n];
		b[0] = DVec2::new(2.0, 2.0);
		b[n - 1] = DVec2::new(2.0, 2.0);

		let mut c = vec![DVec2::new(1.0, 1.0); n];

		// 'd' is the the second point in a cubic bezier, which is what we solve for
		let mut d = vec![DVec2::ZERO; n];

		d[0] = DVec2::new(2.0 * points[1].x + points[0].x, 2.0 * points[1].y + points[0].y);
		d[n - 1] = DVec2::new(3.0 * points[n - 1].x, 3.0 * points[n - 1].y);
		for idx in 1..(n - 1) {
			d[idx] = DVec2::new(4.0 * points[idx].x + 2.0 * points[idx + 1].x, 4.0 * points[idx].y + 2.0 * points[idx + 1].y);
		}

		// Solve with Thomas algorithm (see https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm)
		// do row operations to eliminate `a` coefficients
		c[0] /= -b[0];
		d[0] /= -b[0];
		#[allow(clippy::assign_op_pattern)]
		for i in 1..n {
			b[i] += c[i - 1];
			// for some reason the below line makes the borrow checker mad
			//d[i] += d[i-1]
			d[i] = d[i] + d[i - 1];
			c[i] /= -b[i];
			d[i] /= -b[i];
		}

		// at this point b[i] == -a[i + 1], a[i] == 0,
		// do row operations to eliminate 'c' coefficients and solve
		d[n - 1] *= -1.0;
		#[allow(clippy::assign_op_pattern)]
		for i in (0..n - 1).rev() {
			d[i] = d[i] - (c[i] * d[i + 1]);
			d[i] *= -1.0; //d[i] /= b[i]
		}

		// given the second point in the n'th cubic bezier, the third point is given by 2 * points[n+1] - b[n+1].
		// to find 'handle1_pos' for the n'th point we need the n-1 cubic bezier
		new.0.push_end(ManipulatorGroup::new_with_handles(points[0], None, Some(d[0])));
		for i in 1..n - 1 {
			new.0.push_end(ManipulatorGroup::new_with_handles(points[i], Some(2.0 * points[i] - d[i]), Some(d[i])));
		}
		new.0.push_end(ManipulatorGroup::new_with_handles(points[n - 1], Some(2.0 * points[n - 1] - d[n - 1]), None));

		new
	}

	/// Move the selected points by the delta vector
	pub fn move_selected(&mut self, delta: DVec2) {
		self.selected_manipulator_groups_any_points_mut()
			.for_each(|manipulator_group| manipulator_group.move_selected_points(delta));
	}

	/// Delete the selected points from the [Subpath]
	pub fn delete_selected(&mut self) {
		let mut ids_to_delete: Vec<u64> = vec![];
		for (id, manipulator_group) in self.manipulator_groups_mut().enumerate_mut() {
			if manipulator_group.is_anchor_selected() {
				ids_to_delete.push(*id);
			} else {
				manipulator_group.delete_selected();
			}
		}

		for id in ids_to_delete {
			self.manipulator_groups_mut().remove(id);
		}
	}

	// Apply a transformation to all of the Subpath points
	pub fn apply_affine(&mut self, affine: DAffine2) {
		for manipulator_group in self.manipulator_groups_mut().iter_mut() {
			manipulator_group.transform(&affine);
		}
	}

	// ** SELECTION OF POINTS **

	/// Set a single point to a chosen selection state by providing `(manipulator group ID, manipulator type)`.
	pub fn select_point(&mut self, point: (u64, ManipulatorType), selected: bool) -> Option<&mut ManipulatorGroup> {
		let (manipulator_group_id, point_id) = point;
		if let Some(manipulator_group) = self.manipulator_groups_mut().by_id_mut(manipulator_group_id) {
			manipulator_group.select_point(point_id as usize, selected);

			Some(manipulator_group)
		} else {
			None
		}
	}

	/// Set points in the [Subpath] to a chosen selection state, given by `(manipulator group ID, manipulator type)`.
	pub fn select_points(&mut self, points: &[(u64, ManipulatorType)], selected: bool) {
		points.iter().for_each(|point| {
			self.select_point(*point, selected);
		});
	}

	/// Select all the anchors in this shape
	pub fn select_all_anchors(&mut self) {
		for manipulator_group in self.manipulator_groups_mut().iter_mut() {
			manipulator_group.select_point(ManipulatorType::Anchor as usize, true);
		}
	}

	/// Select an anchor by index
	pub fn select_anchor_by_index(&mut self, manipulator_group_index: usize) -> Option<&mut ManipulatorGroup> {
		if let Some(manipulator_group) = self.manipulator_groups_mut().by_index_mut(manipulator_group_index) {
			manipulator_group.select_point(ManipulatorType::Anchor as usize, true);

			Some(manipulator_group)
		} else {
			None
		}
	}

	/// The last anchor in the shape
	pub fn select_last_anchor(&mut self) -> Option<&mut ManipulatorGroup> {
		if let Some(manipulator_group) = self.manipulator_groups_mut().last_mut() {
			manipulator_group.select_point(ManipulatorType::Anchor as usize, true);

			Some(manipulator_group)
		} else {
			None
		}
	}

	/// Clear all the selected manipulator groups, i.e., clear the selected points inside the manipulator groups
	pub fn clear_selected_manipulator_groups(&mut self) {
		for manipulator_group in self.manipulator_groups_mut().iter_mut() {
			manipulator_group.clear_selected_points();
		}
	}

	// ** ACCESSING MANIPULATORGROUPS **

	/// Return all the selected anchors, reference
	pub fn selected_manipulator_groups(&self) -> impl Iterator<Item = &ManipulatorGroup> {
		self.manipulator_groups().iter().filter(|manipulator_group| manipulator_group.is_anchor_selected())
	}

	/// Return all the selected anchors, mutable
	pub fn selected_manipulator_groups_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorGroup> {
		self.manipulator_groups_mut().iter_mut().filter(|manipulator_group| manipulator_group.is_anchor_selected())
	}

	/// Return all the selected [ManipulatorPoint]s by reference
	pub fn selected_manipulator_groups_any_points(&self) -> impl Iterator<Item = &ManipulatorGroup> {
		self.manipulator_groups().iter().filter(|manipulator_group| manipulator_group.any_points_selected())
	}

	/// Return all the selected [ManipulatorPoint]s by mutable reference
	pub fn selected_manipulator_groups_any_points_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorGroup> {
		self.manipulator_groups_mut().iter_mut().filter(|manipulator_group| manipulator_group.any_points_selected())
	}

	/// An alias for `self.0`
	pub fn manipulator_groups(&self) -> &IdBackedVec<ManipulatorGroup> {
		&self.0
	}

	/// Returns a [ManipulatorPoint] from the last [ManipulatorGroup] in the [Subpath].
	pub fn last_point(&self, control_type: ManipulatorType) -> Option<&ManipulatorPoint> {
		self.manipulator_groups().last().and_then(|manipulator_group| manipulator_group.points[control_type].as_ref())
	}

	/// Returns a [ManipulatorPoint] from the last [ManipulatorGroup], mutably
	pub fn last_point_mut(&mut self, control_type: ManipulatorType) -> Option<&mut ManipulatorPoint> {
		self.manipulator_groups_mut().last_mut().and_then(|manipulator_group| manipulator_group.points[control_type].as_mut())
	}

	/// Returns a [ManipulatorPoint]  from the first [ManipulatorGroup]
	pub fn first_point(&self, control_type: ManipulatorType) -> Option<&ManipulatorPoint> {
		self.manipulator_groups().first().and_then(|manipulator_group| manipulator_group.points[control_type].as_ref())
	}

	/// Returns a [ManipulatorPoint] from the first [ManipulatorGroup]
	pub fn first_point_mut(&mut self, control_type: ManipulatorType) -> Option<&mut ManipulatorPoint> {
		self.manipulator_groups_mut().first_mut().and_then(|manipulator_group| manipulator_group.points[control_type].as_mut())
	}

	/// Should we close the shape?
	pub fn should_close_shape(&self) -> bool {
		if self.last_point(ManipulatorType::Anchor).is_none() {
			return false;
		}

		self.first_point(ManipulatorType::Anchor)
			.unwrap()
			.position
			.distance(self.last_point(ManipulatorType::Anchor).unwrap().position)
			< 0.001 // TODO Replace with constant, a small epsilon
	}

	/// Close the shape if able
	pub fn close_shape(&mut self) {
		if self.should_close_shape() {
			self.manipulator_groups_mut().push_end(ManipulatorGroup::closed());
		}
	}

	/// An alias for `self.0` mutable
	pub fn manipulator_groups_mut(&mut self) -> &mut IdBackedVec<ManipulatorGroup> {
		&mut self.0
	}

	/// Return the bounding box of the shape.
	pub fn bounding_box(&self) -> Option<[DVec2; 2]> {
		self.bezier_iter()
			.map(|bezier| bezier.internal.bounding_box())
			.reduce(|[a_min, a_max], [b_min, b_max]| [a_min.min(b_min), a_max.max(b_max)])
	}

	/// Generate an SVG `path` elements's `d` attribute: `<path d="...">`.
	pub fn to_svg(&mut self) -> String {
		fn write_positions(result: &mut String, values: [Option<DVec2>; 3]) {
			use core::fmt::Write;
			let count = values.into_iter().flatten().count();
			for (index, pos) in values.into_iter().flatten().enumerate() {
				write!(result, "{},{}", pos.x, pos.y).unwrap();
				if index != count - 1 {
					result.push(' ');
				}
			}
		}

		let mut result = String::new();
		// The out position from the previous ManipulatorGroup
		let mut last_out_handle = None;
		// The values from the last moveto (for closing the path)
		let (mut first_in_handle, mut first_in_anchor) = (None, None);
		// Should the next element be a moveto?
		let mut start_new_contour = true;
		for manipulator_group in self.manipulator_groups().iter() {
			let in_handle = manipulator_group.points[ManipulatorType::InHandle].as_ref().map(|point| point.position);
			let anchor = manipulator_group.points[ManipulatorType::Anchor].as_ref().map(|point| point.position);
			let out_handle = manipulator_group.points[ManipulatorType::OutHandle].as_ref().map(|point| point.position);

			let command = match (last_out_handle.is_some(), in_handle.is_some(), anchor.is_some()) {
				(_, _, true) if start_new_contour => 'M',
				(true, false, true) | (false, true, true) => 'Q',
				(true, true, true) => 'C',
				(false, false, true) => 'L',
				(_, false, false) => 'Z',
				_ => panic!("Invalid shape {:#?}", self),
			};

			// Complete the last curve
			if command == 'Z' {
				if last_out_handle.is_some() && first_in_handle.is_some() {
					result.push('C');
					write_positions(&mut result, [last_out_handle, first_in_handle, first_in_anchor]);
				} else if last_out_handle.is_some() || first_in_handle.is_some() {
					result.push('Q');
					write_positions(&mut result, [last_out_handle, first_in_handle, first_in_anchor]);
				}
				result.push('Z');
			}
			// Update the last moveto position
			else if command == 'M' {
				(first_in_handle, first_in_anchor) = (in_handle, anchor);
				result.push(command);
				write_positions(&mut result, [None, None, anchor]);
			}
			// Write other path commands (line to/quadratic to/cubic to)
			else {
				result.push(command);
				write_positions(&mut result, [last_out_handle, in_handle, anchor]);
			}

			start_new_contour = command == 'Z';
			last_out_handle = out_handle;
		}
		result
	}

	/// Convert to an iter over [`bezier_rs::Bezier`] segments.
	pub fn bezier_iter(&self) -> PathIter {
		PathIter {
			path: self.manipulator_groups().enumerate(),
			last_anchor: None,
			last_out_handle: None,
			last_id: None,
			first_in_handle: None,
			first_anchor: None,
			first_id: None,
			start_new_contour: true,
		}
	}
}

/// A wrapper around [`bezier_rs::Bezier`] containing also the IDs for the [`ManipulatorGroup`]s where the points are from.
pub struct BezierId {
	/// The internal [`bezier_rs::Bezier`].
	pub internal: bezier_rs::Bezier,
	/// The ID of the [ManipulatorGroup] of the start point and, if cubic, the start handle.
	pub start: u64,
	/// The ID of the [ManipulatorGroup] of the end point and, if cubic, the end handle.
	pub end: u64,
	/// The ID of the [ManipulatorGroup] of the handle on a quadratic (if applicable).
	pub mid: Option<u64>,
}

impl BezierId {
	/// Construct a `BezierId` by encapsulating a [`bezier_rs::Bezier`] and providing the IDs of the [`ManipulatorGroup`]s the constituent points belong to.
	fn new(internal: bezier_rs::Bezier, start: u64, end: u64, mid: Option<u64>) -> Self {
		Self { internal, start, end, mid }
	}
}

/// An iterator over [`bezier_rs::Bezier`] segments constructable via [`Subpath::bezier_iter`].
pub struct PathIter<'a> {
	path: core::iter::Zip<core::slice::Iter<'a, u64>, core::slice::Iter<'a, ManipulatorGroup>>,

	last_anchor: Option<DVec2>,
	last_out_handle: Option<DVec2>,
	last_id: Option<u64>,

	first_in_handle: Option<DVec2>,
	first_anchor: Option<DVec2>,
	first_id: Option<u64>,

	start_new_contour: bool,
}

impl<'a> Iterator for PathIter<'a> {
	type Item = BezierId;

	fn next(&mut self) -> Option<Self::Item> {
		use bezier_rs::Bezier;

		let mut result = None;

		while result.is_none() {
			let (&id, manipulator_group) = self.path.next()?;

			let in_handle = manipulator_group.points[ManipulatorType::InHandle].as_ref().map(|point| point.position);
			let anchor = manipulator_group.points[ManipulatorType::Anchor].as_ref().map(|point| point.position);
			let out_handle = manipulator_group.points[ManipulatorType::OutHandle].as_ref().map(|point| point.position);

			let mut start_new_contour = false;

			// Move to
			if anchor.is_some() && self.start_new_contour {
				// Update the last moveto position
				(self.first_in_handle, self.first_anchor) = (in_handle, anchor);
				self.first_id = Some(id);
			}
			// Cubic to
			else if let (Some(p1), Some(p2), Some(p3), Some(p4), Some(last_id)) = (self.last_anchor, self.last_out_handle, in_handle, anchor, self.last_id) {
				result = Some(BezierId::new(Bezier::from_cubic_dvec2(p1, p2, p3, p4), last_id, id, None));
			}
			// Quadratic to
			else if let (Some(p1), Some(p2), Some(p3), Some(last_id)) = (self.last_anchor, self.last_out_handle.or(in_handle), anchor, self.last_id) {
				let mid = if self.last_out_handle.is_some() { last_id } else { id };
				result = Some(BezierId::new(Bezier::from_quadratic_dvec2(p1, p2, p3), last_id, id, Some(mid)));
			}
			// Line to
			else if let (Some(p1), Some(p2), Some(last_id)) = (self.last_anchor, anchor, self.last_id) {
				result = Some(BezierId::new(Bezier::from_linear_dvec2(p1, p2), last_id, id, None));
			}
			// Close path
			else if in_handle.is_none() && anchor.is_none() {
				start_new_contour = true;
				if let (Some(last_id), Some(first_id)) = (self.last_id, self.first_id) {
					// Complete the last curve
					if let (Some(p1), Some(p2), Some(p3), Some(p4)) = (self.last_anchor, self.last_out_handle, self.first_in_handle, self.first_anchor) {
						result = Some(BezierId::new(Bezier::from_cubic_dvec2(p1, p2, p3, p4), last_id, first_id, None));
					} else if let (Some(p1), Some(p2), Some(p3)) = (self.last_anchor, self.last_out_handle.or(self.first_in_handle), self.first_anchor) {
						let mid = if self.last_out_handle.is_some() { last_id } else { first_id };
						result = Some(BezierId::new(Bezier::from_quadratic_dvec2(p1, p2, p3), last_id, first_id, Some(mid)));
					} else if let (Some(p1), Some(p2)) = (self.last_anchor, self.first_anchor) {
						result = Some(BezierId::new(Bezier::from_linear_dvec2(p1, p2), last_id, first_id, None));
					}
				}
			}

			self.start_new_contour = start_new_contour;
			self.last_out_handle = out_handle;
			self.last_anchor = anchor;
			self.last_id = Some(id);
		}
		result
	}
}

impl From<&Subpath> for BezPath {
	/// Create a [BezPath] from a [Subpath].
	fn from(subpath: &Subpath) -> Self {
		// Take manipulator groups and create path elements: line, quad or curve, or a close indicator
		let manipulator_groups_to_path_el = |first: &ManipulatorGroup, second: &ManipulatorGroup| -> (PathEl, bool) {
			match [
				&first.points[ManipulatorType::OutHandle],
				&second.points[ManipulatorType::InHandle],
				&second.points[ManipulatorType::Anchor],
			] {
				[None, None, Some(anchor)] => (PathEl::LineTo(point_to_kurbo(anchor)), false),
				[None, Some(in_handle), Some(anchor)] => (PathEl::QuadTo(point_to_kurbo(in_handle), point_to_kurbo(anchor)), false),
				[Some(out_handle), None, Some(anchor)] => (PathEl::QuadTo(point_to_kurbo(out_handle), point_to_kurbo(anchor)), false),
				[Some(out_handle), Some(in_handle), Some(anchor)] => (PathEl::CurveTo(point_to_kurbo(out_handle), point_to_kurbo(in_handle), point_to_kurbo(anchor)), false),
				[Some(out_handle), None, None] => {
					if let Some(first_anchor) = subpath.manipulator_groups().first() {
						(
							if let Some(in_handle) = &first_anchor.points[ManipulatorType::InHandle] {
								PathEl::CurveTo(
									point_to_kurbo(out_handle),
									point_to_kurbo(in_handle),
									point_to_kurbo(first_anchor.points[ManipulatorType::Anchor].as_ref().unwrap()),
								)
							} else {
								PathEl::QuadTo(point_to_kurbo(out_handle), point_to_kurbo(first_anchor.points[ManipulatorType::Anchor].as_ref().unwrap()))
							},
							true,
						)
					} else {
						(PathEl::ClosePath, true)
					}
				}
				[None, None, None] => (PathEl::ClosePath, true),
				_ => panic!("Invalid path element {:#?}", subpath),
			}
		};

		if subpath.manipulator_groups().is_empty() {
			return BezPath::new();
		}

		let mut bez_path = vec![];
		let mut start_new_shape = true;

		for elements in subpath.manipulator_groups().windows(2) {
			let first = &elements[0];
			let second = &elements[1];

			// Tell kurbo cursor to move to the first anchor
			if start_new_shape {
				if let Some(anchor) = &first.points[ManipulatorType::Anchor] {
					bez_path.push(PathEl::MoveTo(point_to_kurbo(anchor)));
				}
			}

			// Create a path element from our first and second manipulator groups in the window
			let (path_el, should_start_new_shape) = manipulator_groups_to_path_el(first, second);
			start_new_shape = should_start_new_shape;
			bez_path.push(path_el);
			if should_start_new_shape && bez_path.last().filter(|&&el| el == PathEl::ClosePath).is_none() {
				bez_path.push(PathEl::ClosePath)
			}
		}

		BezPath::from_vec(bez_path)
	}
}

impl<T: Iterator<Item = PathEl>> From<T> for Subpath {
	/// Create a Subpath from a [BezPath].
	fn from(path: T) -> Self {
		let mut subpath = Subpath::new();
		let mut closed = false;
		for path_el in path {
			if closed {
				warn!("Verbs appear after the close path in a subpath. This will probably cause crashes.");
			}
			match path_el {
				PathEl::MoveTo(p) => {
					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p)));
					if !subpath.0.is_empty() {
						warn!("A move to path element appears part way through a subpath. This will be treated as a line to verb.");
					}
				}
				PathEl::LineTo(p) => {
					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p)));
				}
				PathEl::QuadTo(p0, p1) => {
					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p1)));
					subpath.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::InHandle] = Some(ManipulatorPoint::new(kurbo_point_to_dvec2(p0), ManipulatorType::InHandle));
				}
				PathEl::CurveTo(p0, p1, p2) => {
					subpath.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::OutHandle] = Some(ManipulatorPoint::new(kurbo_point_to_dvec2(p0), ManipulatorType::OutHandle));
					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p2)));
					subpath.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::InHandle] = Some(ManipulatorPoint::new(kurbo_point_to_dvec2(p1), ManipulatorType::InHandle));
				}
				PathEl::ClosePath => {
					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::closed());
					closed = true;
				}
			}
		}

		subpath
	}
}

#[inline]
fn point_to_kurbo(point: &ManipulatorPoint) -> kurbo::Point {
	kurbo::Point::new(point.position.x, point.position.y)
}

#[inline]
fn kurbo_point_to_dvec2(point: kurbo::Point) -> DVec2 {
	DVec2::new(point.x, point.y)
}