using System;

using System.ComponentModel;			// for TypeConverterAttribute

using System.Diagnostics;				// mostly for Debug.Assert(...)



namespace Axe.Geometry

{

	/// <summary>

	/// Представляет плоскость в пространстве

	/// xA + yB + zC - D = 0

	/// </summary>

	public struct Plane3 : ICloneable 

	{

		/// <summary>

		/// Создает новую плоскость

		/// </summary>

		/// <mParam name="normal"></mParam>

		/// <mParam name="constant"></mParam>

		public Plane3( Vector3 normal, double constant ) 

		{

			this.Normal = normal;

			this.Constant = constant;

		}



		/// <summary>

		/// Create the plane that has the given normal and is coplanar with the given point

		/// </summary>

		/// <mParam name="normal"></mParam>

		/// <mParam name="coplanarPoint"></mParam>

		/// <returns></returns>

		static public Plane3 FromNormalAndPoint( Vector3 normal, Vector3 coplanarPoint ) 

		{

			return	new Plane3( normal.GetUnit(), Vector3.Dot( normal, coplanarPoint ) );

		}

		

		/// <summary>

		/// Create the plane defined by the three given points

		/// </summary>

		/// <mParam name="pt0">Первая вершина</mParam>

		/// <mParam name="pt1">Вторая вершина</mParam>

		/// <mParam name="pt2">Треться вершина</mParam>

		/// <returns>Созданная плоскость</returns>

		static public Plane3 FromCoplanarPoints( Vector3 pt0, Vector3 pt1, Vector3 pt2 ) 

		{

			Vector3 normal = Vector3.Cross( pt2 - pt1, pt0 - pt1 ).GetUnit();

			return	new Plane3( normal, Vector3.Dot( normal, pt0 ) );

		}

		



		object ICloneable.Clone() 

		{

			return	new Plane3( this.Normal, this.Constant );

		}



		/// <summary>

		/// Copy

		/// </summary>

		/// <returns></returns>

		public Plane3 Clone() 

		{

			return	new Plane3( this.Normal, this.Constant );

		}



		/// <summary>

		/// The Normal parameter of the plane when defined as "Normal*( pt ) - Constant = 0" 

		/// </summary>

		public Vector3 Normal;



		/// <summary>

		/// The Constant parameter of the plane when defined as "Normal*( pt ) - Constant = 0"

		/// </summary>

		public double Constant;



		/// <summary>

		/// The A parameter of the plane when defined as "Ax + By + Cz - D = 0"

		/// </summary>

		public double A 

		{

			get {	return	Normal.X;	}

			set {	Normal.X = value;	}

		}



		/// <summary>

		/// The B parameter of the plane when defined as "Ax + By + Cz - D = 0"

		/// </summary>

		public double B 

		{

			get {	return	Normal.Y;	}

			set {	Normal.Y = value;	}

		}

		

		/// <summary>

		/// The C parameter of the plane when defined as "Ax + By + Cz - D = 0"

		/// </summary>

		public double C 

		{

			get {	return	Normal.Z;	}

			set {	Normal.Z = value;	}

		}

		

		/// <summary>

		/// The D parameter of the plane when defined as "Ax + By + Cz - D = 0"

		/// </summary>

		public double D 

		{

			get {	return	Constant;	}

			set {	Constant = value;	}

		}

			

		/// <summary>

		/// Flip the plane.

		/// </summary>

		public void Flip() 

		{

			Normal = - Normal;

			Constant = - Constant;

		}



		/// <summary>

		/// Создает новый plane that is identical the current but flipped.

		/// </summary>

		/// <returns></returns>

		public Plane3 GetFlipped() 

		{

			Plane3 plane = this.Clone();

			plane.Flip();

			return plane;

		}



		/// <summary>

		/// Get the shortest distance from the point to the plane

		/// </summary>

		/// <mParam name="pt"></mParam>

		/// <returns></returns>

		public double GetDistanceToPlane( Vector3 pt ) 

		{

			return	Vector3.Dot( pt, Normal ) - Constant; 

		}



		/// <summary>

		/// Get the sign of the point in relation to the plane

		/// </summary>

		/// <mParam name="pt"></mParam>

		/// <returns></returns>

		public Sign GetSign( Vector3 pt ) 

		{

			return Math3D.GetSign( GetDistanceToPlane( pt ), Math3D.EpsilonF );

		}



		/// <summary>

		/// Get the aggregate sign of the polygon in relation to the plane

		/// </summary>

		/// <mParam name="polygon"></mParam>

		/// <returns></returns>

		public Sign GetSign( Polygon polygon ) 

