using System;
using System.Collections.Generic;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Event;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Measures;

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// A class whose <see cref="ITransform"/> implementation is defined by another
    /// <see cref="ITransform"/> instance. This class allows for easier creation of
    /// <see cref="ITransform"/> types that need to use other <see cref="ITransform"/>
    /// implementations or for classes that need to dynamically alter their
    /// implementation at runtime. This is an implementation of the decorator
    /// pattern (http://en.wikipedia.org/wiki/Decorator_pattern).
    /// </summary>
    public abstract class TransformDecorator : ITransform
    {
        /// <summary>
        /// Translates the transform in the X axis by a specified amount.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        public void TranslateX(float x) { DecoratedTransform.TranslateX(x); }

        /// <summary>
        /// Translates the transform in the Y axis by a specified amount.
        /// </summary>
        /// <param name="y">The amount to translate in the Y.</param>
        public void TranslateY(float y) { DecoratedTransform.TranslateY(y); }

        /// <summary>
        /// Translates the transform in the Z axis by a specified amount.
        /// </summary>
        /// <param name="z">The amount to translate in the Z.</param>
        public void TranslateZ(float z) { DecoratedTransform.TranslateZ(z); }

        /// <summary>
        /// Translates the transform in the X and Y axis by a specified amount.
        /// This method is useful for transforms that exist in 2D world.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        /// <param name="y">The amount to translate in the Y.</param>
        public void Translate(float x, float y) { DecoratedTransform.Translate(x, y); }

        /// <summary>
        /// Translates the transform in the X and Y axis by a specified amount.
        /// This method is useful for transforms that exist in 2D world.
        /// </summary>
        /// <param name="amount">The amount to translate in the X and Y axis.</param>
        public void Translate(Vector2 amount) { DecoratedTransform.Translate(amount); }

        /// <summary>
        /// Translates the transform in the X axis, Y axis
        /// and Z axis by specified amounts.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        /// <param name="y">The amount to translate in the Y.</param>
        /// <param name="z">The amount to translate in the Z.</param>
        public void Translate(float x, float y, float z) { DecoratedTransform.Translate(x, y, z); }

        /// <summary>
        /// Translates the transform in the X axis, Y axis and Z axis by
        /// specified amounts.
        /// </summary>
        /// <param name="amount">The amount to translate the transform in each
        /// of the three axis where Vector3.X is the X axis translation amount,
        /// Vector3.Y is the Y axis translation amount, and Vector3.Z is the
        /// Z axis translation amount.</param>
        public void Translate(Vector3 amount) { DecoratedTransform.Translate(amount); }

        /// <summary>
        /// Rotates this transform around a vector by a specified amount.
        /// </summary>
        /// <param name="vectorToRotateAround">The vector to rotate around.</param>
        /// <param name="radian">The amount to rotate around the vector.</param>
        public void Rotate(Vector3 vectorToRotateAround, Radian radian) { DecoratedTransform.Rotate(vectorToRotateAround, radian); }

        /// <summary>
        /// Rotates this transform about the X axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public void Pitch(Radian amount) { DecoratedTransform.Pitch(amount); }

        /// <summary>
        /// Rotates this transform about the Y axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public void Yaw(Radian amount) { DecoratedTransform.Yaw(amount); }

        /// <summary>
        /// Rotates this transform about the Z axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public void Roll(Radian amount) { DecoratedTransform.Roll(amount); }

        /// <summary>
        /// Scales the transform along the X axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the X axis.</param>
        public void ScaleX(float amount) { DecoratedTransform.ScaleX(amount); }

        /// <summary>
        /// Scales the transform in the Y axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Y axis.</param>
        public void ScaleY(float amount) { DecoratedTransform.ScaleY(amount); }

        /// <summary>
        /// Scales the transform in the Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Z axis.</param>
        public void ScaleZ(float amount) { DecoratedTransform.ScaleZ(amount); }

        /// <summary>
        /// Scales the transform uniformly over the X, Y, and Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in all axis.</param>
        public void Scale(float amount) { DecoratedTransform.Scale(amount); }

        /// <summary>
        /// Scales the transform in the X and Y axis. This is useful if the
        /// transform exists in a 2D world.
        /// </summary>
        /// <param name="x">The amount to scale in the X axis.</param>
        /// <param name="y">The amount to scale in the Y axis.</param>
        public void Scale(float x, float y) { DecoratedTransform.Scale(x, y); }

        /// <summary>
        /// Scales the transform in the X and Y axis. This is useful if the
        /// transform exists in a 2D world.
        /// </summary>
        /// <param name="amount">The amount to scale in the X and Y axis.</param>
        public void Scale(Vector2 amount) { DecoratedTransform.Scale(amount); }

        /// <summary>
        /// Scales the transform uniformly over the X, Y, and Z axis.
        /// </summary>
        /// <param name="x">The amount to scale in the X axis.</param>
        /// <param name="y">The amount to scale in the Y axis.</param>
        /// <param name="z">The amount to scale in the Z axis.</param>
        public void Scale(float x, float y, float z) { DecoratedTransform.Scale(x, y, z); }

        /// <summary>
        /// Scales the transform uniformly over the X, Y, and Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in each axis where
        /// Vector3.X is the amount to scale in the X axis, Vector3.Y is the
        /// amount to scale in the Y axis, Vector3.Z is the amount to scale in
        /// the Z axis.</param>
        public void Scale(Vector3 amount) { DecoratedTransform.Scale(amount); }

        /// <summary>
        /// Sets the internal local transformation to the matrix passed in.
        /// </summary>
        /// <param name="matrix">The matrix to set the internal local
        /// transformation to.</param>
        public void SetTransformation(ref Matrix4 matrix) { DecoratedTransform.SetTransformation(ref matrix); }

        /// <inheritdoc />
        public void Dispose() => Transform.SeparateParentChild(TransformParent, this);

        /// <summary>
        /// An event that is raised when the transform has been "dirtied" or
        /// when the position, orientation, and/or scale of the transform has
        /// been changed either due to an ancestor being changed or due to the
        /// transform itself being changed. This event will only be raised once
        /// when the transform is changed, subsequent changes to the transform
        /// or it's ancestors will not cause the event to be raised. If the
        /// transform is cleaned (typically done when the <see cref="WorldMatrix"/>
        /// is accessed) and then dirtied again, the event will be raised. This
        /// event will be fired before children transforms are notified of the
        /// change to the transform or it's ancestors (usually through the
        /// child's <see cref="IsUpdateNeeded"/> flag).
        /// </summary>
        public event EventHandler TransformDirtied
        {
            add { DecoratedTransform.TransformDirtied += value; }
            remove { DecoratedTransform.TransformDirtied -= value; }
        }

        /// <summary>
        /// The parent to this transform. This property will
        /// be null if this is the root of the hierarchy.
        /// </summary>
        public virtual ITransform TransformParent { get { return DecoratedTransform.TransformParent; } set { DecoratedTransform.TransformParent = value; } }

        /// <summary>
        /// The children of this transform who's
        /// position, orientation, scale, etc., are
        /// effected or offset by this transform.
        /// </summary>
        public virtual IList<ITransform> TransformChildren { get { return DecoratedTransform.TransformChildren; } }

        /// <summary>
        /// This transforms position in the world. This property returns the
        /// World position (i.e. the position from <see cref="WorldMatrix"/>) but
        /// sets the Local position (i.e. the position from <see cref="LocalMatrix"/>.
        /// </summary>
        public Vector3 Position
        {
            get { return DecoratedTransform.Position; }
            set { DecoratedTransform.Position = value; }
        }

        /// <summary>
        /// The up vector of this transform in the world, which is also the +Y
        /// vector or <see cref="Matrix4.Column1"/>.
        /// </summary>
        public Vector3 Up { get { return DecoratedTransform.Up; } }

        /// <summary>
        /// The vector that points straight ahead (in the world) for this
        /// transform, which is also the -Z vector or negative
        /// <see cref="Matrix4.Column2"/>.
        /// </summary>
        public Vector3 Forward { get { return DecoratedTransform.Forward; } }

        /// <summary>
        /// The vector that points to this transform's right in the world, which
        /// is also the +X vector or <see cref="Matrix4.Column0"/>.
        /// </summary>
        public Vector3 Right { get { return DecoratedTransform.Right; } }

        /// <summary>
        /// The amount of scale in the world X axis of the transform.
        /// </summary>
        public float XScale { get { return DecoratedTransform.XScale; } }

        /// <summary>
        /// The amount of scale in the world Y axis of the transform.
        /// </summary>
        public float YScale { get { return DecoratedTransform.YScale; } }

        /// <summary>
        /// The amount of scale in the world Z axis of the transform.
        /// </summary>
        public float ZScale { get { return DecoratedTransform.ZScale; } }

        /// <summary>
        /// Gets/sets this transforms local matrix. The local matrix
        /// is the matrix that has been "untouched" by the parents,
        /// grandparents, etc., of this transform. In other words,
        /// it is not relative to any other transform.
        /// </summary>
        public virtual Matrix4 LocalMatrix { get { return DecoratedTransform.LocalMatrix; } }

        /// <summary>
        /// Gets/sets this transform's world matrix. The world matrix
        /// is the position and orientation relative to the parent of
        /// this transform.
        /// </summary>
        public virtual Matrix4 WorldMatrix { get { return DecoratedTransform.WorldMatrix; } }

        /// <summary>
        /// True if an update to this transform's world matrix is
        /// needed, false if otherwise. A transform will need to be
        /// updated if it's local matrix or an ancestors local matrix
        /// is updated.
        /// </summary>
        public bool IsUpdateNeeded { get { return DecoratedTransform.IsUpdateNeeded; } set { DecoratedTransform.IsUpdateNeeded = value; } }

        /// <summary>
        /// The instance being extended. Setting on instance on this property
        /// will cause that instance to be extended. If a previous instance was
        /// already being extended, then this extension will detach itself from
        /// that instance (stop extending it) and attach itself to the new
        /// instance (begin extending it). If null is set on this property then
        /// the previous instance will being extended will no longer be extended
        /// (if applicable). Note to implementors: it is highly recommended you
        /// store the extended instance in either a
        /// <see cref="Chernobyl.WeakReference{ExtendedType}"/> or a
        /// <see cref="System.WeakReference"/> to allow the extended instance to
        /// be properly garbage collected.
        /// </summary>
        public virtual ITransform Extended
        {
            get { return DecoratedTransform.Extended; }
            set { DecoratedTransform.Extended = value; }
        }

        /// <summary>
        /// An event that is raised right after the instance being extended has
        /// changed (or whenever the <see cref="Extended"/> property has been
        /// changed).
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<ITransform>> ExtendedChanged
        {
            add { DecoratedTransform.ExtendedChanged += value; }
            remove { DecoratedTransform.ExtendedChanged -= value; }
        }

        /// <summary>
        /// Overrides <see cref="INamed"/>.
        /// </summary>
        public string Name { get { return DecoratedTransform.Name; } set { DecoratedTransform.Name = value; } }

        /// <summary>
        /// The list of <see cref="IExtension"/> or
        /// <see cref="IExtension{TExtended}"/> instances that have
        /// attached themselves to this instance.
        /// </summary>
        /// <value>The extensions of this instance.</value>
        public IList<IExtension> Extensions { get { return DecoratedTransform.Extensions; } }

        /// <summary>
        /// The <see cref="ITransform"/> that provides this
        /// <see cref="ITransform"/>s capabilities.
        /// </summary>
        protected abstract ITransform DecoratedTransform { get; }
    }
}