using UnityEngine;

namespace Flexalon
{
    /// <summary> Common math help functions. </summary>
    public static class Math
    {
        public static readonly float MaxValue = 999999f;
        public static readonly Vector3 MaxVector = new Vector3(MaxValue, MaxValue, MaxValue);

        /// <summary> Returns the opposite direction. </summary>
        /// <param name="direction"> The direction to get the opposite of. </param>
        /// <returns> The opposite direction. </returns>
        public static Direction GetOppositeDirection(Direction direction)
        {
            switch (direction)
            {
                case Direction.PositiveX: return Direction.NegativeX;
                case Direction.NegativeX: return Direction.PositiveX;
                case Direction.PositiveY: return Direction.NegativeY;
                case Direction.NegativeY: return Direction.PositiveY;
                case Direction.PositiveZ: return Direction.NegativeZ;
                case Direction.NegativeZ: return Direction.PositiveZ;
                default: return Direction.PositiveX;
            }
        }

        /// <summary> Returns the opposite direction. </summary>
        /// <param name="direction"> The direction to get the opposite of. </param>
        /// <returns> The opposite direction. </returns>
        public static Direction GetOppositeDirection(int direction)
        {
            return GetOppositeDirection((Direction)direction);
        }

        /// <summary> Returns the axis of a direction. </summary>
        /// <param name="direction"> The direction to get the axis of. </param>
        /// <returns> The axis of the direction. </returns>
        public static Axis GetAxisFromDirection(Direction direction)
        {
            switch (direction)
            {
                case Direction.PositiveX: return Axis.X;
                case Direction.NegativeX: return Axis.X;
                case Direction.PositiveY: return Axis.Y;
                case Direction.NegativeY: return Axis.Y;
                case Direction.PositiveZ: return Axis.Z;
                case Direction.NegativeZ: return Axis.Z;
                default: return Axis.X;
            }
        }

        /// <summary> Returns the axis of a direction. </summary>
        /// <param name="direction"> The direction to get the axis of. </param>
        /// <returns> The axis of the direction. </returns>
        public static Axis GetAxisFromDirection(int direction)
        {
            return GetAxisFromDirection((Direction)direction);
        }

        /// <summary> Returns the positive and negative directions of an axis. </summary>
        /// <param name="axis"> The axis to get the directions of. </param>
        /// <returns> The positive and negative directions of the axis. </returns>
        public static (Direction, Direction) GetDirectionsFromAxis(Axis axis)
        {
            switch (axis)
            {
                case Axis.X: return (Direction.PositiveX, Direction.NegativeX);
                case Axis.Y: return (Direction.PositiveY, Direction.NegativeY);
                case Axis.Z: return (Direction.PositiveZ, Direction.NegativeZ);
                default: return (Direction.PositiveX, Direction.NegativeX);
            }
        }

        /// <summary> Returns the positive and negative directions of an axis. </summary>
        /// <param name="axis"> The axis to get the directions of. </param>
        /// <returns> The positive and negative directions of the axis. </returns>
        public static (Direction, Direction) GetDirectionsFromAxis(int axis)
        {
            return GetDirectionsFromAxis((Axis)axis);
        }

        /// <summary> Returns the positive direction of an axis. </summary>
        /// <param name="axis"> The axis to get the direction of. </param>
        /// <returns> The positive direction of the axis. </returns>
        public static float GetPositiveFromDirection(Direction direction)
        {
            switch (direction)
            {
                case Direction.PositiveX:
                case Direction.PositiveY:
                case Direction.PositiveZ:
                    return 1;
                default:
                    return -1;
            }
        }

        /// <summary> Returns the positive direction of an axis. </summary>
        /// <param name="axis"> The axis to get the direction of. </param>
        /// <returns> The positive direction of the axis. </returns>
        public static float GetPositiveFromDirection(int direction)
        {
            return GetPositiveFromDirection((Direction)direction);
        }

        /// <summary> Returns a unit vector in the direction. </summary>
        /// <param name="direction"> The direction to get the vector of. </param>
        /// <returns> A unit vector in the direction. </returns>
        public static Vector3 GetVectorFromDirection(Direction direction)
        {
            switch (direction)
            {
                case Direction.PositiveX:
                    return Vector3.right;
                case Direction.PositiveY:
                    return Vector3.up;
                case Direction.PositiveZ:
                    return Vector3.forward;
                case Direction.NegativeX:
                    return Vector3.left;
                case Direction.NegativeY:
                    return Vector3.down;
                case Direction.NegativeZ:
                    return Vector3.back;
            }

            return Vector3.zero;
        }

