/*
   Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined( INCLUDED_WINDING_H )
#define INCLUDED_WINDING_H

#include "debugging/debugging.h"

#include <vector>

#include "math/vector.h"
#include "container/array.h"

enum ProjectionAxis
{
	eProjectionAxisX = 0,
	eProjectionAxisY = 1,
	eProjectionAxisZ = 2,
};

const float ProjectionAxisEpsilon = static_cast<float>( 0.0001 );

inline bool projectionaxis_better( float axis, float other ){
	return fabs( axis ) > fabs( other ) + ProjectionAxisEpsilon;
}

/// \brief Texture axis precedence: Z > X > Y
inline ProjectionAxis projectionaxis_for_normal( const Vector3& normal ){
	return ( projectionaxis_better( normal[eProjectionAxisY], normal[eProjectionAxisX] ) )
		   ? ( projectionaxis_better( normal[eProjectionAxisY], normal[eProjectionAxisZ] ) )
		   ? eProjectionAxisY
		   : eProjectionAxisZ
		   : ( projectionaxis_better( normal[eProjectionAxisX], normal[eProjectionAxisZ] ) )
		   ? eProjectionAxisX
		   : eProjectionAxisZ;
}


struct indexremap_t
{
	indexremap_t( std::size_t _x, std::size_t _y, std::size_t _z )
		: x( _x ), y( _y ), z( _z ){
	}
	std::size_t x, y, z;
};

inline indexremap_t indexremap_for_projectionaxis( const ProjectionAxis axis ){
	switch ( axis )
	{
	case eProjectionAxisX: return indexremap_t( 1, 2, 0 );
	case eProjectionAxisY: return indexremap_t( 2, 0, 1 );
	default: return indexremap_t( 0, 1, 2 );
	}
}

enum PlaneClassification
{
	ePlaneFront = 0,
	ePlaneBack = 1,
	ePlaneOn = 2,
};

#define MAX_POINTS_ON_WINDING 64
const std::size_t c_brush_maxFaces = 1024;


class WindingVertex
{
public:
Vector3 vertex;
Vector2 texcoord;
Vector3 tangent;
Vector3 bitangent;
std::size_t adjacent;
};



struct Winding
{
	typedef Array<WindingVertex> container_type;

	std::size_t numpoints;
	container_type points;

	typedef container_type::iterator iterator;
	typedef container_type::const_iterator const_iterator;

	Winding() : numpoints( 0 ){
	}
	Winding( std::size_t size ) : numpoints( 0 ), points( size ){
	}
	void resize( std::size_t size ){
		points.resize( size );
		numpoints = 0;
	}

	iterator begin(){
		return points.begin();
	}
	const_iterator begin() const {
		return points.begin();
	}
	iterator end(){
		return points.begin() + numpoints;
	}
	const_iterator end() const {
		return points.begin() + numpoints;
	}

	WindingVertex& operator[]( std::size_t index ){
		ASSERT_MESSAGE( index < points.size(), "winding: index out of bounds" );
		return points[index];
	}
	const WindingVertex& operator[]( std::size_t index ) const {
		ASSERT_MESSAGE( index < points.size(), "winding: index out of bounds" );
		return points[index];
	}

	void push_back( const WindingVertex& point ){
		points[numpoints] = point;
		++numpoints;
	}
	void erase( iterator point ){
		for ( iterator i = point + 1; i != end(); point = i, ++i )
		{
			*point = *i;
		}
		--numpoints;
	}
};

typedef BasicVector3<double> DoubleVector3;

class DoubleLine
{
public:
DoubleVector3 origin;
DoubleVector3 direction;
};

class FixedWindingVertex
{
public:
DoubleVector3 vertex;
DoubleLine edge;
std::size_t adjacent;

FixedWindingVertex( const DoubleVector3& vertex_, const DoubleLine& edge_, std::size_t adjacent_ )
	: vertex( vertex_ ), edge( edge_ ), adjacent( adjacent_ ){
}
};

struct FixedWinding
{
	typedef std::vector<FixedWindingVertex> Points;
	Points points;

	FixedWinding(){
		points.reserve( MAX_POINTS_ON_WINDING );
	}

	FixedWindingVertex& front(){
		return points.front();
	}
	const FixedWindingVertex& front() const {
		return points.front();
	}
	FixedWindingVertex& back(){
		return points.back();
	}
	const FixedWindingVertex& back() const {
		return points.back();
	}

	void clear(){
		points.clear();
	}

	void push_back( const FixedWindingVertex& point ){
		points.push_back( point );
	}
	std::size_t size() const {
		return points.size();
	}

	FixedWindingVertex& operator[]( std::size_t index ){
		//ASSERT_MESSAGE(index < MAX_POINTS_ON_WINDING, "winding: index out of bounds");
		return points[index];
	}
	const FixedWindingVertex& operator[]( std::size_t index ) const {
		//ASSERT_MESSAGE(index < MAX_POINTS_ON_WINDING, "winding: index out of bounds");
		return points[index];
	}

};


inline void Winding_forFixedWinding( Winding& winding, const FixedWinding& fixed ){
	winding.resize( fixed.size() );
	winding.numpoints = fixed.size();
	for ( std::size_t i = 0; i < fixed.size(); ++i )
	{
		winding[i].vertex[0] = static_cast<float>( fixed[i].vertex[0] );
		winding[i].vertex[1] = static_cast<float>( fixed[i].vertex[1] );
		winding[i].vertex[2] = static_cast<float>( fixed[i].vertex[2] );
		winding[i].adjacent = fixed[i].adjacent;
	}
}

inline std::size_t Winding_wrap( const Winding& winding, std::size_t i ){
	ASSERT_MESSAGE( winding.numpoints != 0, "Winding_wrap: empty winding" );
	return i % winding.numpoints;
}

inline std::size_t Winding_next( const Winding& winding, std::size_t i ){
	return Winding_wrap( winding, ++i );
}


class Plane3;

void Winding_createInfinite( FixedWinding& w, const Plane3& plane, double infinity );

const double ON_EPSILON = 1.0 / ( 1 << 8 );

/// \brief Returns true if edge (\p x, \p y) is smaller than the epsilon used to classify winding points against a plane.
inline bool Edge_isDegenerate( const Vector3& x, const Vector3& y ){
	return vector3_length_squared( y - x ) < ( ON_EPSILON * ON_EPSILON );
}

void Winding_Clip( const FixedWinding& winding, const Plane3& plane, const Plane3& clipPlane, std::size_t adjacent, FixedWinding& clipped );

struct brushsplit_t
{
	brushsplit_t(){
		counts[0] = 0;
		counts[1] = 0;
		counts[2] = 0;
	}
	brushsplit_t& operator+=( const brushsplit_t& other ){
		counts[0] += other.counts[0];
		counts[1] += other.counts[1];
		counts[2] += other.counts[2];
		return *this;
	}
	std::size_t counts[3];
};

brushsplit_t Winding_ClassifyPlane( const Winding& w, const Plane3& plane );

bool Winding_PlanesConcave( const Winding& w1, const Winding& w2, const Plane3& plane1, const Plane3& plane2 );
bool Winding_TestPlane( const Winding& w, const Plane3& plane, bool flipped );

std::size_t Winding_FindAdjacent( const Winding& w, std::size_t face );

std::size_t Winding_Opposite( const Winding& w, const std::size_t index, const std::size_t other );
std::size_t Winding_Opposite( const Winding& w, std::size_t index );

void Winding_Centroid( const Winding& w, const Plane3& plane, Vector3& centroid );


inline void Winding_printConnectivity( Winding& winding ){
	for ( Winding::iterator i = winding.begin(); i != winding.end(); ++i )
	{
		std::size_t vertexIndex = std::distance( winding.begin(), i );
		globalOutputStream() << "vertex: " << Unsigned( vertexIndex ) << " adjacent: " << Unsigned( ( *i ).adjacent ) << "\n";
	}
}

#endif