#ifndef TAXONOMY_H
#define TAXONOMY_H

#include "../ifcparse/IfcBaseClass.h"
#include "../ifcparse/IfcLogger.h"

#include "ConversionSettings.h"

#include <boost/variant.hpp>
#include <boost/functional/hash.hpp>

#include <Eigen/Dense>

#include <map>
#include <string>
#include <tuple>
#include <exception>
#include <numeric>

#ifndef TAXONOMY_USE_UNIQUE_PTR
#ifndef TAXONOMY_USE_NAKED_PTR
#define TAXONOMY_USE_SHARED_PTR
#endif
#endif

#ifdef TAXONOMY_USE_SHARED_PTR
#include <memory>
#endif

// @todo don't do std::less but use hashing and cache hash values.

namespace ifcopenshell {

	namespace geometry {

		namespace taxonomy {

#ifdef TAXONOMY_USE_SHARED_PTR
			template <typename T>
			T clone(T& t) {
				return t;
			}
			template <typename T, typename U>
			std::shared_ptr<T> cast(const std::shared_ptr<U>& u);
			template <typename T, typename U>
			std::shared_ptr<T> dcast(const std::shared_ptr<U>& u);
#endif
#ifdef TAXONOMY_USE_UNIQUE_PTR
			// untested currently
			template <typename T>
			T clone(T& t) {
				return t->clone_();
			}
			template <typename T, typename U>
			T* cast(const std::unique_ptr<U>& u);
			template <typename T, typename U>
			T* dcast(const std::unique_ptr<U>& u);
#endif
#ifdef TAXONOMY_USE_NAKED_PTR
			// untested currently
			template <typename T>
			T clone(T& t) {
				return t->clone_();
			}
			template <typename T, typename U>
			T* cast(const U*& u);
			template <typename T, typename U>
			T* dcast(const U*& u);
#endif

#ifdef TAXONOMY_USE_SHARED_PTR
#define DECLARE_PTR(item) \
typedef std::shared_ptr<item> ptr; \
typedef std::shared_ptr<const item> const_ptr;
#endif
#ifdef TAXONOMY_USE_UNIQUE_PTR
#define DECLARE_PTR(item) \
typedef std::uniqe_ptr<item> ptr; \
typedef std::uniqe_ptr<const item> ptr;
#endif
#ifdef TAXONOMY_USE_NAKED_PTR
#define DECLARE_PTR(item) \
typedef item* ptr; \
typedef item const* ptr;
#endif

			class topology_error : public std::runtime_error {
			public:
				topology_error() : std::runtime_error("Generic topology error") {}
				topology_error(const char* const s) : std::runtime_error(s) {}
			};

			enum kinds { MATRIX4, POINT3, DIRECTION3, LINE, CIRCLE, ELLIPSE, BSPLINE_CURVE, OFFSET_CURVE, PLANE, CYLINDER, BSPLINE_SURFACE, EDGE, LOOP, FACE, SHELL, SOLID, LOFT, EXTRUSION, REVOLVE, SURFACE_CURVE_SWEEP, NODE, COLLECTION, BOOLEAN_RESULT, PIECEWISE_FUNCTION, COLOUR, STYLE };

			const std::string& kind_to_string(kinds k);

			struct item {
			private:
				uint32_t identity_;
				static std::atomic_uint32_t counter_;
				mutable size_t computed_hash_;
			public:
				DECLARE_PTR(item)

				const IfcUtil::IfcBaseInterface* instance;

				boost::optional<bool> orientation;

				virtual item* clone_() const = 0;
				virtual kinds kind() const = 0;
				virtual void print(std::ostream&, int indent = 0) const = 0;
				virtual void reverse() { throw taxonomy::topology_error(); }
				virtual size_t calc_hash() const = 0;
				virtual size_t hash() const {
					if (computed_hash_) {
						return computed_hash_;
					}
					computed_hash_ = calc_hash();
					if (computed_hash_ == 0) {
						computed_hash_++;
					}
					return computed_hash_;
				}

				item(const IfcUtil::IfcBaseInterface* instance = nullptr) : identity_(counter_++), computed_hash_(0), instance(instance) {}

				virtual ~item() {}

				uint32_t identity() const { return identity_; }
			};

			struct implicit_item : public item {
				DECLARE_PTR(implicit_item)
				using item::item;

				virtual item::ptr evaluate() const = 0;
			};

			struct piecewise_function : public implicit_item {
				DECLARE_PTR(piecewise_function)

				piecewise_function(const IfcUtil::IfcBaseInterface* instance = nullptr) : implicit_item(instance){};
				piecewise_function(ifcopenshell::geometry::Settings* settings) : settings_(settings){};
            piecewise_function(piecewise_function&&) = default;
            piecewise_function(const piecewise_function&) = default;

				ifcopenshell::geometry::Settings* settings_ = nullptr;

				// length of span, function to evaluate span
				std::vector<std::pair<double, std::function<Eigen::Matrix4d(double u)>>> spans;

				double length() const {
                    return std::accumulate(spans.begin(), spans.end(), 0.0, [](const auto& v,const auto& s) { return v + s.first; });
                }

				void print(std::ostream& o, int = 0) const {
					o << "piecewise_function" << std::endl;
				}

