using System;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Measures;
using Chernobyl.Measures.Speed;
using Chernobyl.Measures.Time;

namespace Chernobyl.Mathematics.Measures
{
    /// <summary>
    /// The speed at which an object is moving and in what direction.
    /// </summary>
    public struct Velocity : IMeasurement<Vector3d>, IEquatable<Velocity>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Velocity"/> struct.
        /// </summary>
        /// <param name="direction">The direction in which an object is moving.
        /// This <see cref="Vector3"/> will be normalized by this type.</param>
        /// <param name="speed">The speed component of the velocity in metres
        /// per second.</param>
        public Velocity(Vector3d direction, Metres<Seconds> speed)
            : this()
        {
            direction.Normalize();
            Value = direction * speed.Value;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Velocity"/> struct.
        /// </summary>
        /// <param name="directionAndSpeed">The direction and speed of the 
        /// velocity expressed as a <see cref="Vector3"/> where the normalized
        /// vector is the direction and the vector's length is the speed in 
        /// meters per second.</param>
        public Velocity(Vector3d directionAndSpeed)
            : this()
        {
            Value = directionAndSpeed;
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="Velocity"/> to 
        /// <see cref="Vector3d"/>.
        /// </summary>
        /// <param name="velocity">The velocity to convert.</param>
        /// <returns>The <see cref="Velocity"/> as a raw <see cref="Vector3"/>.</returns>
        public static implicit operator Vector3d(Velocity velocity)
        {
            return velocity.Value;
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="Vector3"/> to 
        /// <see cref="Velocity"/>.
        /// </summary>
        /// <param name="vector">The <see cref="Vector3"/> to convert.</param>
        /// <returns>The <see cref="Vector3"/> as a <see cref="Velocity"/>.</returns>
        public static explicit operator Velocity(Vector3d vector)
        {
            return new Velocity(vector);
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="Velocity"/> to 
        /// <see cref="Metres{Seconds}"/>.
        /// </summary>
        /// <param name="velocity">The velocity to convert.</param>
        /// <returns>The <see cref="Velocity"/> in the form of speed.</returns>
        public static explicit operator Metres<Seconds>(Velocity velocity)
        {
            return velocity.Speed;
        }

        /// <summary>
        /// Adds two <see cref="Velocity"/> instances together.
        /// </summary>
        /// <param name="left">The left side of the operand.</param>
        /// <param name="right">The right side of the operand.</param>
        /// <returns>The result of the addition.</returns>
        public static Velocity operator +(Velocity left, Velocity right)
        {
            return new Velocity(left.Value + right.Value);
        }

        /// <summary>
        /// Subtracts two <see cref="Velocity"/> instances from each other.
        /// </summary>
        /// <param name="left">The left side of the operand.</param>
        /// <param name="right">The right side of the operand.</param>
        /// <returns>The result of the negation.</returns>
        public static Velocity operator -(Velocity left, Velocity right)
        {
            return new Velocity(left.Value - right.Value);
        }

        /// <summary>
        /// Negates a <see cref="Velocity"/>.
        /// </summary>
        /// <param name="velocity">The <see cref="Velocity"/> to be negated.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Velocity operator -(Velocity velocity)
        {
            return new Velocity(-velocity.Value);
        }

        /// <summary>
        /// Multiplies a <see cref="Velocity"/> by a scalar.
        /// </summary>
        /// <param name="velocity">The left side of the operand.</param>
        /// <param name="time">The right side of the operand.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Velocity operator *(Velocity velocity, Metres<Seconds> time)
        {
            return new Velocity(velocity.Value * time.Value);
        }

        /// <summary>
        /// Multiplies a <see cref="Velocity"/> by a scalar.
        /// </summary>
        /// <param name="time">The left side of the operand.</param>
        /// <param name="velocity">The right side of the operand.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Velocity operator *(Metres<Seconds> time, Velocity velocity)
        {
            return new Velocity(time.Value * velocity.Value);
        }

        /// <summary>
        /// Divides a <see cref="Velocity"/> by a scalar.
        /// </summary>
        /// <param name="velocity">The left side of the operand.</param>
        /// <param name="time">The right side of the operand.</param>
        /// <returns>The result of the division.</returns>
        public static Velocity operator /(Velocity velocity, Metres<Seconds> time)
        {
            return new Velocity(velocity.Value * time.Value);
        }

        /// <summary>
        /// Checks if two <see cref="Velocity" /> instances are equal.
        /// </summary>
        /// <param name="left">The left side of the operand.</param>
        /// <param name="right">The right side of the operand.</param>
        /// <returns>True if they are equal, false if otherwise.</returns>
        public static bool operator ==(Velocity left, Velocity right)
        {
            return left.Equals(right);
        }

        /// <summary>
        /// Checks if two <see cref="Velocity" /> instances are not equal.
        /// </summary>
        /// <param name="left">The left side of the operand.</param>
        /// <param name="right">The right side of the operand.</param>
        /// <returns>True if they are not equal, false if otherwise.</returns>
        public static bool operator !=(Velocity left, Velocity right)
        {
            return !left.Equals(right);
        }

        /// <summary>
        /// Gets the hash code of the <see cref="Velocity"/>.
        /// </summary>
        /// <returns>The hash code of the <see cref="Velocity"/>.</returns>
        public override int GetHashCode()
        {
            return Value.GetHashCode();
        }

        /// <summary>
        /// Indicates whether the current object is equal to another object of 
        /// the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>True if the current object is equal to the 
        /// <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        public bool Equals(Velocity other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Checks this <see cref="Velocity"/> for equality with object passed in.
        /// </summary>
        /// <param name="obj">The object to compare to.</param>
        /// <returns>True if the object is equal to this <see cref="Velocity"/>,
        /// false if otherwise.</returns>
        public override bool Equals(object obj)
        {
            return (obj is Velocity && Equals((Velocity)obj));
        }

        /// <summary>
        /// Returns a <see cref="String"/> that represents this instance. For
        /// example, a velocity of (2.4, 22.4, 55.9) will be returned as 
        /// "(0.0398215899277352, 0.371668172658861, 0.927511198733498) at 
        /// 60.2688140869141 m/s".
        /// </summary>
        /// <returns>A <see cref="String"/> that represents this instance.</returns>
        public override string ToString()
        {
            return Direction + " at " + Speed;
        }

        /// <summary>
        /// The direction in which an object is moving as a normalized (unit)
        /// vector.
        /// </summary>
        public Vector3d Direction
        {
            get
            {
                Vector3d result = Value;
                result.Normalize();
                return result;
            }
        }

        /// <summary>
        /// The speed component of the velocity in metres per second.
        /// </summary>
        public Metres<Seconds> Speed { get { return (Metres<Seconds>)Value.Length; } }

        /// <summary>
        /// The raw value of the velocity as a <see cref="Vector3d"/>.
        /// </summary>
        public Vector3d Value { get; private set; }
    }
}