		{

			Sign sign = Sign.Undefined;



			foreach( Vector3 p in polygon.Points ) 

			{

				sign = Math3D.CombineSigns( sign, this.GetSign( p ) );

			}



			return sign;

		}



		/// <summary>

		/// Project a point onto the plane

		/// </summary>

		/// <mParam name="pt"></mParam>

		/// <returns></returns>

		public Vector3 ProjectOntoPlane( Vector3 pt ) 

		{

			return	pt + ( Constant - Vector3.Dot( pt, Normal ) ) * Normal;

		}



		/// <summary>

		/// Determine whether the rkLine connecting pt0 to pt1 intersects the plane

		/// </summary>

		/// <mParam name="pt0"></mParam>

		/// <mParam name="pt1"></mParam>

		/// <returns></returns>

		public bool IsIntersection( Vector3 pt0, Vector3 pt1 ) 

		{

			int sign0 = (int) Math3D.GetSign( GetDistanceToPlane( pt0 ) );

			int sign1 = (int) Math3D.GetSign( GetDistanceToPlane( pt1 ) );

			

			return ( sign0 < 0 && sign1 > 0 ) || ( sign0 > 0 && sign1 <= 0 );

		}



		/// <summary>

		/// Determine the exact location where the given rkLine segment intersects the plane

		/// </summary>

		/// <mParam name="pt0"></mParam>

		/// <mParam name="pt1"></mParam>

		/// <returns></returns>

		public Vector3 GetIntersection( Vector3 pt0, Vector3 pt1 ) 

		{

			Debug.Assert( IsIntersection( pt0, pt1 ) == true );



			Vector3 ptDirection = pt1 - pt0;

			double denominator = Vector3.Dot( Normal, ptDirection );

			if( denominator == 0 ) 

			{

				throw new DivideByZeroException( "Can not get the intersection of a plane with a line when they are parallel to each other." );

			}

			double t = ( Constant - Vector3.Dot( Normal, pt0 ) ) / denominator;

			return	pt0 + ptDirection * t;

		}



		/// <summary>

		/// Clip the given polygon by the plane so that only the regions

		/// located positive of the plane remain.

		/// </summary>

		/// <mParam name="polygon"></mParam>

		public void ClipPolygon( Polygon polygon ) 

		{

			Vector3 ptNormal = polygon.GetNormal();



			Vector3Collection	vNewPoints = new Vector3Collection();

			int iPoints = polygon.Points.Count;



			for ( int i = 0; i < iPoints; i ++ ) 

			{

				Vector3 pt0 = polygon.Points[ ( i + iPoints - 1 ) % iPoints ];

				Vector3 pt1 = polygon.Points[ i ];



				int sign0 = (int) Math3D.GetSign( this.GetDistanceToPlane( pt0 ), Math3D.EpsilonF );

				int sign1 = (int) Math3D.GetSign( this.GetDistanceToPlane( pt1 ), Math3D.EpsilonF );



				if( sign0 > 0 ) 

				{

					// rkLine is infront

					if ( sign1 >= 0 ) 

					{

						vNewPoints.Add( pt1 );

					}

						// rkLine is entering plane

					else if( sign1 < 0 ) 

					{

						Debug.Assert( sign0 > 0 && sign1 < 0 );

						vNewPoints.Add( this.GetIntersection( pt0, pt1 ) );

					}

				}

				else if( sign0 == 0 ) 

				{

					// rkLine is infront

					if( sign1 > 0 ) 

					{

						vNewPoints.Add( pt1 );

					}

						// rkLine is coplanar

					else if( sign1 == 0 ) 

					{

						vNewPoints.Add( pt1 );

					}

						// rkLine is behind

					else if( sign1 < 0 ) 

					{

					}

				}

				else if( sign0 < 0 ) 

				{

					// rkLine is leaving plane

					if( sign1 > 0 ) 

					{

						Debug.Assert( sign0 < 0 && sign1 > 0 );

						vNewPoints.Add( this.GetIntersection( pt0, pt1 ) );

						vNewPoints.Add( pt1 );

					}

						// rkLine is leaving plane

					else if( sign1 == 0 ) 

					{

						vNewPoints.Add( pt1 );

					}

						// rkLine is behind

					else if( sign1 < 0 ) 

					{

					}

				}

			}



			// set new points

			polygon.Points.Clear();

			polygon.Points.AddRange( vNewPoints );



			/*if( this.Points.Count >= 3 ) {

				if( Vector3.Dot( this.GetNormal(), ptNormal ) < 0 ) {

					this.Flip();

				}

			}  */



			polygon.Optimize();

		}

	

