using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Utility;

namespace Chernobyl.Mathematics.Geometry
{
    /// <summary>
    /// The default implementation of <see cref="IArc"/>. This type is a 
    /// representation of a part of a curve that is bounded by two distinct 
    /// end points and contains every point on the curve between its end points.
    /// The <see cref="IArc"/> holds several <see cref="ITransform"/> instances
    /// that represent points along the arc. The first <see cref="ITransform"/> 
    /// is the first end point and the last <see cref="ITransform"/> is the last 
    /// end point. <see cref="ITransform"/> instances are ordered in this
    /// <see cref="IEnumerable{T}"/> so that drawing an arc through these
    /// points in the order specified by this <see cref="IEnumerable{T}"/>
    /// represents the actual arc. If an <see cref="ITransform"/> is stored at
    /// the beginning of the <see cref="IEnumerable{T}"/> and at the end of it
    /// then the arc is a loop. If this <see cref="IEnumerable{T}"/> has only
    /// two <see cref="ITransform"/> points then it is a straight line segment.
    /// </summary>
    public class Arc : IArc
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Arc"/> class.
        /// </summary>
        /// <param name="points">The points that make up this arc. The first 
        /// <see cref="ITransform"/> is the first end point and the last 
        /// <see cref="ITransform"/> is the last end point. 
        /// <see cref="ITransform"/> instances are ordered in this
        /// <see cref="IEnumerable{T}"/> so that drawing an arc through these
        /// points in the order specified by this <see cref="IEnumerable{T}"/>
        /// represents the actual arc. If an <see cref="ITransform"/> is stored at
        /// the beginning of the <see cref="IEnumerable{T}"/> and at the end of it
        /// then the arc is a loop. If this <see cref="IEnumerable{T}"/> has only
        /// two <see cref="ITransform"/> points then it is a straight line segment.</param>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the passed
        /// in <paramref name="points"/> <see cref="IEnumerable{T}"/> contains
        /// less than two points.</exception>
        public Arc(IEnumerable<ITransform> points) : this()
        {
            const int minimumPoints = 2;
            if (points.Take(minimumPoints).Count() < minimumPoints)
                throw new ArgumentOutOfRangeException("points", points, 
                    "An arc can only be composed of at least 2 points.");

            _points = points;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Arc" /> class.
        /// </summary>
        /// <param name="lines">The lines.</param>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the passed
        /// in <paramref name="lines"/> <see cref="IEnumerable{T}"/> is empty.</exception>
        public Arc(IEnumerable<ILineSegment> lines) : this()
        {
            if (lines.Any() == false)
                throw new ArgumentOutOfRangeException("lines", lines,
                                                      "An arc can only be " +
                                                      "composed of at least 2 " + 
                                                      "points.");

            LinkedList<ILineSegment> lineList = new LinkedList<ILineSegment>(lines);
            int pointCount = lineList.Count * 2; // each line has 2 points.
            List<ITransform> points = new List<ITransform>(pointCount);

            // We start with the first line segment.
            LinkedListNode<ILineSegment> currentNode = lineList.First;
            ITransform currentNodePoint = currentNode.Value.Point2;
            ITransform siblingNodePoint = currentNode.Value.Point1;
            points.Add(siblingNodePoint);
            lineList.Remove(currentNode);

            bool finished = false;
            do
            {
                // Find the next line segment in the list.
                LinkedListNode<ILineSegment> nextNode = null;
                using (IEnumerator<LinkedListNode<ILineSegment>> nodeEnum = lineList.GetNodes().GetEnumerator())
                {
                    while (nodeEnum.MoveNext() == true && nextNode == null)
                    {
                        // Now check this segment for any points that may equal
                        // the point we are currently on.
                        LinkedListNode<ILineSegment> potentialNext = nodeEnum.Current;

                        if (currentNodePoint.Position == potentialNext.Value.Point1.Position)
                        {
                            // Point1 connects to the previous line segment so
                            // this is the next line segment in line. We will
                            // now move to Point2 of this segment to find the
                            // next matching line segment.
                            nextNode = potentialNext;
                            currentNodePoint = potentialNext.Value.Point2;
                            siblingNodePoint = potentialNext.Value.Point1;
                        }
                        else if (currentNodePoint.Position == potentialNext.Value.Point2.Position)
                        {
                            // Point2 connects to the previous line segment so
                            // this is the next line segment in line. We will
                            // now move to Point1 of this segment to find the
                            // next matching line segment.

                            // Point1 of this segment is the next point in the
                            // arc.
                            nextNode = potentialNext;
                            currentNodePoint = potentialNext.Value.Point1;
                            siblingNodePoint = potentialNext.Value.Point2;
                        }
                    }
                }

                if (nextNode != null)
                {
                    // The next line segment was found so the second point can
                    // be included in the point list.
                    points.Add(siblingNodePoint);
                    currentNode = nextNode;
                    nextNode = null;

                    // We are finished with this node and don't want it included
                    // in future searches.
                    lineList.Remove(currentNode);
                }
                else if (lineList.First != null)
                {
                    // The next segment in the line could not be found but the
                    // list of nodes is not empty. That means this is not a
                    // continguous line.
                    throw new ArgumentException("An arc must contain continguous " +
                                                "points. The set of line segments " +
                                                "passed in is not contiguous.",
                                                "lines");
                }

                // If there are no more nodes then we are at the end of the 
                // line. Add the 2nd point and we are done.
                if (lineList.First == null)
                {
                    points.Add(currentNodePoint);
                    finished = true;
                }

            } while (finished == false);

            _points = points;
        }

        /// <summary>
        /// Default constructor that performs common initialition.
        /// </summary>
        Arc()
        {
            Extensions = new List<IExtension>();
        }

        /// <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.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>
        /// The list of <see cref="IExtension"/> or
        /// <see cref="IExtension{TExtended}"/> instances that have
        /// attached themselves to this instance.
        /// </summary>
        public IList<IExtension> Extensions { get; private set; }

        /// <summary>
        /// The points that make up this arc. The first <see cref="ITransform"/>
        /// is the first end point and the last <see cref="ITransform"/> is the
        /// last end point. <see cref="ITransform"/> instances are ordered in
        /// this <see cref="IEnumerable{T}"/> so that drawing an arc through
        /// these points in the order specified by this <see cref="IEnumerable{T}"/>
        /// represents the actual arc. If an <see cref="ITransform"/> is stored at
        /// the beginning of the <see cref="IEnumerable{T}"/> and at the end of it
        /// then the arc is a loop. If this <see cref="IEnumerable{T}"/> has only
        /// two <see cref="ITransform"/> points then it is a straight line segment.
        /// </summary>
        IEnumerable<ITransform> _points;
    }
}