				virtual piecewise_function* clone_() const { return new piecewise_function(*this); }
				virtual kinds kind() const { return PIECEWISE_FUNCTION; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(PIECEWISE_FUNCTION), 0);
					return boost::hash<decltype(v)>{}(v);
				}

				virtual item::ptr evaluate() const;
            item::ptr evaluate(double ustart, double uend,unsigned nsteps) const;

				Eigen::Matrix4d evaluate(double u) const;
			};

#ifdef TAXONOMY_USE_SHARED_PTR
			typedef std::shared_ptr<item> ptr;
			typedef std::shared_ptr<const item> const_ptr;
			template<typename T, typename... Args>
			std::shared_ptr<T> make(Args&&... args) {
				return std::make_shared<T>(std::forward<Args>(args)...);
			}
#endif
#ifdef TAXONOMY_USE_UNIQUE_PTR
			typedef std::uniqe_ptr<item> ptr;
			typedef std::uniqe_ptr<const item> ptr;
			template<typename T, typename... Args>
			std::uniqe_ptr<T> make(Args&&... args) {
				return new T(std::forward<Args>(args)...));
			}
#endif
#ifdef TAXONOMY_USE_NAKED_PTR
			typedef item* ptr;
			typedef item const* ptr;
			template<typename T, typename... Args>
			T* make(Args&&... args) {
				return new T(std::forward<Args>(args)...));
			}
