namespace GeometriCS
{
    /// <summary>
    /// Three-dimensional vector with double precision.
    /// </summary>
    public class Vector3d : ICloneable
    {
        /// <summary>
        /// Vector with 0 length.
        /// </summary>
        public static readonly Vector3d ZeroVector = new(0d, 0d, 0d);

        /// <summary>
        /// Unit vector following the X axis, or (1; 0; 0)
        /// </summary>
        public static readonly Vector3d XAxis = new(1d, 0d, 0d);

        /// <summary>
        /// Unit vector following the Y axis, or (0; 1; 0)
        /// </summary>
        public static readonly Vector3d YAxis = new(0d, 1d, 0d);

        /// <summary>
        /// Unit vector following the Z axis, or (0; 0; 1)
        /// </summary>
        public static readonly Vector3d ZAxis = new(0d, 1d, 1d);

        /// <summary>
        /// X component of the vector.
        /// </summary>
        public double X { get; set; }

        /// <summary>
        /// Y component of the vector.
        /// </summary>
        public double Y { get; set; }

        /// <summary>
        /// Z component of the vector.
        /// </summary>
        public double Z { get; set; }

        /// <summary>
        /// Length of the vector.
        /// </summary>
        public double Length
        {
            get
            {
                return Math.Sqrt(X * X + Y * Y + Z * Z);
            }
            set
            {
                // If desired length is 0, set the components to 0 manually.
                if (IsZero)
                {
                    X = 0;
                    Y = 0;
                    Z = 0;
                    return;
                }

                // New length divided by the old Length.
                // Or, the scalar we need to apply to the vector in order for it to reach the desired length.
                double scaleDelta = value / Length;

                // Scale the vector by the scalar delta.
                X *= scaleDelta;
                Y *= scaleDelta;
                Z *= scaleDelta;
            }
        }

        /// <summary>
        /// Is this a zero vecor?
        /// </summary>
        public bool IsZero => Utils.DoubleEquals(Length, 0);

        /// <summary>
        /// Is this a unit vector?
        /// </summary>
        public bool IsUnit => Utils.DoubleEquals(Length, 1);

        /// <summary>
        /// Normalized, or unit version of the vector.
        /// </summary>
        /// <remarks>Calling this method does not affect the source vector.</remarks>
        /// <returns>Normalized vector, or <c>(0; 0; 0)</c> if original is <c>(0; 0; 0)</c>.</returns>
        public Vector3d Normalized()
        {
            // If this is a zero vector, return a zero vector.
            if (IsZero)
            {
                return new Vector3d(0, 0, 0);
            }

            // Get the inverse of the length of the vector,
            // Or the scalar we need to apply to the vector in order for it to reach the desired length.
            double scaleDelta = 1 / Length;

            // Return this vector scaled to have its Length equal to 1
            return new Vector3d(X * scaleDelta, Y * scaleDelta, Z * scaleDelta);
        }

        /// <summary>
        /// Compute the cross product between this and another vector.
        /// </summary>
        /// <param name="other">Other vector.</param>
        /// <returns>The cross product of the two vectors.</returns>
        public Vector3d CrossProduct(Vector3d other)
        {
            return new Vector3d(
                Y * other.Z - Z * other.Y,
                Z * other.X - X * other.Z,
                X * other.Y - Y * other.X);
        }

        /// <summary>
        /// Compute the dot product between this and another vector.
        /// </summary>
        /// <param name="other">Other vector.</param>
        /// <returns>The dot product of the two vectors.</returns>
        public double DotProduct(Vector3d other)
        {
            return X * other.X + Y * other.Y + Z * other.Z;
        }

