using System;
using System.Runtime.InteropServices;
using Chernobyl.Mathematics.Utility;

namespace Chernobyl.Mathematics.Vectors
{
    /// <summary>Represents a 2D vector using two integers.</summary>
    [Serializable]
    [StructLayout(LayoutKind.Sequential)]
    public struct Vector2Int : IEquatable<Vector2Int>
    {
        #region Fields

        /// <summary>
        /// The X component of the Vector2Int.
        /// </summary>
        public int X;

        /// <summary>
        /// The Y component of the Vector2Int.
        /// </summary>
        public int Y;

        #endregion

        #region Constructors

        /// <summary>
        /// Constructs a new Vector2Int.
        /// </summary>
        /// <param name="x">The x coordinate of the net Vector2Int.</param>
        /// <param name="y">The y coordinate of the net Vector2Int.</param>
        public Vector2Int(int x, int y)
        {
            X = x;
            Y = y;
        }

        #endregion

        #region Public Members

        #region Instance

        #region public void Add()

        /// <summary>Add the Vector passed as parameter to this instance.</summary>
        /// <param name="right">Right operand. This parameter is only read from.</param>
        public void Add(Vector2Int right)
        {
            X += right.X;
            Y += right.Y;
        }

        /// <summary>Add the Vector passed as parameter to this instance.</summary>
        /// <param name="right">Right operand. This parameter is only read from.</param>
        public void Add(ref Vector2Int right)
        {
            X += right.X;
            Y += right.Y;
        }

        #endregion public void Add()

        #region public void Sub()

        /// <summary>Subtract the Vector passed as parameter from this instance.</summary>
        /// <param name="right">Right operand. This parameter is only read from.</param>
        public void Sub(Vector2Int right)
        {
            X -= right.X;
            Y -= right.Y;
        }

        /// <summary>Subtract the Vector passed as parameter from this instance.</summary>
        /// <param name="right">Right operand. This parameter is only read from.</param>
        public void Sub(ref Vector2Int right)
        {
            X -= right.X;
            Y -= right.Y;
        }

        #endregion public void Sub()

        #region public void Mult()

        /// <summary>Multiply this instance by a scalar.</summary>
        /// <param name="f">Scalar operand.</param>
        public void Mult(int f)
        {
            X *= f;
            Y *= f;
        }

        #endregion public void Mult()

        #region public void Div()

        /// <summary>Divide this instance by a scalar.</summary>
        /// <param name="f">Scalar operand.</param>
        public void Div(int f)
        {
            X /= f;
            Y /= f;
        }

        #endregion public void Div()

        #region public int Length

        /// <summary>
        /// Gets the length (magnitude) of the vector.
        /// </summary>
        /// <see cref="LengthFast"/>
        /// <seealso cref="LengthSquared"/>
        public int Length => (int)Math.Sqrt(X * X + Y * Y);

        #endregion

        #region public int LengthFast

        /// <summary>
        /// Gets an approximation of the vector length (magnitude).
        /// </summary>
        /// <remarks>
        /// This property uses an approximation of the square root function to calculate vector
        /// magnitude, with an upper error bound of 0.001.
        /// </remarks>
        /// <see cref="Length"/>
        /// <seealso cref="LengthSquared"/>
        public int LengthFast => (int)(1.0f / Functions.InverseSqrtFast(X * X + Y * Y));

        #endregion

        #region public int LengthSquared

        /// <summary>
        /// Gets the square of the vector length (magnitude).
        /// </summary>
        /// <remarks>
        /// This property avoids the costly square root operation required by the Length property.
        /// This makes it more suitable for comparisons.
        /// </remarks>
        /// <see cref="Length"/>
        /// <seealso cref="LengthFast"/>
        public int LengthSquared => X * X + Y * Y;

        #endregion

        #region public Vector2Int PerpendicularRight

        /// <summary>
        /// Gets the perpendicular vector on the right side of this vector.
        /// </summary>
        public Vector2Int PerpendicularRight => new Vector2Int(Y, -X);

        #endregion

        #region public Vector2Int PerpendicularLeft

        /// <summary>
        /// Gets the perpendicular vector on the left side of this vector.
        /// </summary>
        public Vector2Int PerpendicularLeft => new Vector2Int(-Y, X);