#endif

			bool less(item::const_ptr, item::const_ptr);

			struct less_functor {
				bool operator()(item::const_ptr a, item::const_ptr b) const {
					return less(a, b);
				}
			};

			namespace {

				template <typename T>
				const T& eigen_defaults();

				template <>
				const Eigen::Vector3d& eigen_defaults<Eigen::Vector3d>() {
					static Eigen::Vector3d identity = Eigen::Vector3d::Zero();
					return identity;
				}

				template <>
				const Eigen::Matrix4d& eigen_defaults<Eigen::Matrix4d>() {
					static Eigen::Matrix4d identity = Eigen::Matrix4d::Identity();
					return identity;
				}

			}

			template <typename T>
			struct eigen_base {
				T* components_;

				eigen_base() {
					components_ = nullptr;
				}

				eigen_base(const eigen_base& other) {
					this->components_ = other.components_ ? new T(*other.components_) : nullptr;
				}

				eigen_base(const T& other) {
					this->components_ = new T(other);
				}

				eigen_base& operator=(const eigen_base& other) {
					if (this != &other) {
						this->components_ = other.components_ ? new T(*other.components_) : nullptr;
					}
					return *this;
				}

				void print_impl(std::ostream& o, const std::string& class_name, int indent = 0) const {
					o << std::string(indent, ' ') << class_name;
					if (this->components_) {
						int n = T::RowsAtCompileTime * T::ColsAtCompileTime;
						for (int i = 0; i < n; ++i) {
							o << " " << (*components_)(i);
						}
					}
					o << std::endl;
				}

				virtual ~eigen_base() {
					delete this->components_;
				}

				const T& ccomponents() const {
					if (this->components_) {
						return *this->components_;
					}
					else {
						return eigen_defaults<T>();
					}
				}

				T& components() {
					if (!this->components_) {
						this->components_ = new T(eigen_defaults<T>());
					}
					return *this->components_;
				}

				explicit operator bool() const {
					return components_;
				}

				uint32_t hash_components() const {
					size_t h = std::hash<size_t>{}(T::RowsAtCompileTime);
					boost::hash_combine(h, std::hash<size_t>{}(T::ColsAtCompileTime));
					if (components_) {
						for (int i = 0; i < components_->size(); ++i) {
							auto elem = *(components_->data() + (size_t) i);
							boost::hash_combine(h, std::hash<typename T::Scalar>()(elem));
						}
					}
					return (uint32_t) h;
				}
			};

			struct matrix4 : public item, public eigen_base<Eigen::Matrix4d> {
			private:
				void init(const Eigen::Vector3d& o, const Eigen::Vector3d& z, const Eigen::Vector3d& x) {
					auto X = x.normalized();
					auto Y = z.cross(x).normalized();
					auto Z = z.normalized();
					components_ = new Eigen::Matrix4d;
					(*components_) <<
						X(0), Y(0), Z(0), o(0),
						X(1), Y(1), Z(1), o(1),
						X(2), Y(2), Z(2), o(2),
						0, 0, 0, 1.;
					if (is_identity()) {
						// @todo detect this earlier to save us the heapalloc.
						delete components_;
						components_ = nullptr;
						tag = IDENTITY;
					}
				}
			public:
				DECLARE_PTR(matrix4)

				enum tag_t {
					IDENTITY, AFFINE_WO_SCALE, AFFINE_W_UNIFORM_SCALE, AFFINE_W_NONUNIFORM_SCALE, OTHER
				};
				tag_t tag;

				matrix4() : eigen_base(), tag(IDENTITY) {}
				matrix4(const Eigen::Matrix4d& c) : eigen_base(c), tag(OTHER) {}
				matrix4(const Eigen::Vector3d& o, const Eigen::Vector3d& z, const Eigen::Vector3d& x) : tag(AFFINE_WO_SCALE) {
					init(o, z, x);
				}
				matrix4(const Eigen::Vector3d& o, const Eigen::Vector3d& z) : tag(AFFINE_WO_SCALE) {
					auto x = Eigen::Vector3d(1, 0, 0);
					auto y = z.cross(x);
					if (y.squaredNorm() < 1.e-7) {
						x = Eigen::Vector3d(0, 0, 1);
					}
					init(o, z, x);
				}

				bool is_identity() const {
					return !components_ || components_->isIdentity();
				}

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "matrix4", indent);
				}

				virtual matrix4* clone_() const { return new matrix4(*this); }
				virtual kinds kind() const { return MATRIX4; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(MATRIX4), hash_components());
					return boost::hash<decltype(v)>{}(v);
				}

				Eigen::Vector3d translation_part() const { return ccomponents().col(3).head<3>(); }
			};

			struct colour : public item, public eigen_base<Eigen::Vector3d> {
				DECLARE_PTR(colour)

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "colour", indent);
				}

				virtual colour* clone_() const { return new colour(*this); }
				virtual kinds kind() const { return COLOUR; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(COLOUR), hash_components());
					return boost::hash<decltype(v)>{}(v);
				}

				colour() : eigen_base() {}
				colour(double r, double g, double b) { components() << r, g, b; }

				const double& r() const { return ccomponents()[0]; }
				const double& g() const { return ccomponents()[1]; }
				const double& b() const { return ccomponents()[2]; }
			};

			struct style : public item {
				DECLARE_PTR(style)

				std::string name;
				colour diffuse;
				colour specular;
				double specularity, transparency;

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "style" << std::endl;
					o << std::string(indent, ' ') << "     " << "name" << (name) << std::endl;
					if (diffuse.components_) {
						o << std::string(indent, ' ') << "     " << "diffuse" << (name) << std::endl;
						diffuse.print(o, indent + 5 + 7);
					}
					if (specular.components_) {
						o << std::string(indent, ' ') << "     " << "specular" << (name) << std::endl;
						specular.print(o, indent + 5 + 8);
					}
					// @todo
				}

				virtual style* clone_() const { return new style(*this); }
				virtual kinds kind() const { return STYLE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(STYLE), name, diffuse.hash(), specular.hash(), specularity, transparency);
					return boost::hash<decltype(v)>{}(v);
				}

				// @todo equality implementation based on values?
				bool operator==(const style& other) const { return instance == other.instance; }

				style() : specularity(std::numeric_limits<double>::quiet_NaN()), transparency(std::numeric_limits<double>::quiet_NaN()) {}
				style(const std::string& name) : name(name), specularity(std::numeric_limits<double>::quiet_NaN()), transparency(std::numeric_limits<double>::quiet_NaN()) {}

				bool has_specularity() const {
					return !std::isnan(specularity);
				}

				bool has_transparency() const {
					return !std::isnan(transparency);
				}
			};

			struct geom_item : public item {
				DECLARE_PTR(geom_item)

				style::ptr surface_style;
				matrix4::ptr matrix;

				geom_item(const IfcUtil::IfcBaseClass* instance = nullptr) : item(instance), surface_style(nullptr) {}
				geom_item(const IfcUtil::IfcBaseClass* instance, matrix4::ptr m) : item(instance), surface_style(nullptr), matrix(m) {}
				geom_item(matrix4::ptr m) : surface_style(nullptr), matrix(m) {}
			};

			// @todo make 4d for easier multiplication
			template <size_t N>
			struct cartesian_base : public item, public eigen_base<Eigen::Vector3d> {
				cartesian_base() : eigen_base() {}
				cartesian_base(const Eigen::Vector3d& c) : eigen_base(c) {}
				cartesian_base(double x, double y, double z = 0.) : eigen_base(Eigen::Vector3d(x, y, z)) {}
			};

			struct point3 : public cartesian_base<3> {
				DECLARE_PTR(point3)

				virtual point3* clone_() const { return new point3(*this); }
				virtual kinds kind() const { return POINT3; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(POINT3), hash_components());
					return boost::hash<decltype(v)>{}(v);
				}

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "point3", indent);
				}

				point3() : cartesian_base() {}
				point3(const Eigen::Vector3d& c) : cartesian_base(c) {}
				point3(double x, double y, double z = 0.) : cartesian_base(x, y, z) {}
			};

			struct direction3 : public cartesian_base<3> {
				DECLARE_PTR(direction3)

				virtual direction3* clone_() const { return new direction3(*this); }
				virtual kinds kind() const { return DIRECTION3; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(DIRECTION3), hash_components());
					return boost::hash<decltype(v)>{}(v);
				}

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "direction3", indent);
				}

				direction3() : cartesian_base() {}
				direction3(const Eigen::Vector3d& c) : cartesian_base(c) {}
				direction3(double x, double y, double z = 0.) : cartesian_base(x, y, z) {}
			};

			struct curve : public geom_item {
				void print_impl(std::ostream& o, const std::string& classname, int indent = 0) const {
					o << std::string(indent, ' ') << classname << std::endl;
					this->matrix->print(o, indent + 4);
				}
			};

			struct line : public curve {
				DECLARE_PTR(line)

				virtual line* clone_() const { return new line(*this); }
				virtual kinds kind() const { return LINE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(LINE), matrix->hash_components());
					return boost::hash<decltype(v)>{}(v);
				}

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "line", indent);
				}
			};

			struct circle : public curve {
				DECLARE_PTR(circle)

				double radius;

				virtual circle* clone_() const { return new circle(*this); }
				virtual kinds kind() const { return CIRCLE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(CIRCLE), matrix->hash_components(), radius);
					return boost::hash<decltype(v)>{}(v);
				}

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "circle", indent);
				}

				static circle::ptr from_3_points(const Eigen::Vector3d& p1, const Eigen::Vector3d& p2, const Eigen::Vector3d& p3) {
					Eigen::Vector3d t = p2 - p1;
					Eigen::Vector3d u = p3 - p1;
					Eigen::Vector3d v = p3 - p2;

					auto norm = t.cross(u);
					auto mag = norm.dot(norm);

					auto iwsl2 = 1. / (2. * mag);
					auto tt = t.dot(t);
					auto uu = u.dot(u);

					auto orig = p1 + (u * tt * u.dot(v) - t * uu * t.dot(v)) * iwsl2;

					if (!orig.array().isNaN().any()) {
						auto radius = std::sqrt(tt * uu * v.dot(v) * iwsl2 * 0.5f);
						auto ax = norm / std::sqrt(mag);


						auto c = make<circle>();
						c->radius = radius;
						c->matrix = taxonomy::make<taxonomy::matrix4>(orig, ax);
						return c;
					}

					return nullptr;
				}
			};

			struct ellipse : public circle {
				DECLARE_PTR(ellipse)

				double radius2;

				virtual ellipse* clone_() const { return new ellipse(*this); }
				virtual kinds kind() const { return ELLIPSE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(ELLIPSE), matrix->hash_components(), radius, radius2);
					return boost::hash<decltype(v)>{}(v);
				}

				void print(std::ostream& o, int indent = 0) const {
					print_impl(o, "ellipse", indent);
				}
			};

			struct bspline_curve : public curve {
				DECLARE_PTR(bspline_curve)

				virtual bspline_curve* clone_() const { return new bspline_curve(*this); }
				virtual kinds kind() const { return BSPLINE_CURVE; }

				virtual size_t calc_hash() const {
					size_t h = std::hash<size_t>{}(BSPLINE_CURVE);
					for (auto& x : control_points) {
						boost::hash_combine(h, x->hash());
					}
					for (auto& x : multiplicities) {
						boost::hash_combine(h, std::hash<int>{}(x));
					}
					for (auto& x : knots) {
						boost::hash_combine(h, std::hash<double>{}(x));
					}
					if (weights) {
						for (auto& x : *weights) {
							boost::hash_combine(h, std::hash<double>{}(x));
						}
					}
					boost::hash_combine(h, std::hash<int>{}(degree));
					return h;
				}

				std::vector<point3::ptr> control_points;
				std::vector<int> multiplicities;
				std::vector<double> knots;
				boost::optional<std::vector<double>> weights;
				int degree;

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "bspline curve" << std::endl;
				}
			};

			struct offset_curve : public curve {
				DECLARE_PTR(offset_curve)

				direction3::ptr reference;
				double offset;
				item::ptr basis;

				virtual offset_curve* clone_() const { return new offset_curve(*this); }
				virtual kinds kind() const { return OFFSET_CURVE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(OFFSET_CURVE), reference->hash(), offset, basis ? basis->hash() : size_t(0));
					return boost::hash<decltype(v)>{}(v);
				}

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "offset_curve" << std::endl;
				}
			};

			struct trimmed_curve : public item {
				DECLARE_PTR(trimmed_curve)

				// @todo The copy constructor of point3 within the variant fails on the avx instruction
				// on the default gcc in Ubuntu 18.04 and a recent AMD Ryzen. Probably due to allignment.
				boost::variant<point3::ptr, double> start, end;

				// @todo somehow account for the fact that curve in IFC can be trimmed curve, polyline and composite curve as well.
				item::ptr basis;

				// @todo does this make sense? this is to accommodate for the fact that orientation is defined on both TrimmedCurve as well CompCurveSegment
				boost::optional<bool> orientation_2;

				trimmed_curve() : basis(nullptr), orientation_2(true) {}
				trimmed_curve(const point3::ptr& a, const point3::ptr& b) : start(a), end(b), basis(nullptr) {}

				virtual void reverse() {
					// std::swap(start, end);
					orientation = !orientation;
				}

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "trimmed_curve" << std::endl;
					if (basis) {
						basis->print(o, indent + 4);
					}

					const boost::variant<point3::ptr, double>* const start_end[2] = { &start, &end };
					for (int i = 0; i < 2; ++i) {
						o << std::string(indent + 4, ' ') << (i == 0 ? "start" : "end") << std::endl;
						if (start_end[i]->which() == 0) {
							boost::get<point3::ptr>(*start_end[i])->print(o, indent + 4);
						}
						else if (start_end[i]->which() == 1) {
							o << std::string(indent + 4, ' ') << "parameter " << boost::get<double>(*start_end[i]) << std::endl;
						}
					}

					if (this->instance) {
						o << std::string(indent, ' ') << this->instance->data().toString() << std::endl;
					}
				}
			};

			struct edge : public trimmed_curve {
				DECLARE_PTR(edge)

				edge() : trimmed_curve() {}
				edge(const point3::ptr& a, const point3::ptr& b) : trimmed_curve(a, b) {}

				// @todo how to express similarity between trimmed_curve and edge?
				virtual edge* clone_() const { return new edge(*this); }
				virtual kinds kind() const { return EDGE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(EDGE), start, end, basis ? basis->hash() : size_t(0), orientation_2 ? *orientation_2 ? 2 : 1 : 0);
					return boost::hash<decltype(v)>{}(v);
				}
			};

			template <typename T = item>
			struct collection_base : public geom_item {
				std::vector<typename T::ptr> children;

				collection_base() {}
				collection_base(const collection_base& other)
					: geom_item()
				{
					std::transform(other.children.begin(), other.children.end(), std::back_inserter(children), [](typename T::ptr p) { return clone(p); });
				}

				/*
				template <typename T>
				std::vector<typename T::ptr> children_as() const {
					std::vector<typename T::ptr> ts;
					ts.reserve(children.size());
					std::for_each(children.begin(), children.end(), [&ts](ptr i){
						auto v = dcast<T>(i);
						if (v) {
							ts.push_back(v);
						}
					});
					return ts;
				}
				*/

				virtual void reverse() {
					// @todo this needs to create copies of the children in case of shared_ptr
					std::reverse(children.begin(), children.end());
					for (auto& child : children) {
						child->reverse();
					}
				}

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << kind_to_string(kind()) << std::endl;
					if (!matrix->is_identity()) {
						matrix->print(o, indent + 4);
					}
					for (auto& c : children) {
						c->print(o, indent + 4);
					}
				}

				virtual ~collection_base() {
#ifdef TAXONOMY_USE_NAKED_PTR
					for (auto& c : children) {
						delete c;
					}
#endif
				}

				uint32_t hash_elements() const {
					size_t h = 0;
					for (auto& c : children) {
						boost::hash_combine(h, c->hash());
					}
					// @todo should we really use uint32_t instead of size_t for hashes?
					return (uint32_t) h;
				}
			};

			struct collection : public collection_base<geom_item> {
				DECLARE_PTR(collection)

				virtual collection* clone_() const { return new collection(*this); }
				virtual kinds kind() const { return COLLECTION; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(COLLECTION), hash_elements());
					return boost::hash<decltype(v)>{}(v);
				}
			};


			struct loop : public collection_base<edge> {
				DECLARE_PTR(loop)

				boost::optional<bool> external, closed;
				boost::optional<taxonomy::piecewise_function::ptr> pwf;

				bool is_polyhedron() const {
					for (auto& e : children) {
						if (e->basis != nullptr) {
							if (e->basis->kind() != LINE) {
								return false;
							}
						}
					}
					return true;
				}

				virtual loop* clone_() const { return new loop(*this); }
				virtual kinds kind() const { return LOOP; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(LOOP), hash_elements(), external ? *external ? 2 : 1 : 0, closed ? *closed ? 2 : 1 : 0);
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct face : public collection_base<loop> {
				DECLARE_PTR(face)

				item::ptr basis;

				virtual face* clone_() const { return new face(*this); }
				virtual kinds kind() const { return FACE; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(FACE), hash_elements(), basis ? basis->hash() : size_t(0));
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct shell : public collection_base<face> {
				DECLARE_PTR(shell)

				boost::optional<bool> closed;

				virtual shell* clone_() const { return new shell(*this); }
				virtual kinds kind() const { return SHELL; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(SHELL), hash_elements(), closed ? *closed ? 2 : 1 : 0);
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct solid : public collection_base<shell> {
				DECLARE_PTR(solid)

				virtual solid* clone_() const { return new solid(*this); }
				virtual kinds kind() const { return SOLID; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(SOLID), hash_elements());
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct loft : public collection_base<face> {
				DECLARE_PTR(loft)

				item::ptr axis;

				virtual loft* clone_() const { return new loft(*this); }
				virtual kinds kind() const { return LOFT; }

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(LOFT), hash_elements(), axis ? axis->hash() : size_t(0));
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct surface : public geom_item {};

			struct plane : public surface {
				DECLARE_PTR(plane)

				virtual plane* clone_() const { return new plane(*this); }
				virtual kinds kind() const { return PLANE; }

				void print(std::ostream& o, int) const {
					o << "not implemented";
				}

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(PLANE), matrix->hash_components());
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct cylinder : public surface {
				DECLARE_PTR(cylinder)

				double radius;

				virtual cylinder* clone_() const { return new cylinder(*this); }
				virtual kinds kind() const { return CYLINDER; }

				void print(std::ostream& o, int) const {
					o << "not implemented";
				}
				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(CYLINDER), matrix->hash_components());
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct bspline_surface : public surface {
				DECLARE_PTR(bspline_surface)

				virtual bspline_surface* clone_() const { return new bspline_surface(*this); }
				virtual kinds kind() const { return BSPLINE_SURFACE; }

				virtual size_t calc_hash() const {
					size_t h = std::hash<size_t>{}(BSPLINE_SURFACE);
					boost::hash_combine(h, std::hash<size_t>{}(control_points.size()));
					for (auto& xs : control_points) {
						for (auto& x : xs) {
							boost::hash_combine(h, x->hash());
						}
					}
					for (auto& xs : multiplicities) {
						for (auto& x : xs) {
							boost::hash_combine(h, std::hash<int>{}(x));
						}
					}
					for (auto& xs : knots) {
						for (auto& x : xs) {
							boost::hash_combine(h, std::hash<double>{}(x));
						}
					}
					if (weights) {
						for (auto& xs : *weights) {
							for (auto& x : xs) {
								boost::hash_combine(h, std::hash<double>{}(x));
							}
						}
					}
					boost::hash_combine(h, std::hash<int>{}(degree[0]));
					boost::hash_combine(h, std::hash<int>{}(degree[1]));
					return h;
				}

				std::vector<std::vector<point3::ptr>> control_points;
				std::array<std::vector<int>, 2> multiplicities;
				std::array<std::vector<double>, 2> knots;
				boost::optional<std::vector<std::vector<double>>> weights;
				std::array<int, 2> degree;

				void print(std::ostream& o, int) const {
					o << "not implemented";
				}
			};

			struct sweep : public geom_item {
				DECLARE_PTR(sweep)

				face::ptr basis;

				sweep(face::ptr b) : basis(b) {}
				sweep(matrix4::ptr m, face::ptr b) : geom_item(m), basis(b) {}
			};

			struct extrusion : public sweep {
				DECLARE_PTR(extrusion)

				direction3::ptr direction;
				double depth;

				virtual extrusion* clone_() const { return new extrusion(*this); }
				virtual kinds kind() const { return EXTRUSION; }

				extrusion(matrix4::ptr m, face::ptr basis, direction3::ptr dir, double d) : sweep(m, basis), direction(dir), depth(d) {}

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "extrusion " << depth << std::endl;
					direction->print(o, indent + 4);
					basis->print(o, indent + 4);
				}

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(EXTRUSION), matrix->hash_components(), basis->calc_hash(), direction->hash_components(), depth);
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct revolve : public sweep {
				DECLARE_PTR(revolve)

				point3::ptr axis_origin;
				direction3::ptr direction;
				boost::optional<double> angle;

				virtual revolve* clone_() const { return new revolve(*this); }
				virtual kinds kind() const { return REVOLVE; }

				revolve(matrix4::ptr m, face::ptr basis, point3::ptr pnt, direction3::ptr dir, const boost::optional<double>& a) : sweep(m, basis), axis_origin(pnt), direction(dir), angle(a) {}

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "revolve" << std::endl;
				}

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(REVOLVE), matrix->hash_components(), basis->calc_hash(), axis_origin->hash_components(), direction->hash_components(), angle ? *angle : 1000.);
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct surface_curve_sweep : public sweep {
				DECLARE_PTR(surface_curve_sweep)

				item::ptr surface;
				item::ptr curve;

				virtual surface_curve_sweep* clone_() const { return new surface_curve_sweep(*this); }
				virtual kinds kind() const { return SURFACE_CURVE_SWEEP; }

				surface_curve_sweep(matrix4::ptr m, face::ptr basis, item::ptr surf, item::ptr crv) : sweep(m, basis), surface(surf), curve(crv) {}

				void print(std::ostream& o, int indent = 0) const {
					o << std::string(indent, ' ') << "surface_curve_sweep" << std::endl;
				}

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(SURFACE_CURVE_SWEEP), matrix->hash_components(), basis->calc_hash(), surface->calc_hash(), curve->calc_hash());
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct node : public item {
				DECLARE_PTR(node)

				// std::map<std::string, geom_item> representations;

				virtual node* clone_() const { return new node(*this); }
				virtual kinds kind() const { return NODE; }

				void print(std::ostream&, int = 0) const {}

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(NODE));
					return boost::hash<decltype(v)>{}(v);
				}
			};

			struct boolean_result : public collection_base<geom_item> {
				DECLARE_PTR(boolean_result)

				enum operation_t {
					UNION, SUBTRACTION, INTERSECTION
				};

				virtual boolean_result* clone_() const { return new boolean_result(*this); }
				virtual kinds kind() const { return BOOLEAN_RESULT; }
				operation_t operation;

				static const std::string& operation_str(operation_t op) {
					using namespace std::string_literals;
					static std::string s[] = { "union"s, "subtraction"s, "intersection"s };
					return s[(size_t)op];
				}

				virtual size_t calc_hash() const {
					auto v = std::make_tuple(static_cast<size_t>(BOOLEAN_RESULT), hash_elements(), static_cast<size_t>(operation));
					return boost::hash<decltype(v)>{}(v);
				}
			};

			namespace impl {
				typedef std::tuple<matrix4, point3, direction3, line, circle, ellipse, bspline_curve, offset_curve, plane, cylinder, bspline_surface, edge, loop, face, shell, solid, loft, extrusion, revolve, surface_curve_sweep, node, collection, boolean_result, piecewise_function> KindsTuple;
				typedef std::tuple<line, circle, ellipse, bspline_curve, offset_curve, loop, edge> CurvesTuple;
				typedef std::tuple<plane, cylinder, bspline_surface> SurfacesTuple;
			}

			struct type_by_kind {
				template <std::size_t N>
				using type = typename std::tuple_element<N, impl::KindsTuple>::type;

				static const size_t max = std::tuple_size<impl::KindsTuple>::value;
			};

			struct curves {
				template <std::size_t N>
				using type = typename std::tuple_element<N, impl::CurvesTuple>::type;

				static const size_t max = std::tuple_size<impl::CurvesTuple>::value;
			};

			struct surfaces {
				template <std::size_t N>
				using type = typename std::tuple_element<N, impl::SurfacesTuple>::type;

				static const size_t max = std::tuple_size<impl::SurfacesTuple>::value;
			};

			// Hacks around not wanting to use if constexpr
			template <typename T>
			class loop_to_face_upgrade {
			public:
				loop_to_face_upgrade(taxonomy::ptr) {}

				operator bool() const {
					return false;
				}

				operator taxonomy::face::ptr() const {
					throw taxonomy::topology_error();
				}

				operator typename T::ptr() const {
					throw taxonomy::topology_error();
				}
			};

			template <>
			class loop_to_face_upgrade<taxonomy::face> {
			private:
				boost::optional<taxonomy::face::ptr> face_;
			public:
				loop_to_face_upgrade(taxonomy::ptr item) {
					auto loop = taxonomy::dcast<taxonomy::loop>(item);
					if (loop) {
						loop->external = true;

						face_ = taxonomy::make<taxonomy::face>();
						(*face_)->instance = loop->instance;
						(*face_)->matrix = loop->matrix;
						(*face_)->children = { taxonomy::clone(loop) };
					}
				}

				operator bool() const {
					return face_.is_initialized();
				}

				operator taxonomy::face::ptr() const {
					return *face_;
				}
			};

			// Hacks around not wanting to use if constexpr
         template <typename T>
         class loop_to_piecewise_function_upgrade {
              public:
                loop_to_piecewise_function_upgrade(taxonomy::ptr) {}

                operator bool() const {
                    return false;
                }

                operator taxonomy::piecewise_function::ptr() const {
                    throw taxonomy::topology_error();
                }

                operator typename T::ptr() const {
                    throw taxonomy::topology_error();
                }
            };

            template <>
            class loop_to_piecewise_function_upgrade<taxonomy::piecewise_function> {
              private:
                boost::optional<taxonomy::piecewise_function::ptr> pwf_;

              public:
                loop_to_piecewise_function_upgrade(taxonomy::ptr item) {
                    auto loop = taxonomy::dcast<taxonomy::loop>(item);
                    if (loop) {
                        if (loop->pwf.is_initialized()) {
                            pwf_ = loop->pwf;
                        } else {
                            pwf_ = taxonomy::make<taxonomy::piecewise_function>();
                            for (auto& edge : loop->children) {
                                // the edge could be an arc or trimmed circle in the case of IfcIndexPolyCurve - support for this isn't implemented yet
                                if (edge->basis) {
                                    Logger::Message(Logger::Severity::LOG_NOTICE, "Shape of basis curve ignored - edge is treated as a straight line edge");
                                }

                                const auto& s = boost::get<taxonomy::point3::ptr>(edge->start)->ccomponents();
                                const auto& e = boost::get<taxonomy::point3::ptr>(edge->end)->ccomponents();
                                Eigen::Vector3d v = e - s;
                                auto l = v.norm(); // the norm of a vector is a measure of its length
                                v.normalize();     // normalize the vector so that it is a unit direction vector
                                std::function<Eigen::Matrix4d(double)> fn = [s, v](double u) {
                                    Eigen::Vector3d o(s + u * v), axis(0, 0, 1), refDirection(v);
                                    auto Y = axis.cross(refDirection).normalized();
                                    axis = refDirection.cross(Y).normalized();
                                    return taxonomy::make<taxonomy::matrix4>(o, axis, refDirection)->components();
                                };
                                (*pwf_)->spans.emplace_back(l, fn);
                            }
                            loop->pwf = pwf_;
                        }
                    }
                }

                operator bool() const {
                    return pwf_.is_initialized();
                }

                operator taxonomy::piecewise_function::ptr() const {
                    return *pwf_;
                }
            };

