using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Utility;
using Chernobyl.Values;

namespace Chernobyl.Mathematics.Geometry
{
    /// <summary>
    /// An implementation of <see cref="ILineSegment"/>. This type represents a
    /// part of a line that is bounded by two distinct end points and contains 
    /// every point on the line between its end points. This type is an
    /// <see cref="IArc"/> but can only contain two points (<see cref="Point1"/>
    /// and <see cref="Point2"/>) in its <see cref="IEnumerable{T}"/>. In
    /// addition, this type is an <see cref="ITransform"/> whose 
    /// <see cref="ITransform.Position"/> is the center point between 
    /// <see cref="Point1"/> and <see cref="Point2"/>, whose X axis is parallel
    /// to the line segment between <see cref="Point1"/> and <see cref="Point2"/>,
    /// and whose X axis scale is the distance from <see cref="Point1"/> to 
    /// <see cref="Point2"/>.
    /// </summary>
    public class LineSegment : MatrixTransform, ILineSegment
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="LineSegment"/> class.
        /// </summary>
        /// <param name="point1">The first end point of this instance. This
        /// point is also contained within this <see cref="IEnumerable{T}"/>.</param>
        /// <param name="point2">The second end point of this instance. This
        /// point is also contained within this <see cref="IEnumerable{T}"/>.</param>
        /// <exception cref="ArgumentNullException">Thrown if either 
        /// <paramref name="point1"/> or <paramref name="point2"/> are null.</exception>
        public LineSegment(ITransform point1, ITransform point2)
        {
            point1.ThrowIfNull("point1");
            point2.ThrowIfNull("point2");

            _points[0] = point1;
            _points[0].TransformDirtied += PointTransformDirtied;

            _points[1] = point2;
            _points[1].TransformDirtied += PointTransformDirtied;

            IsUpdateNeeded = true;
        }

        /// <summary>
        /// The first end point of this instance. This point is also contained
        /// within this <see cref="IEnumerable{T}"/>.
        /// </summary>
        public ITransform Point1
        {
            get { return _points[0]; }
        }

        /// <summary>
        /// The second end point of this instance. This point is also contained
        /// within this <see cref="IEnumerable{T}"/>.
        /// </summary>
        public ITransform Point2
        {
            get { return _points[1]; }
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>A <see cref="IEnumerator{T}"/> that can be used to iterate
        /// through the collection.</returns>
        public IEnumerator<ITransform> GetEnumerator()
        {
            return _points.AsEnumerable().GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns>An <see cref="IEnumerator"/> object that can be used to
        /// iterate through the collection.</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        /// <summary>
        /// This method is invoked during the update of the
        /// <see cref="ITransform.WorldMatrix"/> right before the
        /// <see cref="ITransform.WorldMatrix"/> is actually updated. Typically
        /// you would override this method if you would like to modify the
        /// <see cref="ITransform.LocalMatrix"/> prior to the final calculation
        /// of the <see cref="ITransform.WorldMatrix"/>.
        /// </summary>
        /// <param name="world">The value of the <see cref="ITransform.WorldMatrix"/>.
        /// It is stored in a <see cref="LazyValue{T}"/> so that the calculation can be
        /// avoided if necessary. Don't call <see cref="LazyValue{T}.Value"/> unless
        /// required.</param>
        protected override void PreUpdate(Values.LazyValue<Matrix4> world)
        {
            base.PreUpdate(world);

            // Calculate a vector from one end point to the other.
            Vector3 point1ToPoint2 = Point2.Position - Point1.Position;

            // Now calculate the position of the local matrix which should be
            // the center point between the two end points.
            Vector4 newPosition = new Vector4(Point1.Position + (point1ToPoint2 * 0.5f), 1);

            //-----------------------------------------------------------------
            // Calculate the rotation of the transform.
            //-----------------------------------------------------------------

            Vector3 xAxis = Vector3.Normalize(Point2.Position - newPosition.Xyz);

            // If the xAxis is equal to the up/down vector than we will get a vector
            // full of NaN when we attempt to cross them. To prevent that we just
            // set the Z axis to its default value in that case.
            Vector3 zAxis;
            if (xAxis != Vector3.UnitY && xAxis != -Vector3.UnitY)
            {
                zAxis = Vector3.Normalize(Vector3.Cross(Vector3.UnitY, xAxis));

                // If the line is on a 2D plane than we always want the Z axis to
                // point in the -Z. This is because other parts of Chernobyl
                // assume that the -Z faces away from the viewer. Due to
                // precision issues on most computers, the Z axis may not be
                // exactly equal to the unit Z so we'll have to check if its
                // close.
                const float maxDifference = 0.000001f;
                if ((Vector3.UnitZ - zAxis).LengthFast < maxDifference)
                    zAxis = -Vector3.UnitZ;
            }
            else
                zAxis = -Vector3.UnitZ;

            Vector3 yAxis = Vector3.Normalize(Vector3.Cross(xAxis, zAxis));

            // Scale the X axis to match the width between the points.
            xAxis *= point1ToPoint2.Length;

            Matrix4 local = new Matrix4(new Vector4(xAxis.X, xAxis.Y, xAxis.Z, 0.0f),
                                        new Vector4(yAxis.X, yAxis.Y, yAxis.Z, 0.0f),
                                        new Vector4(zAxis.X, zAxis.Y, zAxis.Z, 0.0f),
                                        newPosition);

            SetTransformation(ref local);
        }

        /// <summary>
        /// An event handler that is invoked when either <see cref="Point1"/> or
        /// <see cref="Point2"/> are moved. This method just dirties this
        /// <see cref="ITransform"/> so that it has to update when its 
        /// transformation properties are accessed.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the 
        /// event data.</param>
        void PointTransformDirtied(object sender, EventArgs e)
        {
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// The end points of the line.
        /// </summary>
        ITransform[] _points = new ITransform[2];
    }
}