        #endregion

        #region public void Normalize()

        /// <summary>
        /// Scales the Vector2Int to unit length.
        /// </summary>
        public void Normalize()
        {
            var length = Length;
            X /= length;
            Y /= length;
        }

        #endregion

        #region public void NormalizeFast()

        /// <summary>
        /// Scales the Vector2Int to approximately unit length.
        /// </summary>
        public void NormalizeFast()
        {
            var length = LengthFast;
            X /= length;
            Y /= length;
        }

        #endregion

        #region public void Scale()

        /// <summary>
        /// Scales the current Vector2Int by the given amounts.
        /// </summary>
        /// <param name="sx">The scale of the X component.</param>
        /// <param name="sy">The scale of the Y component.</param>
        public void Scale(int sx, int sy)
        {
            X = X * sx;
            Y = Y * sy;
        }

        /// <summary>Scales this instance by the given parameter.</summary>
        /// <param name="scale">The scaling of the individual components.</param>
        public void Scale(Vector2Int scale)
        {
            X *= scale.X;
            Y *= scale.Y;
        }

        /// <summary>Scales this instance by the given parameter.</summary>
        /// <param name="scale">The scaling of the individual components.</param>
        public void Scale(ref Vector2Int scale)
        {
            X *= scale.X;
            Y *= scale.Y;
        }

        #endregion public void Scale()

        #endregion

        #region Static

        #region Fields

        /// <summary>
        /// Defines a unit-length Vector2Int that points towards the X-axis.
        /// </summary>
        public static readonly Vector2Int UnitX = new Vector2Int(1, 0);

        /// <summary>
        /// Defines a unit-length Vector2Int that points towards the Y-axis.
        /// </summary>
        public static readonly Vector2Int UnitY = new Vector2Int(0, 1);

        /// <summary>
        /// Defines a zero-length Vector2Int.
        /// </summary>
        public static readonly Vector2Int Zero = new Vector2Int(0, 0);

        /// <summary>
        /// Defines an instance with all components set to 1.
        /// </summary>
        public static readonly Vector2Int One = new Vector2Int(1, 1);

        /// <summary>
        /// Defines the size of the Vector2Int struct in bytes.
        /// </summary>
        public static readonly int SizeInBytes = Marshal.SizeOf(new Vector2Int());

        #endregion

        #region Add

        /// <summary>
        /// Add two Vectors
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <returns>Result of addition</returns>
        public static Vector2Int Add(Vector2Int a, Vector2Int b)
        {
            a.X += b.X;
            a.Y += b.Y;
            return a;
        }

        /// <summary>
        /// Add two Vectors
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <param name="result">Result of addition</param>
        public static void Add(ref Vector2Int a, ref Vector2Int b, out Vector2Int result)
        {
            result.X = a.X + b.X;
            result.Y = a.Y + b.Y;
        }

        #endregion

        #region Sub

        /// <summary>
        /// Subtract one Vector from another
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <returns>Result of subtraction</returns>
        public static Vector2Int Sub(Vector2Int a, Vector2Int b)
        {
            a.X -= b.X;
            a.Y -= b.Y;
            return a;
        }

        /// <summary>
        /// Subtract one Vector from another
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <param name="result">Result of subtraction</param>
        public static void Sub(ref Vector2Int a, ref Vector2Int b, out Vector2Int result)
        {
            result.X = a.X - b.X;
            result.Y = a.Y - b.Y;
        }

        #endregion

        #region Mult

        /// <summary>
        /// Multiply a vector and a scalar
        /// </summary>
        /// <param name="a">Vector operand</param>
        /// <param name="f">Scalar operand</param>
        /// <returns>Result of the multiplication</returns>
        public static Vector2Int Mult(Vector2Int a, int f)
        {
            a.X *= f;
            a.Y *= f;
            return a;
        }

        /// <summary>
        /// Multiply a vector and a scalar
        /// </summary>
        /// <param name="a">Vector operand</param>
        /// <param name="f">Scalar operand</param>
        /// <param name="result">Result of the multiplication</param>
        public static void Mult(ref Vector2Int a, int f, out Vector2Int result)
        {
            result.X = a.X * f;
            result.Y = a.Y * f;
        }

