#include "Triangle3.h"
#include "AxisAlignedBox3.h"
#include "common.h"
#include "Plane3.h"


using namespace std;


namespace CHCDemoEngine {

	
Triangle3::Triangle3(const Vector3 &a, const Vector3 &b, const Vector3 &c) 
{
	Init(a, b, c);
}


void Triangle3::Init(const Vector3 &a, const Vector3 &b, const Vector3 &c) 
{
	mVertices[0] = a;
	mVertices[1] = b;
	mVertices[2] = c;
}


AxisAlignedBox3 Triangle3::GetBoundingBox() const
{
	AxisAlignedBox3 box;
	box.Initialize();

	box.Include(mVertices[0]);
	box.Include(mVertices[1]);
	box.Include(mVertices[2]);

	box.EnlargeToMinSize();
	
	return box;
}


Vector3 Triangle3::GetNormal() const 
{
	const Vector3 v1 = mVertices[0] - mVertices[1];
	const Vector3 v2 = mVertices[2] - mVertices[1];

	return Normalize(CrossProd(v2, v1));
}


Vector3 Triangle3::GetWorldCenter() const 
{
	return (mVertices[0] + mVertices[1] + mVertices[2]) / 3.0f;
}


float Triangle3::GetArea() const 
{
	Vector3 v1 = mVertices[0] - mVertices[1], v2=mVertices[2] - mVertices[1];
	return 0.5f * Magnitude(CrossProd(v2, v1));
}


bool Triangle3::GetPlaneIntersection(const Plane3 &plane, 
									 Vector3 &intersectA, 
									 Vector3 &intersectB) const
{
	int side[3];

	// compute distance from plane
	for (int i = 0; i < 3; ++ i)
		side[i] = plane.Side(mVertices[i], Limits::Small);

	/////
	// no intersection => early exit
	if (((side[0] > 0) && (side[1] > 0) && (side[2] > 0)) ||
		((side[0] < 0) && (side[1] < 0) && (side[2] < 0)))
	{
		return false;
	}

	/////////////
	// at least 2 triangle vertices lie in plane => early exit

	for (int i = 0; i < 3; ++ i)
	{
		if (!side[i] && !side[(i + 1) % 3])
		{
			intersectA = mVertices[i];
			intersectB = mVertices[(i + 1) % 3];
			
			return true;
		}
	}

	bool foundA = false;

	// compute intersection points
	for (int i = 0; i < 3; ++ i)
	{
		const int i_2 = (i + 1) % 3;

		// intersection found
		if ((side[i] >= 0) && (side[i_2] <= 0) ||
			(side[i] <= 0) && (side[i_2] >= 0))
		{	
			const float t = plane.FindT(mVertices[i], mVertices[i_2]);
			
			if (!foundA)
			{
				intersectA = mVertices[i] + t * (mVertices[i_2] - mVertices[i]);
				foundA = true;
			}
			else
			{
				intersectB = mVertices[i] + t * (mVertices[i_2] - mVertices[i]);
				return true;
			}
		}
	}

	cout << "warning! wrong triangle - plane intersection" << endl;
	return false; // something went wrong!
}


bool Triangle3::Valid() const
{
	const Vector3 a = mVertices[0] - mVertices[1];
	const Vector3 b = mVertices[0] - mVertices[2];
	const Vector3 cross_a_b = CrossProd(a, b);

	const float eps = 1e-6f;
	
	if (SqrMagnitude(cross_a_b) <= eps * eps) 
	{
		// v0, v1 & v2 lies on a line (area == 0)
		return false;
	}

	return true;
}


}