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

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// Used to provide an interface to which objects can become an object that can scale, rotate,
    /// and/or translate. Disposing of an <see cref="ITransform"/> must separate it from its parent.
    /// </summary>
    public interface ITransform : IDisposable, IExtension<ITransform>, IExtendable
    {
        /// <summary>
        /// Translates the transform in the X axis by a specified amount.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        void TranslateX(float 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>
        void TranslateY(float 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>
        void TranslateZ(float 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>
        void Translate(float x, float 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>
        void Translate(Vector2 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>
        void Translate(float x, float y, float 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>
        void Translate(Vector3 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,
        /// in radians.</param>
        void Rotate(Vector3 vectorToRotateAround, Radian radian);

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

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

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

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

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

        /// <summary>
        /// Scales the transform in the Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Z axis.</param>
        void ScaleZ(float 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>
        void Scale(float 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>
        void Scale(float x, float 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>
        void Scale(Vector2 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>
        void Scale(float x, float y, float 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>
        void Scale(Vector3 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>
        void SetTransformation(ref Matrix4 matrix);

        /// <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>
        event EventHandler TransformDirtied;

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

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

        /// <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>
        Vector3 Position { get; set; }

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

        /// <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>
        Vector3 Forward { get; }

        /// <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>
        Vector3 Right { get; }

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

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

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

        /// <summary>
        /// Retrieves 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>
        Matrix4 LocalMatrix { get; }

        /// <summary>
        /// Retrieves this transform's world matrix. The world matrix
        /// is the position and orientation relative to the parent of
        /// this transform.
        /// </summary>
        Matrix4 WorldMatrix { get; }

        /// <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>
        bool IsUpdateNeeded { get; set; }
    }

    /// <summary>
    /// An enum to define the axis of a transform (i.e. the X axis, Y axis,
    /// Z axis). This enum is used by some code when it needs to allow the user
    /// to specify certain axis for some operation.
    /// </summary>
    [Flags]
    public enum Axis
    {
        /// <summary>
        /// None of the axis.
        /// </summary>
        None = 0,

        /// <summary>
        /// The X axis of a transform.
        /// </summary>
        X = 1,

        /// <summary>
        /// The Y axis of a transform.
        /// </summary>
        Y = 2,

        /// <summary>
        /// The Z axis of a transform.
        /// </summary>
        Z = 4,

        /// <summary>
        /// All axis' of a transform
        /// </summary>
        All = X | Y | Z
    }
}