        #endregion

        #region Div

        /// <summary>
        /// Divide a vector by a scalar
        /// </summary>
        /// <param name="a">Vector operand</param>
        /// <param name="f">Scalar operand</param>
        /// <returns>Result of the division</returns>
        public static Vector2Int Div(Vector2Int a, int f)
        {
            a.X /= f;
            a.Y /= f;
            return a;
        }

        /// <summary>
        /// Divide a vector by a scalar
        /// </summary>
        /// <param name="a">Vector operand</param>
        /// <param name="f">Scalar operand</param>
        /// <param name="result">Result of the division</param>
        public static void Div(ref Vector2Int a, int f, out Vector2Int result)
        {
            result.X = a.X / f;
            result.Y = a.Y / f;
        }

        #endregion

        #region ComponentMin

        /// <summary>
        /// Calculate the component-wise minimum of two vectors
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <returns>The component-wise minimum</returns>
        public static Vector2Int ComponentMin(Vector2Int a, Vector2Int b)
        {
            a.X = a.X < b.X ? a.X : b.X;
            a.Y = a.Y < b.Y ? a.Y : b.Y;
            return a;
        }

        /// <summary>
        /// Calculate the component-wise minimum of two vectors
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <param name="result">The component-wise minimum</param>
        public static void ComponentMin(ref Vector2Int a, ref Vector2Int b, out Vector2Int result)
        {
            result.X = a.X < b.X ? a.X : b.X;
            result.Y = a.Y < b.Y ? a.Y : b.Y;
        }

        #endregion

        #region ComponentMax

        /// <summary>
        /// Calculate the component-wise maximum of two vectors
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <returns>The component-wise maximum</returns>
        public static Vector2Int ComponentMax(Vector2Int a, Vector2Int b)
        {
            a.X = a.X > b.X ? a.X : b.X;
            a.Y = a.Y > b.Y ? a.Y : b.Y;
            return a;
        }

        /// <summary>
        /// Calculate the component-wise maximum of two vectors
        /// </summary>
        /// <param name="a">First operand</param>
        /// <param name="b">Second operand</param>
        /// <param name="result">The component-wise maximum</param>
        public static void ComponentMax(ref Vector2Int a, ref Vector2Int b, out Vector2Int result)
        {
            result.X = a.X > b.X ? a.X : b.X;
            result.Y = a.Y > b.Y ? a.Y : b.Y;
        }

        #endregion

        #region Min

        /// <summary>
        /// Returns the Vector3 with the minimum magnitude
        /// </summary>
        /// <param name="left">Left operand</param>
        /// <param name="right">Right operand</param>
        /// <returns>The minimum Vector3</returns>
        public static Vector2Int Min(Vector2Int left, Vector2Int right) =>
            left.LengthSquared < right.LengthSquared ? left : right;

        #endregion

        #region Max

        /// <summary>
        /// Returns the Vector3 with the minimum magnitude
        /// </summary>
        /// <param name="left">Left operand</param>
        /// <param name="right">Right operand</param>
        /// <returns>The minimum Vector3</returns>
        public static Vector2Int Max(Vector2Int left, Vector2Int right) =>
            left.LengthSquared >= right.LengthSquared ? left : right;

        #endregion

        #region Clamp

        /// <summary>
        /// Clamp a vector to the given minimum and maximum vectors
        /// </summary>
        /// <param name="vec">Input vector</param>
        /// <param name="min">Minimum vector</param>
        /// <param name="max">Maximum vector</param>
        /// <returns>The clamped vector</returns>
        public static Vector2Int Clamp(Vector2Int vec, Vector2Int min, Vector2Int max)
        {
            vec.X = vec.X < min.X ? min.X : vec.X > max.X ? max.X : vec.X;
            vec.Y = vec.Y < min.Y ? min.Y : vec.Y > max.Y ? max.Y : vec.Y;
            return vec;
        }