        /// <summary> Returns a unit vector in the direction. </summary>
        /// <param name="direction"> The direction to get the vector of. </param>
        /// <returns> A unit vector in the direction. </returns>
        public static Vector3 GetVectorFromDirection(int direction)
        {
            return GetVectorFromDirection((Direction)direction);
        }

        /// <summary> Returns a unit vector in the positive direction of axis. </summary>
        /// <param name="axis"> The axis to get the vector of. </param>
        /// <returns> A unit vector in the axis. </returns>
        public static Vector3 GetVectorFromAxis(Axis axis)
        {
            switch (axis)
            {
                case Axis.X:
                    return Vector3.right;
                case Axis.Y:
                    return Vector3.up;
                case Axis.Z:
                    return Vector3.forward;
            }

            return Vector3.zero;
        }

        /// <summary> Returns a unit vector in the positive direction of axis. </summary>
        /// <param name="axis"> The axis to get the vector of. </param>
        /// <returns> A unit vector in the axis. </returns>
        public static Vector3 GetVectorFromAxis(int axis)
        {
            return GetVectorFromAxis((Axis)axis);
        }

        /// <summary> Returns the other two axes. </summary>
        /// <param name="axis"> The axis to get the other two axes of. </param>
        /// <returns> The other two axes. </returns>
        public static (Axis, Axis) GetOtherAxes(Axis axis)
        {
            switch (axis)
            {
                case Axis.X: return (Axis.Y, Axis.Z);
                case Axis.Y: return (Axis.X, Axis.Z);
                default: return (Axis.X, Axis.Y);
            }
        }

        /// <summary> Returns the other two axes. </summary>
        /// <param name="axis"> The axis to get the other two axes of. </param>
        /// <returns> The other two axes. </returns>
        public static (int, int) GetOtherAxes(int axis)
        {
            var other = GetOtherAxes((Axis)axis);
            return ((int)other.Item1, (int)other.Item2);
        }

        /// <summary> Given two axes, returns the third axis. </summary>
        /// <param name="axis1"> The first axis. </param>
        /// <param name="axis2"> The second axis. </param>
        /// <returns> The third axis. </returns>
        public static Axis GetThirdAxis(Axis axis1, Axis axis2)
        {
            var otherAxes = GetOtherAxes(axis1);
            return (otherAxes.Item1 == axis2) ? otherAxes.Item2 : otherAxes.Item1;
        }

        /// <summary> Given two axes, returns the third axis. </summary>
        /// <param name="axis1"> The first axis. </param>
        /// <param name="axis2"> The second axis. </param>
        /// <returns> The third axis. </returns>
        public static int GetThirdAxis(int axis1, int axis2)
        {
            return (int) GetThirdAxis((Axis)axis1, (Axis)axis2);
        }

        /// <summary> Returns the axes of a plane. </summary>
        /// <param name="plane"> The plane to get the axes of. </param>
        /// <returns> The axes of the plane. </returns>
        public static (Axis, Axis) GetPlaneAxes(Plane plane)
        {
            switch (plane)
            {
                case Plane.XY: return (Axis.X, Axis.Y);
                case Plane.XZ: return (Axis.X, Axis.Z);
                default: return (Axis.Z, Axis.Y);
            }
        }

        /// <summary> Returns the axes of a plane. </summary>
        /// <param name="plane"> The plane to get the axes of. </param>
        /// <returns> The axes of the plane. </returns>
        public static (int, int) GetPlaneAxesInt(Plane plane)
        {
            var axes = GetPlaneAxes(plane);
            return ((int)axes.Item1, (int)axes.Item2);
        }

        /// <summary> Multiplies each component of two vectors. </summary>
        /// <param name="a"> The first vector. </param>
        /// <param name="b"> The second vector. </param>
        /// <returns> The multiplied vector. </returns>
        public static Vector3 Mul(Vector3 a, Vector3 b)
        {
            a.x *= b.x;
            a.y *= b.y;
            a.z *= b.z;
            return a;
        }