		/// <summary>

		/// Are two planes equal?

		/// </summary>

		/// <mParam name="a"></mParam>

		/// <mParam name="b"></mParam>

		/// <returns></returns>

		static public bool operator==( Plane3 a, Plane3 b ) 

		{

			return ( a.Constant == b.Constant ) && ( a.Normal == b.Normal );

		}



		/// <summary>

		/// Are two planes not equal?

		/// </summary>

		/// <mParam name="a"></mParam>

		/// <mParam name="b"></mParam>

		/// <returns></returns>

		static public bool operator!=( Plane3 a, Plane3 b ) 

		{

			return ( a.Constant != b.Constant ) || ( a.Normal != b.Normal );

		}



		/// <summary>

		/// Is given object equal to current planes?

		/// </summary>

		/// <mParam name="o"></mParam>

		/// <returns></returns>

		public override bool Equals( object o ) 

		{

			if( o is Plane3 ) 

			{

				Plane3 plane = (Plane3) o;

				return ( this.Constant == plane.Constant ) && ( this.Normal == plane.Normal );

			}

			return false;

		}



		/// <summary>

		/// Get the hashcode of the planes

		/// </summary>

		/// <returns></returns>

		public override int GetHashCode() 

		{

			return	this.Constant.GetHashCode() ^ this.Normal.GetHashCode();

		}

		

		

		/// <summary>

		/// Get an orthogonal basis for the plane

		/// </summary>

		/// <mParam name="u"></mParam>

		/// <mParam name="v"></mParam>

		public void GetBasis( out Vector3 u, out Vector3 v ) 

		{

			Vector3 pt = this.ProjectOntoPlane( Vector3.Origin );



			u = this.ProjectOntoPlane( pt + Vector3.XAxis ) - pt;

			u = Vector3.Max( u, this.ProjectOntoPlane( pt + Vector3.YAxis ) - pt );

			u = Vector3.Max( u, this.ProjectOntoPlane( pt + Vector3.ZAxis ) - pt );



			v = Vector3.Cross( u, this.Normal );



			u.Normalize();

			v.Normalize();

		}



		/// <summary>

		/// Create a polygon coplanar with the current plane that extends to the given extent

		/// </summary>

		/// <mParam name="fExtent"></mParam>

		/// <returns></returns>

		public Polygon CreatePolygon( double fExtent ) 

		{

			int a, b, c;



			double[] n = new double[3] { Math.Abs( Normal.X ), Math.Abs( Normal.Y ), Math.Abs( Normal.Z ) };



			if( n[0] >= n[1] && n[0] >= n[2] ) 

			{

				a = 1;	b = 2;	c = 0;

			}

			else if( n[1] >= n[0] && n[1] >= n[2] ) 

			{

				a = 0;	b = 2;	c = 1;

			}

			else if( n[2] >= n[0] && n[2] >= n[1] ) 

			{

				a = 0;	b = 1;	c = 2;

			}

			else 

			{

				a = b = c = -1;

				Debug.Assert( false );

			}



			//Debug.WriteLine( " normal[" + Normal.ToString() + " a[" + a + "] b[" + b + "] c[" + c + "]" );



			int[]	aSigns = new int[4] {  1,  1, -1, -1 };

			int[]	bSigns = new int[4] {  1, -1, -1,  1 };



			Polygon	poly = new Polygon();



			for( int i = 0; i < 4; i ++ ) 

			{

				Vector3 pt = new Vector3();



				pt[a] = fExtent * aSigns[i];

				pt[b] = fExtent * bSigns[i];

				pt[c] = ( Constant -  Normal[a] * pt[a] - Normal[b] * pt[b] ) / Normal[c];



				//Debug.WriteLine( " pt[" + i + "] = " + pt.ToString() + " dTp = " + DistanceToPlane( pt ) );

			

				poly.Points.Add( pt );

			}



			//Debug.WriteLine( " plane.Normal = " + Normal ); 

			//Debug.WriteLine( " plane.Constant = " + Constant ); 



			if( Vector3.Dot( Normal, poly.GetNormal() ) < 0 ) 

			{

				poly.Flip();

			}



			//Debug.WriteLine( " polygon.Normal = " + poly.Normal().ToString() ); 



			return	poly;

		}





		/// <summary>

		/// Get a description of the plane.

		/// </summary>

		/// <returns></returns>

		public override string ToString() 

		{

			return	"Plane3 [ n=" + Normal.ToString() + " c=" + Constant + " ]";

		}



		/// <summary>

		/// Zero

		/// </summary>

		static public readonly Plane3	Zero	= new Plane3();

	}

}