#ifdef TAXONOMY_USE_SHARED_PTR
			template <typename T, typename U>
			std::shared_ptr<T> cast(const std::shared_ptr<U>& u) {
				loop_to_face_upgrade<T> upg(u);
				if (upg) {
					return upg;
				}
            loop_to_piecewise_function_upgrade<T> pwupg(u);
            if (pwupg) {
               return pwupg;
            }
				return std::static_pointer_cast<T>(u);
			}
			template <typename T, typename U>
			std::shared_ptr<T> dcast(const std::shared_ptr<U>& u) {
				loop_to_face_upgrade<T> upg(u);
				if (upg) {
					return upg;
				}
            loop_to_piecewise_function_upgrade<T> pwupg(u);
            if (pwupg) {
               return pwupg;
            }
            return std::dynamic_pointer_cast<T>(u);
			}
#endif
#ifdef TAXONOMY_USE_UNIQUE_PTR
			template <typename T, typename U>
			T* cast(const std::unique_ptr<U>& u) {
				loop_to_face_upgrade<T> upg(u);
				if (upg) {
					return upg;
				}
            loop_to_piecewise_function_upgrade<T> pwupg(u);
            if (pwupg) {
               return pwupg;
            }
            return static_cast<T*>(&*u);
			}
			template <typename T, typename U>
			T* dcast(const std::unique_ptr<U>& u) {
				loop_to_face_upgrade<T> upg(u);
				if (upg) {
					return upg;
				}
            loop_to_piecewise_function_upgrade<T> pwupg(u);
            if (pwupg) {
               return pwupg;
            }
            return dynamic_cast<T*>(&*u);
			}