        /// <summary> Divides each component of two vectors. </summary>
        /// <param name="a"> The divided vector. </param>
        /// <param name="b"> The divisor vector. </param>
        /// <returns> The divided vector. </returns>
        public static Vector3 Div(Vector3 a, Vector3 b)
        {
            a.x /= b.x;
            a.y /= b.y;
            a.z /= b.z;
            return a;
        }

        /// <summary> Rotates a bounds around the origin and returns a new bounds
        /// that encapsulates all of the rotated corners. </summary>
        /// <param name="bounds"> The bounds to rotate. </param>
        /// <param name="rotation"> The rotation to rotate the bounds by. </param>
        /// <returns> The new bounds. </returns>
        public static Bounds RotateBounds(Bounds bounds, Quaternion rotation)
        {
            if (rotation == Quaternion.identity) return bounds;

            var rotatedCenter = rotation * bounds.center;
            var p1 = rotation * bounds.max;
            var p2 = rotation * new Vector3(bounds.max.x, bounds.max.y, bounds.min.z);
            var p3 = rotation * new Vector3(bounds.max.x, bounds.min.y, bounds.max.z);
            var p4 = rotation * new Vector3(bounds.max.x, bounds.min.y, bounds.min.z);
            var p5 = rotation * new Vector3(bounds.min.x, bounds.max.y, bounds.max.z);
            var p6 = rotation * new Vector3(bounds.min.x, bounds.max.y, bounds.min.z);
            var p7 = rotation * new Vector3(bounds.min.x, bounds.min.y, bounds.max.z);
            var p8 = rotation * bounds.min;

            var rotatedBounds = new Bounds(rotatedCenter, Vector3.zero);
            rotatedBounds.Encapsulate(p1);
            rotatedBounds.Encapsulate(p2);
            rotatedBounds.Encapsulate(p3);
            rotatedBounds.Encapsulate(p4);
            rotatedBounds.Encapsulate(p5);
            rotatedBounds.Encapsulate(p6);
            rotatedBounds.Encapsulate(p7);
            rotatedBounds.Encapsulate(p8);
            return rotatedBounds;
        }

        /// <summary> Creates rotated and scaled bounds at center. </summary>
        /// <param name="center"> The center of the bounds. </param>
        /// <param name="size"> The size of the bound before rotation. </param>
        /// <param name="rotation"> The rotation to apply to the size.  </param>
        public static Bounds CreateRotatedBounds(Vector3 center, Vector3 size, Quaternion rotation)
        {
            if (rotation == Quaternion.identity) return new Bounds(center, size);
            var bounds = RotateBounds(new Bounds(Vector3.zero, size), rotation);
            bounds.center = center;
            return bounds;
        }

        /// <summary> Scales a bounds by multiplying the center and size by 'scale'. </summary>
        /// <param name="bounds"> The bounds to scale. </param>
        /// <param name="scale"> The scale to scale the bounds by. </param>
        /// <returns> The scaled bounds. </returns>
        public static Bounds ScaleBounds(Bounds bounds, Vector3 scale)
        {
            bounds.center = Math.Mul(bounds.center, scale);
            bounds.size = Math.Mul(bounds.size, scale);
            return bounds;
        }

        /// <summary> Determines the aligned position in a size. </summary>
        /// <param name="size"> The size to align to. </param>
        /// <param name="align"> The alignment. </param>
        /// <returns> The aligned position. </returns>
        public static float Align(float size, Align align)
        {
            if (align == global::Flexalon.Align.Start)
            {
                return -size * 0.5f;
            }
            else if (align == global::Flexalon.Align.End)
            {
                return size * 0.5f;
            }

            return 0;
        }

        /// <summary> Determines the aligned position in a size for an axis. </summary>
        /// <param name="size"> The size to align to. </param>
        /// <param name="axis"> The axis to align to. </param>
        /// <param name="align"> The alignment. </param>
        /// <returns> The aligned position. </returns>
        public static float Align(Vector3 size, int axis, Align align)
        {
            return Align(size[axis], align);
        }

        /// <summary> Determines the aligned position in a size. </summary>
        /// <param name="size"> The size to align to. </param>
        /// <param name="horizontal"> The horizontal alignment. </param>
        /// <param name="vertical"> The vertical alignment. </param>
        /// <param name="depth"> The depth alignment. </param>
        /// <returns> The aligned position. </returns>
        public static Vector3 Align(Vector3 size, Align horizontal, Align vertical, Align depth)
        {
            return new Vector3(
                Align(size, 0, horizontal),
                Align(size, 1, vertical),
                Align(size, 2, depth));
        }

