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

namespace Chernobyl.Mathematics.Geometry
{
    /// <summary>
    /// An <see cref="IShape"/> that can expand and contract to fit a 
    /// collection of other <see cref="IShape"/> instances inside of it. 
    /// </summary>
    public class ShapeCollection : MatrixTransform, IShape, ICollection<IShape>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ShapeCollection"/> 
        /// class.
        /// </summary>
        public ShapeCollection()
            : this(0)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ShapeCollection"/> 
        /// class.
        /// </summary>
        /// <param name="capacity">The number of elements that the new list can 
        /// initially store.</param>
        public ShapeCollection(int capacity)
            : this(new List<IShape>(capacity))
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ShapeCollection"/> class.
        /// </summary>
        /// <param name="geometries">The list to store <see cref="IShape"/>s 
        /// in or null if the default <see cref="List{T}"/> should be used.</param>
        public ShapeCollection(ICollection<IShape> geometries)
            : this(geometries, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ShapeCollection"/> class.
        /// </summary>
        /// <param name="geometries">The list to store <see cref="IShape"/>s 
        /// in or null if the default <see cref="List{T}"/> should be used.</param>
        /// <param name="childTransformList">The list to use for the 
        /// <see cref="ITransform.TransformChildren"/> list or null if the default 
        /// <see cref="List{T}"/> should be used..</param>
        public ShapeCollection(ICollection<IShape> geometries, IList<ITransform> childTransformList) : base(childTransformList)
        {
            Geometries = geometries ?? new List<IShape>();
            WidthModifier = DefaultWidthModifier;
            HeightModifier = DefaultHeightModifier;
            DepthModifier = DefaultDepthModifier;
        }

        /// <summary>
        /// The largest width of the object in the object's X axis.
        /// </summary>
        public float Width
        {
            get
            {
                Update();
                return _width;
            }
        }

        /// <summary>
        /// The largest height of the object in the object's Y axis.
        /// </summary>
        public float Height
        {
            get
            {
                Update();
                return _height;
            }
        }

        /// <summary>
        /// The largest depth of the object in the object's Z axis. If the depth
        /// is zero, the object is 2D.
        /// </summary>
        public float Depth
        {
            get
            {
                Update();
                return _depth;
            }
        }

        /// <summary>
        /// True if this <see cref="IShape"/> is convex, false if it is concave
        /// or has 0 <see cref="Dimensions"/> (such as a point).This property 
        /// alway returns false.
        /// </summary>
        public bool IsConvex
        {
            get { return false; }
        }

        /// <summary>
        /// The amount of space taken up by an object on a flat plane in
        /// square metres (m^2). This property will return the sum of the areas 
        /// of the <see cref="IShape"/>s contained within this 
        /// <see cref="ICollection"/>.
        /// </summary>
        public float Area
        {
            get { return Geometries.Sum(shape => shape.Area); }
        }

        /// <summary>
        /// The amount of 3D space this object consumes in cubic metres (m^3).
        /// This property will return the sum of the volumes of the 
        /// <see cref="IShape"/>s contained within this <see cref="ICollection"/>.
        /// </summary>
        public float Volume
        {
            get { return Geometries.Sum(shape => shape.Volume); }
        }

        /// <summary>
        /// The length of the path that surrounds a shape specified in metres (m).
        /// This property will return the sum of the perimeters of the 
        /// <see cref="IShape"/>s contained within this <see cref="ICollection"/>.
        /// </summary>
        public float Perimeter
        {
            get { return Geometries.Sum(shape => shape.Perimeter); }
        }

        /// <summary>
        /// The minimum number of coordinates needed to specify each point
        /// within this object. This property will return the largest dimension 
        /// of the <see cref="IShape"/>s contained in this <see cref="ICollection{T}"/>.
        /// </summary>
        public uint Dimensions
        {
            get { return Geometries.Max(shape => shape.Dimensions); }
        }

        /// <summary>
        /// Adds an item to the <see cref="ICollection{T}"/>.
        /// </summary>
        /// <param name="item">The object to add to the <see cref="ICollection{T}"/>.</param>
        /// <exception cref="NotSupportedException">The <see cref="ICollection{T}"/> 
        /// is read-only.</exception>
        public void Add(IShape item)
        {
            Geometries.Add(item);
            item.TransformDirtied += Geometry2DTransformDirtied;
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// Adds an item to the <see cref="ICollection{T}"/>.
        /// </summary>
        /// <param name="items">The objects to add to the <see cref="ICollection{T}"/>.</param>
        /// <exception cref="NotSupportedException">The <see cref="ICollection{T}"/> 
        /// is read-only.</exception>
        public void AddRange(IEnumerable<IShape> items)
        {
            foreach (IShape volume2D in items)
                Geometries.Add(volume2D);
        }

        /// <summary>
        /// Removes all items from the <see cref="ICollection{T}"/>.
        /// </summary>
        /// <exception cref="NotSupportedException">The <see cref="ICollection{T}"/> 
        /// is read-only. </exception>
        public void Clear()
        {
            // unsubscribe from these geometries, if any
            foreach (IShape volume2D in _geometries)
                volume2D.TransformDirtied -= Geometry2DTransformDirtied;

            Geometries.Clear();
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// Determines whether the <see cref="ICollection{T}"/> contains a 
        /// specific value.
        /// </summary>
        /// <param name="item">The object to locate in the 
        /// <see cref="ICollection{T}"/>.</param>
        /// <returns>
        /// true if <paramref name="item"/> is found in the 
        /// <see cref="ICollection{T}"/>; otherwise, false.
        /// </returns>
        public bool Contains(IShape item)
        {
            return Geometries.Contains(item);
        }

        /// <summary>
        /// Copies the elements of the <see cref="ICollection{T}"/> to an 
        /// <see cref="Array"/>, starting at a particular <see cref="Array"/> 
        /// index.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="Array"/> that is 
        /// the destination of the elements copied from 
        /// <see cref="ICollection{T}"/>. The <see cref="Array"/> must 
        /// have zero-based indexing.</param>
        /// <param name="arrayIndex">The zero-based index in 
        /// <paramref name="array"/> at which copying begins.</param>
        /// <exception cref="ArgumentNullException"><paramref name="array"/> is 
        /// null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// <paramref name="arrayIndex"/> is less than 0.</exception>
        /// <exception cref="ArgumentException"><paramref name="array"/> is 
        /// multidimensional, <paramref name="arrayIndex"/> is equal to or 
        /// greater than the length of <paramref name="array"/>, or the number 
        /// of elements in the source <see cref="ICollection{T}"/> is greater 
        /// than the available space from <paramref name="arrayIndex"/> to the 
        /// end of the destination <paramref name="array"/>.</exception>
        public void CopyTo(IShape[] array, int arrayIndex)
        {
            Geometries.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Gets the number of <see cref="IShape"/>s contained in the 
        /// <see cref="ICollection{T}"/>.
        /// </summary>
        /// <returns>The number of elements contained in the 
        /// <see cref="ICollection{T}"/>.</returns>
        public int Count
        {
            get { return Geometries.Count; }
        }

        /// <summary>
        /// Gets a value indicating whether the <see cref="ICollection{T}"/> is 
        /// read-only.
        /// </summary>
        /// <returns>true if the <see cref="ICollection{T}"/> is read-only; 
        /// otherwise, false.</returns>
        public bool IsReadOnly
        {
            get { return Geometries.IsReadOnly; }
        }

        /// <summary>
        /// Removes the first occurrence of a specific object from the 
        /// <see cref="ICollection{T}"/>.
        /// </summary>
        /// <param name="item">The object to remove from the 
        /// <see cref="ICollection{T}"/>.</param>
        /// <returns>
        /// true if <paramref name="item"/> was successfully removed from the 
        /// <see cref="ICollection{T}"/>; otherwise, false. This method also 
        /// returns false if <paramref name="item"/> is not found in the original 
        /// <see cref="ICollection{T}"/>.
        /// </returns>
        /// <exception cref="NotSupportedException">The 
        /// <see cref="ICollection{T}"/> is read-only.</exception>
        public bool Remove(IShape item)
        {
            bool result = Geometries.Remove(item);

            // if the shape was properly removed then we unsubscribe from its
            // transform dirty event and update
            if (result == true)
            {
                item.TransformDirtied -= Geometry2DTransformDirtied;
                IsUpdateNeeded = true;
            }

            return result;
        }

        /// <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<IShape> GetEnumerator()
        {
            return Geometries.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. This method
        /// ensures the bounds of this instance are kept up to date.
        /// </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(LazyValue<Matrix4> world)
        {
            base.PreUpdate(world);

            UpdateBounds();
        }

        /// <summary>
        /// Called by the <see cref="PreUpdate(LazyValue{Matrix4})"/> method, this 
        /// method updates the <see cref="Width"/>, <see cref="Height"/>, and 
        /// <see cref="ITransform.Position"/> of this <see cref="ShapeCollection"/>.
        /// </summary>
        protected void UpdateBounds()
        {
            // update our width, height and position based on the width, height, 
            // and position of the geometries contained within this collection

            float leftMostPoint = 0;
            float rightMostPoint = 0;
            float topMostPoint = 0;
            float bottomMostPoint = 0;
            float frontMostPoint = 0;
            float backMostPoint = 0;

            using (IEnumerator<IShape> volumeEnumerator = Geometries.GetEnumerator())
            {
                // grab the first IShape and use it's left, right, top 
                // and bottom points as our starting points.
                if (volumeEnumerator.MoveNext() == true)
                {
                    IShape geo = volumeEnumerator.Current;

                    float halfWidth = geo.Width * 0.5f;
                    leftMostPoint = geo.Position.X - halfWidth;
                    rightMostPoint = geo.Position.X + halfWidth;

                    float halfHeight = geo.Height * 0.5f;
                    bottomMostPoint = geo.Position.Y - halfHeight;
                    topMostPoint = geo.Position.Y + halfHeight;

                    float halfDepth = geo.Depth * 0.5f;
                    backMostPoint = geo.Position.Y - halfDepth;
                    frontMostPoint = geo.Position.Y + halfDepth;
                }

                // now locate the points on the geometries that are farthest 
                // out. These points will define our rectangle's edges
                while (volumeEnumerator.MoveNext() == true)
                {
                    IShape geo = volumeEnumerator.Current;

                    float halfWidth = geo.Width * 0.5f;

                    // check the left side
                    float leftPoint = geo.Position.X - halfWidth;
                    if (leftPoint < leftMostPoint)
                        leftMostPoint = leftPoint;

                    // check the right side
                    float rightPoint = geo.Position.X + halfWidth;
                    if (rightPoint > rightMostPoint)
                        rightMostPoint = rightPoint;

                    float halfHeight = geo.Height * 0.5f;

                    // check the bottom
                    float bottomPoint = geo.Position.Y - halfHeight;
                    if (bottomPoint < bottomMostPoint)
                        bottomMostPoint = bottomPoint;

                    // check the top
                    float topPoint = geo.Position.Y + halfHeight;
                    if (topPoint > topMostPoint)
                        topMostPoint = topPoint;

                    float halfDepth = geo.Depth * 0.5f;

                    // check the back
                    float backPoint = geo.Position.Y + halfDepth;
                    if (backPoint > backMostPoint)
                        backMostPoint = backPoint;

                    // check the front
                    float frontPoint = geo.Position.Y + halfDepth;
                    if (frontPoint > frontMostPoint)
                        frontMostPoint = frontPoint;
                }

            }

            // generate our rectangle from the points that we have found
            _width = rightMostPoint - leftMostPoint;
            _height = topMostPoint - bottomMostPoint;
            _depth = frontMostPoint - backMostPoint;

            // grab the local matrix and set its row 0 (the first row, which 
            // holds the scale in the X axis) to unit vector scaled by our 
            // new width, set its row 1 (the second row, which holds the 
            // scale in the Y axis) to unit vector scaled by our new height, 
            // and set its position
            Matrix4 local = LocalMatrix;
            local.Row0 = Vector4.UnitX * (_width + WidthModifier);
            local.Row1 = Vector4.UnitY * (_height + HeightModifier);
            local.Row2 = Vector4.UnitZ * (_depth + DepthModifier);
            local.Row3 = new Vector4(leftMostPoint + _width * 0.5f, bottomMostPoint + _height * 0.5f, LocalMatrix.Row3.Z, LocalMatrix.Row3.W);
            SetTransformation(ref local);
        }

        /// <summary>
        /// The amount to add or remove from the width of the this 
        /// <see cref="IShape"/> in addition to the width calculated for 
        /// the contained <see cref="IShape"/>s.The default value of this 
        /// property is given by the static field 
        /// <see cref="DefaultWidthModifier"/>.
        /// </summary>
        public float WidthModifier
        {
            get { return _widthModifier; }
            set
            {
                _widthModifier = value;
                IsUpdateNeeded = true;
            }
        }

        /// <summary>
        /// The amount to add or remove from the height of the this 
        /// <see cref="IShape"/> in addition to the height calculated for 
        /// the contained <see cref="IShape"/>s. The default value of this 
        /// property is given by the static field 
        /// <see cref="DefaultHeightModifier"/>.
        /// </summary>
        public float HeightModifier
        {
            get { return _heightModifier; }
            set
            {
                _heightModifier = value;
                IsUpdateNeeded = true;
            }
        }

        /// <summary>
        /// The amount to add or remove from the depth of the this 
        /// <see cref="IShape"/> in addition to the depth calculated for 
        /// the contained <see cref="IShape"/>s. The default value of this 
        /// property is given by the static field 
        /// <see cref="DefaultDepthModifier"/>.
        /// </summary>
        public float DepthModifier
        {
            get { return _depthModifier; }
            set
            {
                _depthModifier = value;
                IsUpdateNeeded = true;
            }
        }

        /// <summary>
        /// The default value of the property <see cref="WidthModifier"/>. The 
        /// value of this property is 0.
        /// </summary>
        public const float DefaultWidthModifier = 0;

        /// <summary>
        /// The default value of the property <see cref="HeightModifier"/>. The 
        /// value of this property is 0.
        /// </summary>
        public const float DefaultHeightModifier = 0;

        /// <summary>
        /// The default value of the property <see cref="DepthModifier"/>. The 
        /// value of this property is 0.
        /// </summary>
        public const float DefaultDepthModifier = 0;

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

        /// <summary>
        /// The <see cref="IShape"/>s contained within this 
        /// <see cref="ShapeCollection"/>.
        /// </summary>
        protected ICollection<IShape> Geometries
        {
            get { return _geometries; }
            set
            {
                if (_geometries != null)
                {
                    // unsubscribe from our previous geometries, if any
                    foreach (IShape volume2D in _geometries)
                        volume2D.TransformDirtied -= Geometry2DTransformDirtied;
                }

                _geometries = value;

                // subscribe to our new geometries, if any
                foreach (IShape volume2D in _geometries)
                    volume2D.TransformDirtied += Geometry2DTransformDirtied;

                if(_geometries.Count > 0)
                    IsUpdateNeeded = true;
            }
        }

        /// <summary>
        /// An event handler that is invoked when one of the 
        /// <see cref="IShape"/>s in the <see cref="Geometries"/> list has 
        /// had it's transform change. When one of those transforms change we 
        /// need to update this <see cref="ShapeCollection"/> 
        /// <see cref="Width"/>, <see cref="Height"/>, and 
        /// <see cref="ITransform.Position"/>.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the 
        /// event data.</param>
        protected void Geometry2DTransformDirtied(object sender, EventArgs e)
        {
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// The backing field to <see cref="Geometries"/>.
        /// </summary>
        ICollection<IShape> _geometries;

        /// <summary>
        /// The backing field to <see cref="Width"/>.
        /// </summary>
        float _width;

        /// <summary>
        /// The backing field to <see cref="Height"/>.
        /// </summary>
        float _height;

        /// <summary>
        /// The backing field to <see cref="Depth"/>.
        /// </summary>
        float _depth;

        /// <summary>
        /// The backing field to <see cref="WidthModifier"/>.
        /// </summary>
        float _widthModifier;

        /// <summary>
        /// The backing field to <see cref="HeightModifier"/>.
        /// </summary>
        float _heightModifier;

        /// <summary>
        /// The backing field to <see cref="DepthModifier"/>.
        /// </summary>
        float _depthModifier;
    }
}