        /// <summary>
        /// Clamp a vector to the given minimum and maximum vectors
        /// </summary>
        /// <param name="vec">Input vector</param>
        /// <param name="min">Minimum vector</param>
        /// <param name="max">Maximum vector</param>
        /// <param name="result">The clamped vector</param>
        public static void Clamp(ref Vector2Int vec, ref Vector2Int min, ref Vector2Int max, out Vector2Int result)
        {
            result.X = vec.X < min.X ? min.X : vec.X > max.X ? max.X : vec.X;
            result.Y = vec.Y < min.Y ? min.Y : vec.Y > max.Y ? max.Y : vec.Y;
        }

        #endregion

        #region Dot

        /// <summary>
        /// Calculate the dot (scalar) product of two vectors
        /// </summary>
        /// <param name="left">First operand</param>
        /// <param name="right">Second operand</param>
        /// <returns>The dot product of the two inputs</returns>
        public static int Dot(Vector2Int left, Vector2Int right) => left.X * right.X + left.Y * right.Y;

        /// <summary>
        /// Calculate the dot (scalar) product of two vectors
        /// </summary>
        /// <param name="left">First operand</param>
        /// <param name="right">Second operand</param>
        /// <param name="result">The dot product of the two inputs</param>
        public static void Dot(ref Vector2Int left, ref Vector2Int right, out int result) =>
            result = left.X * right.X + left.Y * right.Y;

        #endregion

        #region Lerp

        /// <summary>
        /// Returns a new Vector that is the linear blend of the 2 given Vectors
        /// </summary>
        /// <param name="a">First input vector</param>
        /// <param name="b">Second input vector</param>
        /// <param name="blend">The blend factor. a when blend=0, b when blend=1.</param>
        /// <returns>a when blend=0, b when blend=1, and a linear combination otherwise</returns>
        public static Vector2Int Lerp(Vector2Int a, Vector2Int b, int blend)
        {
            a.X = blend * (b.X - a.X) + a.X;
            a.Y = blend * (b.Y - a.Y) + a.Y;
            return a;
        }

        /// <summary>
        /// Returns a new Vector that is the linear blend of the 2 given Vectors
        /// </summary>
        /// <param name="a">First input vector</param>
        /// <param name="b">Second input vector</param>
        /// <param name="blend">The blend factor. a when blend=0, b when blend=1.</param>
        /// <param name="result">a when blend=0, b when blend=1, and a linear combination otherwise</param>
        public static void Lerp(ref Vector2Int a, ref Vector2Int b, int blend, out Vector2Int result)
        {
            result.X = blend * (b.X - a.X) + a.X;
            result.Y = blend * (b.Y - a.Y) + a.Y;
        }

        #endregion

        #region Coordinates

        /// <summary>
        /// Get the coordinates for the cell above <c>this</c>.
        /// </summary>
        public Vector2Int GetNorthCoordinates() => this + new Vector2Int(0, 1);

        /// <summary>
        /// Get the coordinates for the cell above and to the right of <c>this</c>.
        /// </summary>
        public Vector2Int GetNorthEastCoordinates() => this + new Vector2Int(1, 1);

        /// <summary>
        /// Get the coordinates for the cell to the right of <c>this</c>.
        /// </summary>
        public Vector2Int GetEastCoordinates() => this + new Vector2Int(1, 0);

        /// <summary>
        /// Get the coordinates for the cell below and to the right <c>this</c>.
        /// </summary>
        public Vector2Int GetSouthEastCoordinates() => this + new Vector2Int(1, -1);

        /// <summary>
        /// Get the coordinates for the cell below <c>this</c>.
        /// </summary>
        public Vector2Int GetSouthCoordinates() => this + new Vector2Int(0, -1);

        /// <summary>
        /// Get the coordinates for the cell below and to the left <c>this</c>.
        /// </summary>
        public Vector2Int GetSouthWestCoordinates() => this + new Vector2Int(-1, -1);

        /// <summary>
        /// Get the coordinates for the cell to the left of <c>this</c>.
        /// </summary>
        public Vector2Int GetWestCoordinates() => this + new Vector2Int(-1, 0);

        /// <summary>
        /// Get the coordinates for the cell above and to the left of <c>this</c>.
        /// </summary>
        public Vector2Int GetNorthWestCoordinates() => this + new Vector2Int(-1, 1);

        #endregion

        #endregion

        #region Operators