        /// <summary> Aligns a child size to a parent size. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="parentAlign"> The alignment of the parent. </param>
        /// <param name="childAlign"> The pivot of the child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static float Align(float childSize, float parentSize, Align parentAlign, Align childAlign)
        {
            return Align(parentSize, parentAlign) - Align(childSize, childAlign);
        }

        /// <summary> Aligns a child size to a parent size. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="align"> The alignment of the parent and child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static float Align(float childSize, float parentSize, Align align)
        {
            return Align(childSize, parentSize, align, align);
        }

        /// <summary> Aligns a child size to a parent size on an axis. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="axis"> The axis to align on. </param>
        /// <param name="align"> The alignment of the parent and child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static float Align(Vector3 childSize, Vector3 parentSize, int axis, Align align)
        {
            return Align(childSize[axis], parentSize[axis], align);
        }

        /// <summary> Aligns a child size to a parent size on an axis. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="axis"> The axis to align on. </param>
        /// <param name="align"> The alignment of the parent and child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static float Align(Vector3 childSize, Vector3 parentSize, Axis axis, Align align)
        {
            return Align(childSize, parentSize, (int)axis, align);
        }

        /// <summary> Aligns a child size to a parent size on an axis. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="axis"> The axis to align on. </param>
        /// <param name="parentAlign"> The alignment of the parent. </param>
        /// <param name="childAlign"> The pivot of the child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static float Align(Vector3 childSize, Vector3 parentSize, int axis, Align parentAlign, Align childAlign)
        {
            return Align(childSize[axis], parentSize[axis], parentAlign, childAlign);
        }

        /// <summary> Aligns a child size to a parent size on an axis. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="axis"> The axis to align on. </param>
        /// <param name="parentAlign"> The alignment of the parent. </param>
        /// <param name="childAlign"> The pivot of the child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static float Align(Vector3 childSize, Vector3 parentSize, Axis axis, Align parentAlign, Align childAlign)
        {
            return Align(childSize, parentSize, (int)axis, parentAlign, childAlign);
        }

        /// <summary> Aligns a child size to a parent size on all axes. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="parentHorizontal"> The horizontal alignment of the parent. </param>
        /// <param name="parentVertical"> The vertical alignment of the parent. </param>
        /// <param name="parentDepth"> The depth alignment of the parent. </param>
        /// <param name="childHorizontal"> The horizontal pivot of the child. </param>
        /// <param name="childVertical"> The vertical pivot of the child. </param>
        /// <param name="childDepth"> The depth pivot of the child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static Vector3 Align(Vector3 childSize, Vector3 parentSize, Align parentHorizontal, Align parentVertical, Align parentDepth, Align childHorizontal, Align childVertical, Align childDepth)
        {
            return Align(parentSize, parentHorizontal, parentVertical, parentDepth) -
                Align(childSize, childHorizontal, childVertical, childDepth);
        }

        /// <summary> Aligns a child size to a parent size on all axes. </summary>
        /// <param name="childSize"> The size of the child. </param>
        /// <param name="parentSize"> The size of the parent. </param>
        /// <param name="horizontal"> The horizontal alignment of the parent and child. </param>
        /// <param name="vertical"> The vertical alignment of the parent and child. </param>
        /// <param name="depth"> The depth alignment of the parent and child. </param>
        /// <returns> The aligned position of the child. </returns>
        public static Vector3 Align(Vector3 childSize, Vector3 parentSize, Align horizontal, Align vertical, Align depth)
        {
            return Align(parentSize, horizontal, vertical, depth) -
                Align(childSize, horizontal, vertical, depth);
        }