#endif
#ifdef TAXONOMY_USE_NAKED_PTR
			template <typename T, typename U>
			T* cast(const U*& u) {
				loop_to_face_upgrade<T> upg(u);
				if (upg) {
					return upg;
				}
            loop_to_piecewise_function_upgrade<T> pwupg(u);
            if (pwupg) {
               return pwupg;
            }
            return std::static_cast<T*>(u);
			}
			template <typename T, typename U>
			T* dcast(const U*& u) {
				loop_to_face_upgrade<T> upg(u);
				if (upg) {
					return upg;
				}
            loop_to_piecewise_function_upgrade<T> pwupg(u);
            if (pwupg) {
               return pwupg;
            }
            return std::dynamic_cast<T*>(u);
			}
#endif

		}

		template <typename U, typename Fn>
		void visit(const typename U::ptr& deep, Fn fn) {
			for (auto& i : deep->children) {
				// @todo Sad... now that we have templated collection members,
				// we can't generally use collection_base anymore as a cast target.
				if (auto s = taxonomy::dcast<taxonomy::collection>(i)) {
					visit<taxonomy::collection>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::loop>(i)) {
					visit<taxonomy::loop>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::face>(i)) {
					visit<taxonomy::face>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::shell>(i)) {
					visit<taxonomy::shell>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::solid>(i)) {
					visit<taxonomy::solid>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::loft>(i)) {
					visit<taxonomy::loft>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::boolean_result>(i)) {
					visit<taxonomy::boolean_result>(s, fn);
				}
				else {
					fn(i);
				}
			}
		}

		template <typename T, typename U, typename Fn>
		void visit_2(const typename U::ptr& c, const Fn& fn) {
			static_assert(std::is_same<T, taxonomy::point3>::value, "@todo Only implemented for point3");
			for (auto& i : c->children) {
				// @todo Sad... now that we have templated collection members,
				// we can't generally use collection_base anymore as a cast target.
				if (auto s = taxonomy::dcast<taxonomy::collection>(i)) {
					visit_2<T, taxonomy::collection>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::loop>(i)) {
					visit_2<T, taxonomy::loop>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::face>(i)) {
					visit_2<T, taxonomy::face>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::shell>(i)) {
					visit_2<T, taxonomy::shell>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::solid>(i)) {
					visit_2<T, taxonomy::solid>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::loft>(i)) {
					visit_2<T, taxonomy::loft>(s, fn);
				}
				else if (auto s = taxonomy::dcast<taxonomy::boolean_result>(i)) {
					visit_2<T, taxonomy::boolean_result>(s, fn);
				}
				else if (auto pt = taxonomy::dcast<taxonomy::point3>(i)) {
					fn(pt);
				}
				else if (auto l = taxonomy::dcast<taxonomy::edge>(i)) {
					// @todo maybe make edge a collection then as well?
					if (l->start.which() == 0) {
						fn(boost::get<taxonomy::point3::ptr>(l->start));
					}
					if (l->end.which() == 0) {
						fn(boost::get<taxonomy::point3::ptr>(l->end));
					}
				}
			}
		}

		taxonomy::collection::ptr flatten(const taxonomy::collection::ptr& deep);

		template <typename Fn>
		bool apply_predicate_to_collection(const taxonomy::ptr& i, Fn fn) {
			if (i->kind() == taxonomy::COLLECTION) {
				auto c = taxonomy::cast<taxonomy::collection>(i);
				for (auto& child : c->children) {
					if (apply_predicate_to_collection(child, fn)) {
						return true;
					}
				}
				return false;
			}
			else {
				return fn(i);
			}
		}

		// @nb traverses nested collections
		template <typename Fn>
		taxonomy::collection::ptr filter(const taxonomy::collection::ptr& collection, Fn fn) {
			auto filtered = taxonomy::make<taxonomy::collection>();
			for (auto& child : collection->children) {
				if (apply_predicate_to_collection(child, fn)) {
					filtered->children.push_back(clone(child));
				}
			}
			if (filtered->children.empty()) {
#ifdef TAXONOMY_USE_NAKED_PTR
				delete filtered;
#endif
				return nullptr;
			}
			return filtered;
		}

		// @nb traverses nested collections
		template <typename Fn>
		taxonomy::collection::ptr filter_in_place(taxonomy::collection::ptr collection, Fn fn) {
			auto& c = collection->children;
			auto new_end = std::remove_if(c.begin(), c.end(), [fn](taxonomy::geom_item::ptr i) {
				return !apply_predicate_to_collection(i, fn);
			});
#ifdef TAXONOMY_USE_NAKED_PTR
			for (auto it = new_end; it != c.end(); ++it) {
				delete *it;
			}
#endif
			c.erase(new_end, c.end());
			return collection;
		}

		taxonomy::solid::ptr create_box(double dx, double dy, double dz);
		taxonomy::solid::ptr create_box(double x, double y, double z, double dx, double dy, double dz);

		struct layerset_information {
			std::vector<double> thicknesses;
			std::vector<ifcopenshell::geometry::taxonomy::ptr> layers;
			std::vector<ifcopenshell::geometry::taxonomy::style> styles;
		};

		enum connection_type {
			ATPATH,
			ATSTART,
			ATEND,
			NOTDEFINED
		};

		typedef std::tuple<connection_type, connection_type, IfcUtil::IfcBaseEntity*> endpoint_connection;
	}

}

#endif