        /// <summary>
        /// Get the vector needed to get from the point at the end of this vector to the end of another vector.
        /// </summary>
        /// <param name="other">The vector to get to the end of.</param>
        /// <returns>Vector leading from the tip of this vector to the tip of the other vector.</returns>
        public Vector3d GetVectorTo(Vector3d other)
        {
            return new Vector3d(-X + other.Y, -Y + other.Y, -Z + other.Z);
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="x">X component of the vector.</param>
        /// <param name="x">X component of the vector.</param>
        /// <param name="z">Z component of the vector.</param>
        public Vector3d(double x, double y, double z)
        {
            X = x;
            Y = y;
            Z = z;
        }

        /// <summary>
        /// String representation of the vector.
        /// </summary>
        /// <returns>(X; Y; Z)</returns>
        public override string ToString()
        {
            return $"({X}; {Y}; {Z})";
        }

        /// <summary>
        /// Do the two objects represent the same vector?
        /// </summary>
        /// <param name="obj">Object to compare.</param>
        /// <returns><c>true</c> if the vectors are equal. Otherwise <c>false</c></returns>
        public override bool Equals(object? obj)
        {
            if (obj is Vector3d asVect)
            {
                return this == asVect;
            }
            else
            {
                return false;
            }
        }

        public override int GetHashCode()
        {
            return HashCode.Combine(X, Y, Z);
        }

        /// <summary>
        /// Deep copy the vector.
        /// </summary>
        /// <returns>Deep copy of the vector.</returns>
        public object Clone()
        {
            return new Vector3d(X, Y, Z);
        }

        /// <summary>
        /// Negation of the vector.
        /// </summary>
        /// <param name="vect">Vector to negate.</param>
        /// <returns>Negated vector.</returns>
        public static Vector3d operator -(Vector3d vect)
        {
            return new Vector3d(-vect.X, -vect.Y, -vect.Z);
        }

        /// <summary>
        /// Are the vectors equal?
        /// </summary>
        /// <param name="a">First vector.</param>
        /// <param name="b">Second vector.</param>
        /// <returns><c>true</c> if the vectors are equal. Otherwise <c>false</c></returns>
        public static bool operator ==(Vector3d a, Vector3d b)
        {
            return Utils.DoubleEquals(a.X, b.X) && Utils.DoubleEquals(a.Y, b.Y) && Utils.DoubleEquals(a.Z, b.Z);
        }

        /// <summary>
        /// Are the vectors different?
        /// </summary>
        /// <param name="a">First vector.</param>
        /// <param name="b">Second vector.</param>
        /// <returns><c>true</c> if the vectors are different. Otherwise <c>false</c></returns>
        public static bool operator !=(Vector3d a, Vector3d b)
        {
            return !(Utils.DoubleEquals(a.X, b.X) && Utils.DoubleEquals(a.Y, b.Y) && Utils.DoubleEquals(a.Z, b.Z));
        }

        /// <summary>
        /// Add the vectors together.
        /// </summary>
        /// <param name="a">First vector.</param>
        /// <param name="b">Second vector.</param>
        /// <returns>a + b</returns>
        public static Vector3d operator +(Vector3d a, Vector3d b)
        {
            return new Vector3d(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
        }

        /// <summary>
        /// Add the first vector and the negation of the second negation.
        /// </summary>
        /// <param name="a">First vector.</param>
        /// <param name="b">Second vector.</param>
        /// <returns>a + (-b)</returns>
        public static Vector3d operator -(Vector3d a, Vector3d b)
        {
            return new Vector3d(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
        }

        /// <summary>
        /// Scale the vector by the scalar.
        /// </summary>
        /// <param name="vect">Vector.</param>
        /// <param name="scalar">Scalar.</param>
        /// <returns>vect * scalar</returns>
        public static Vector3d operator *(Vector3d vect, double scalar)
        {
            return new Vector3d(vect.X * scalar, vect.Y * scalar, vect.Z * scalar);
        }

        /// <summary>
        /// Scale the vector by the inverse of the scalar.
        /// </summary>
        /// <param name="vect">Vector.</param>
        /// <param name="scalar">Scalar.</param>
        /// <returns>vect * (1 / scalar)</returns>
        public static Vector3d operator /(Vector3d vect, double scalar)
        {
            if (Utils.DoubleEquals(scalar, 0))
            {
                throw new DivideByZeroException("Cannot divide by zero, silly.");
            }
            return new Vector3d(vect.X / scalar, vect.Y / scalar, vect.Z / scalar);
        }
    }
}