        /// <summary> Given the bounds of a component, creates a bounds for the node respecting the
        /// size types. Aspect ratio is preserved when possible. </summary>
        /// <param name="componentBounds"> The bounds of the component. </param>
        /// <param name="node"> The node to measure the bounds for. </param>
        /// <param name="size"> The size of the node. </param>
        /// <param name="min"> The minimum size of the node. </param>
        /// <param name="max"> The maximum size of the node. </param>
        /// <returns> The bounds of the node. </returns>
        public static Bounds MeasureComponentBounds(Bounds componentBounds, FlexalonNode node, Vector3 size, Vector3 min, Vector3 max)
        {
            componentBounds.size = Vector3.Max(componentBounds.size, Vector3.one * 0.0001f);
            var bounds = componentBounds;

            bool componentX = node.GetSizeType(Axis.X) == SizeType.Component;
            bool componentY = node.GetSizeType(Axis.Y) == SizeType.Component;
            bool componentZ = node.GetSizeType(Axis.Z) == SizeType.Component;

            var scale = (componentX && componentY && componentZ) ? 1 :
                Mathf.Min(
                    componentX ? float.MaxValue : size.x / bounds.size.x,
                    componentY ? float.MaxValue : size.y / bounds.size.y,
                    componentZ ? float.MaxValue : size.z / bounds.size.z);

            var maxScale = Mathf.Min(max.x / bounds.size.x, max.y / bounds.size.y, max.z / bounds.size.z);
            var minScale = Mathf.Max(min.x / bounds.size.x, min.y / bounds.size.y, min.z / bounds.size.z);
            var clampedScale = Mathf.Clamp(scale, minScale, maxScale);
            var clampedSize = Math.Clamp(size, min, max);

            bounds.size = new Vector3(
                componentX ? bounds.size.x * clampedScale : clampedSize.x,
                componentY ? bounds.size.y * clampedScale : clampedSize.y,
                componentZ ? bounds.size.z * clampedScale : clampedSize.z);

            bounds.center = Math.Mul(bounds.center, Math.Div(bounds.size, componentBounds.size));
            return bounds;
        }

        /// <summary> Given the bounds of a component, creates a bounds for the node respecting the
        /// size types. Aspect ratio is preserved for X and Y when possible. </summary>
        /// <param name="componentBounds"> The bounds of the component. </param>
        /// <param name="node"> The node to measure the bounds for. </param>
        /// <param name="size"> The size of the node. </param>
        /// <param name="min"> The minimum size of the node. </param>
        /// <param name="max"> The maximum size of the node. </param>
        /// <returns> The bounds of the node. </returns>
        public static Bounds MeasureComponentBounds2D(Bounds componentBounds, FlexalonNode node, Vector3 size, Vector3 min, Vector3 max)
        {
            componentBounds.size = Vector3.Max(componentBounds.size, Vector3.one * 0.0001f);
            var bounds = componentBounds;

            bool componentX = node.GetSizeType(Axis.X) == SizeType.Component;
            bool componentY = node.GetSizeType(Axis.Y) == SizeType.Component;

            var scale = (componentX && componentY) ? 1 :
                Mathf.Min(
                    componentX ? float.MaxValue : size.x / bounds.size.x,
                    componentY ? float.MaxValue : size.y / bounds.size.y);

            var maxScale = Mathf.Min(max.x / bounds.size.x, max.y / bounds.size.y);
            var minScale = Mathf.Max(min.x / bounds.size.x, min.y / bounds.size.y);
            var clampedScale = Mathf.Clamp(scale, minScale, maxScale);
            var clampedSize = Math.Clamp(size, min, max);

            bounds.size = new Vector3(
                componentX ? bounds.size.x * clampedScale : clampedSize.x,
                componentY ? bounds.size.y * clampedScale : clampedSize.y,
                clampedSize.z);

            bounds.center = Math.Mul(bounds.center, Math.Div(bounds.size, componentBounds.size));
            return bounds;
        }

        /// <summary> Applies absolute value of to each vector component. </summary>
        /// <param name="v"> The vector to apply absolute value to. </param>
        /// <returns> The vector with absolute value applied. </returns>
        public static Vector3 Abs(Vector3 v)
        {
            v.x = Mathf.Abs(v.x);
            v.y = Mathf.Abs(v.y);
            v.z = Mathf.Abs(v.z);
            return v;
        }

        /// <summary> Clamps value of to each vector component between min and max. </summary>
        /// <param name="v"> The vector to clamp. </param>
        /// <param name="min"> The minimum value. </param>
        /// <param name="max"> The maximum value. </param>
        /// <returns> The clamped vector. </returns>
        public static Vector3 Clamp(Vector3 v, Vector3 min, Vector3 max)
        {
            v.x = Mathf.Clamp(v.x, min.x, max.x);
            v.y = Mathf.Clamp(v.y, min.y, max.y);
            v.z = Mathf.Clamp(v.z, min.z, max.z);
            return v;
        }
    }
}