        /// <summary>
        /// Adds two vectors 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 Vector2Int operator +(Vector2Int left, Vector2Int right)
        {
            left.X += right.X;
            left.Y += right.Y;
            return left;
        }

        /// <summary>
        /// Subtracts two vectors 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 Vector2Int operator -(Vector2Int left, Vector2Int right)
        {
            left.X -= right.X;
            left.Y -= right.Y;
            return left;
        }

        /// <summary>
        /// Negates a vector.
        /// </summary>
        /// <param name="vec">The vector to be negated.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Vector2Int operator -(Vector2Int vec)
        {
            vec.X = -vec.X;
            vec.Y = -vec.Y;
            return vec;
        }

        /// <summary>
        /// Multiplies a vector by a scalar.
        /// </summary>
        /// <param name="vec">The left side of the operand.</param>
        /// <param name="v">The right side of the operand.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Vector2Int operator *(Vector2Int vec, int v)
        {
            vec.X *= v;
            vec.Y *= v;
            return vec;
        }

        /// <summary>
        /// Multiplies a vector by a scalar.
        /// </summary>
        /// <param name="v">The left side of the operand.</param>
        /// <param name="vec">The right side of the operand.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Vector2Int operator *(int v, Vector2Int vec)
        {
            vec.X *= v;
            vec.Y *= v;
            return vec;
        }

        /// <summary>
        /// Divides a vector by a scalar.
        /// </summary>
        /// <param name="vec">The left side of the operand.</param>
        /// <param name="v">The right side of the operand.</param>
        /// <returns>The result of the multiplication.</returns>
        public static Vector2Int operator /(Vector2Int vec, int v)
        {
            vec.X /= v;
            vec.Y /= v;
            return vec;
        }

        /// <summary>
        /// Checks if two vectors 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 ==(Vector2Int left, Vector2Int right) => left.Equals(right);

        /// <summary>
        /// Checks if two vectors 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 !=(Vector2Int left, Vector2Int right) => !left.Equals(right);

        /// <summary>Converts a tuple to a Vector2Int.</summary>
        public static implicit operator Vector2Int((int X, int Y) t) => new Vector2Int(t.X, t.Y);

        /// <summary>Converts a tuple to a Vector2Int.</summary>
        public static implicit operator Vector2Int(Tuple<int, int> t) => new Vector2Int(t.Item1, t.Item2);

        /// <summary>Converts a Vector2Int to a tuple.</summary>
        public static implicit operator (int X, int Y) (Vector2Int v) => (v.X, v.Y);

        /// <summary>Converts a Vector2Int to a tuple.</summary>
        public static implicit operator Tuple<int, int>(Vector2Int v) => Tuple.Create(v.X, v.Y);

        /// <summary>Converts a Vector2Int to a Vector2.</summary>
        public static implicit operator Vector2(Vector2Int v) => new Vector2(v.X, v.Y);

        /// <summary>Converts a Vector2Int to a Vector3.</summary>
        public static implicit operator Vector3(Vector2Int v) => new Vector3(v.X, v.Y, 0);

        #endregion

        #region Overrides

        #region public override string ToString()

        /// <summary>
        /// Returns a System.String that represents the current Vector2Int.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return $"({X}, {Y})";
        }

        #endregion

        #region public override int GetHashCode()

        /// <summary>
        /// Returns the hashcode for this instance.
        /// </summary>
        /// <returns>A System.Int32 containing the unique hashcode for this instance.</returns>
        public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode();

        #endregion

        #region public override bool Equals(object obj)

        /// <summary>
        /// Indicates whether this instance and a specified object are equal.
        /// </summary>
        /// <param name="obj">The object to compare to.</param>
        /// <returns>True if the instances are equal; false otherwise.</returns>
        public override bool Equals(object obj)
        {
            return obj is Vector2Int vector && Equals(vector);
        }

        #endregion

        #endregion

        #endregion

        #region IEquatable<Vector2Int> Members

        /// <summary>Indicates whether the current vector is equal to another vector.</summary>
        /// <param name="other">A vector to compare with this vector.</param>
        /// <returns>true if the current vector is equal to the vector parameter; otherwise, false.</returns>
        public bool Equals(Vector2Int other) => X == other.X && Y == other.Y;

        #endregion
    }
}