#pragma once

#include "sphpack.h"
#include "mars_geometry.h"
#include "mars_ptr.h"
#include "mars_splines.h"
#include "mars_util.h"

namespace geoworld
{
	template < typename T >
	class SpherePackFactory
	{
	public:
		typedef typename RandomSpherePack<T>::VECTOR VECTOR;
		typedef mars::ptr< RandomSpherePack <T> > PackPtr;

	private:
		const mars::RangeX <float> _sizeflux;
		const mars::RangeX <unsigned short> _kidflux, _viter;
		const T _minimum, _maxtier, _limit;
		const float _verratic, _fminimum, _fpihalf;

		class VeinGuide : public mars::BasicGuide <VECTOR, T>
		{
		private:
			inline VECTOR randomV (const T delta) const
			{
				using namespace mars;
				return vector3D <T> (
					RAND(delta) - delta / 2,
					RAND(delta) - delta / 2,
					RAND(delta) - delta / 2
				);
			}
			
		public:
			typedef mars::BasicGuide <VECTOR, T> super;

			inline VeinGuide (const typename super::Point & a, const typename super::Point & b)
				: super::BasicGuide(a, b) {}

			void subdivide (const float factor)
			{
				typename super::PointList::const_iterator itFollow, itLeading;

				itLeading = super::begin();
				itFollow = itLeading++;

				while (itLeading != super::end())
				{
					const VECTOR g = this->grad(itFollow);
					const VECTOR p2 = *itFollow + g / 2 + randomV(static_cast< T > (static_cast< float > (MAG(g)) * factor));

					super::_points.insert(itLeading, p2);

					itFollow = itLeading++;
				}
			}
		};

	public:
		inline SpherePackFactory (
			const T limit,		// Smallest-visible sphere radius before descendant generation ceases
			const T minimum,	// Absolute smallest sphere radius, any generated spheres with radii below this value are discarded
			const T maxtier,	// The maximum number depth-iterations (as opposed to breadth), this also affects the level of detail
			const mars::RangeX <float> & sizeflux,	// Flux of size of spheres at starting tier
			const mars::RangeX <unsigned short> & kidflux,	// Flux of number of breadth-iterations (as opposed to depth)
			const mars::RangeX <unsigned short> & viter,		// Range of allowed number of vein-subdivision iterations (0 = perfectly straight vein, 2^N -> INF = hopelessly crooked)
			const float verratic		// Amount of angular erratic placement of spheres in a vein
		)
			: _sizeflux(sizeflux), _kidflux(kidflux), _limit(limit), _minimum(minimum), _fminimum(static_cast< float > (minimum)), _maxtier(maxtier), _viter(viter), _verratic(verratic), _fpihalf(static_cast< float > (mars::PI / 2)) {}

		PackPtr createLaccolith (const VECTOR & at, const float scale, const float tail) const
		{
			using namespace mars;

			PackPtr pPack = new RandomSpherePack<T> (_limit, _minimum, _maxtier, _sizeflux, _kidflux);
			float size = scale * tail;

			pPack->spawn(at, static_cast< T > (scale));
			if (size > _fminimum)
			{
				pPack->spawn(_fpihalf, _fpihalf, static_cast< T > (size));
				size *= tail;

				if (size > _fminimum)
					pPack->spawn(_fpihalf, _fpihalf, static_cast< T > (size));
			}

			pPack->generateDescendants();

			return pPack;
		}

		PackPtr createCluster (const VECTOR & at, const float scale) const
		{
			using namespace mars;

			PackPtr pPack = new RandomSpherePack<T> (_limit, _minimum, _maxtier, _sizeflux, _kidflux);

			pPack->spawn(at, static_cast< T > (scale));
			pPack->generateDescendants();

			return pPack;
		}

		PackPtr createVein (const VECTOR & a, const VECTOR & b, const float scale, const float deviation) const
		{
			using namespace mars;

			VeinGuide guide (a, b);
			const unsigned short iterations = _viter.next();

			for (unsigned short c = 0; c < iterations; ++c)
				guide.subdivide(deviation);

			PackPtr pPack = new RandomSpherePack<T> (_limit, _minimum, _maxtier, _sizeflux, _kidflux);

			typename RandomSpherePack< T >::Sphere region = pPack->createEmptySphere();
			typename VeinGuide::SegmentType i = guide.begin(), ip;
			SphericalCoords< T > spc = guide.grad (i);
			const float fSQScale = SQ(scale);
			const RangeX <float> rrarc(-_fpihalf * _verratic, _fpihalf * _verratic, 0.02f);

			region = pPack->spawn(a, static_cast< T > (scale));
			while (MAGSQ(guide.back() - region.p) > fSQScale)
			{
				ip = guide.nearestPoint(i, region.p);
				spc = guide.tail(ip) - region.p;
				region = pPack->spawn(spc.zenith + rrarc.next(), spc.azimuth + rrarc.next(), static_cast< T > (scale));
				i = ip;
			}

			pPack->generateDescendants();

			return pPack;
		}

		template< typename SB >
		PackPtr createSpline (const mars::Spline< SB > & spline, const float scale, const float deviation) const
		{
			using namespace mars;

			typedef typename mars::Spline< SB >::real real;

			PackPtr pPack = new RandomSpherePack<T> (_limit, _minimum, _maxtier, _sizeflux, _kidflux);

			for (unsigned int c = 0; c < spline.segCount(); ++c)
			{
				const real 
					fLen = spline.len(c);
				const unsigned int
					nCount = static_cast< unsigned int > (fLen / scale * 2);

				for (unsigned int i = 0; i < nCount; ++i)
					pPack->spawn(spline.compute(c, static_cast< real > (i) / static_cast< real > (nCount)), static_cast< T > (scale));
			}

			pPack->generateDescendants();

			return pPack;
		}
	};
}