using System;
using Chernobyl.Mathematics.Measures;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Values;

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// An <see cref="ITransform"/> that can position itself at the center of a
    /// cell within a regular grid. This positioning is done either by setting the 
    /// <see cref="ITransform.Position"/> property with a position within the 
    /// cell you want this <see cref="ITransform"/> to be in or by parenting
    /// this <see cref="ITransform"/> and allowing the ancestor 
    /// <see cref="ITransform"/> instances to do the work.
    /// </summary>
    public class CellTransform : MatrixTransform
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CellTransform"/> class.
        /// </summary>
        /// <param name="cellSize">The width (<see cref="Vector2.X"/>) and 
        /// height (<see cref="Vector2.Y"/>) of a single cell within the 2D graph 
        /// that this <see cref="ITransform"/> is moving through.</param>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the width
        /// (<see cref="Vector2.X"/>) or height (<see cref="Vector2.Y"/>) of the
        /// <paramref name="cellSize"/> parameter are 0 or negative.</exception>
        public CellTransform(Vector2 cellSize)
        {
            CellSize = cellSize;
        }

        /// <summary>
        /// The (X, Y) index location of this <see cref="ITransform"/> within a
        /// 2D graph.
        /// </summary>
        public RowColumn Cell
        {
            get
            {
                // Make sure this property and the position are in sync.
                Update();

                return _cell;
            }
        }

        /// <summary>
        /// The width (<see cref="Vector2.X"/>) and height (<see cref="Vector2.Y"/>)
        /// of a single cell within the 2D graph that this <see cref="ITransform"/>
        /// is moving through.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the width
        /// (<see cref="Vector2.X"/>) or height (<see cref="Vector2.Y"/>) of the
        /// value set on this property are 0 or negative.</exception>
        public Vector2 CellSize
        {
            get { return _cellSize; }
            private set
            {
                if(value.X <= 0)
                    throw new ArgumentOutOfRangeException("value", value.X, 
                        "The width of a cell cannot be less than or equal to 0.");

                if (value.Y <= 0)
                    throw new ArgumentOutOfRangeException("value", value.Y,
                        "The height of a cell cannot be less than or equal to 0.");

                _cellSize = value;
            }
        }

        /// <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);

            // Grab the position of either this matrix or the parent if we
            // have one so that we can calculate the row, column of the cell 
            // this ITransform is in.
            // here.
            Vector2 position = LocalMatrix.Translation.Xy;
            if (TransformParent != null)
                position = TransformParent.Position.Xy;

            // Update the RowColumn index of the Cell.
            _cell = RowColumn.FromPosition(CellSize, position);

            // Now calculate the position of the transform using the new
            // Cell position and the new position of the parent transform.
            // The position of this matrix should be at the center of the
            // Cell.
            position = _cell.GetCenter(CellSize);

            // If we have a parent we will need to make sure to take its
            // position into account as it will effect the position of
            // this transform. Essentially we are making sure the "position"
            // is relatively to the parent.
            if (TransformParent != null)
                position = position - TransformParent.Position.Xy;

            // Set the new position.
            Matrix4 local = LocalMatrix;
            local.Row3 = new Vector4(position.X, position.Y, local.Row3.Z, local.Row3.W);
            SetTransformation(ref local);
        }

        /// <summary>
        /// The backing field to <see cref="Cell"/>.
        /// </summary>
        RowColumn _cell;

        /// <summary>
        /// The backing field to <see cref="CellSize"/>.
        /// </summary>
        Vector2 _cellSize;
    }
}