using System;

namespace Engine.Core;

/// <summary>
/// Represents a range of values along a single axis.
/// </summary>
/// <param name="min">The minimum value of the projection.</param>
/// <param name="max">The maximum value of the projection.</param>
/// <remarks>
/// Initializes a new instance of the <see cref="Projection1D"/> struct with the specified minimum and maximum values.
/// </remarks>
[System.Diagnostics.DebuggerDisplay("Min: {Min}, Max: {Max}")]
public readonly struct Projection1D(float min, float max) : IEquatable<Projection1D>
{
    /// <summary>
    /// Gets the minimum value of the projection.
    /// </summary>
    public readonly float Min = min;

    /// <summary>
    /// Gets the maximum value of the projection.
    /// </summary>
    public readonly float Max = max;

    public static bool operator ==(Projection1D left, Projection1D right) => left.Min == right.Min && left.Max == right.Max;
    public static bool operator !=(Projection1D left, Projection1D right) => left.Min != right.Min || left.Max != right.Max;

    /// <summary>
    /// Checks if two projections overlap.
    /// </summary>
    /// <param name="left">The first projection to check.</param>
    /// <param name="right">The second projection to check.</param>
    /// <returns><see cref="true"/> if the projections overlap; otherwise, <see cref="false"/>.</returns>
    public static bool Overlaps(Projection1D left, Projection1D right) => Overlaps(left, right, out float _);

    /// <summary>
    /// Checks if two projections overlap and calculates the depth of the overlap.
    /// </summary>
    /// <param name="left">The first projection to check.</param>
    /// <param name="right">The second projection to check.</param>
    /// <param name="depth">The depth of the overlap, if any.</param>
    /// <returns><see cref="true"/> if the projections overlap; otherwise, <see cref="false"/>.</returns>
    public static bool Overlaps(Projection1D left, Projection1D right, out float depth)
    {
        // TODO Try to improve this
        bool rightMinInLeft = right.Min > left.Min && right.Min < left.Max;
        if (rightMinInLeft)
        {
            depth = left.Max - right.Min;
            return true;
        }

        bool rightMaxInLeft = right.Max < left.Max && right.Max > left.Min;
        if (rightMaxInLeft)
        {
            depth = left.Min - right.Max;
            return true;
        }

        bool leftMinInRight = left.Min > right.Min && left.Min < right.Max;
        if (leftMinInRight)
        {
            depth = right.Max - left.Min;
            return true;
        }

        bool leftMaxInRight = left.Max < right.Max && left.Max > right.Min;
        if (leftMaxInRight)
        {
            depth = right.Min - left.Max;
            return true;
        }

        depth = 0f;
        return false;
    }

    /// <summary>
    /// Checks if two <see cref="Projection1D"/>s are approximately equal within a specified epsilon range.
    /// </summary>
    /// <param name="left">The first <see cref="Projection1D"/>.</param>
    /// <param name="right">The second <see cref="Projection1D"/>.</param>
    /// <param name="epsilon">The epsilon range.</param>
    /// <returns><see cref="true"/> if the <see cref="Projection1D"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
    public static bool ApproximatelyEquals(Projection1D left, Projection1D right, float epsilon = float.Epsilon)
        => left.Min.ApproximatelyEquals(right.Min, epsilon) && left.Max.ApproximatelyEquals(right.Max, epsilon);

    /// <summary>
    /// Determines whether the specified object is equal to the current <see cref="Projection1D"/>.
    /// </summary>
    /// <param name="obj">The object to compare with the current <see cref="Projection1D"/>.</param>
    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Projection1D"/>; otherwise, <see cref="false"/>.</returns>
    public override bool Equals(object? obj) => obj is Projection1D projection1D && this == projection1D;
    public bool Equals(Projection1D other) => this == other;

    /// <summary>
    /// Generates a hash code for the <see cref="Projection1D"/>.
    /// </summary>
    /// <returns>A hash code for the <see cref="Projection1D"/>.</returns>
    public override int GetHashCode() => System.HashCode.Combine(Min, Max);

    /// <summary>
    /// Converts the <see cref="Projection1D"/> to its string representation.
    /// </summary>
    /// <returns>A string representation of the <see cref="Projection1D"/>.</returns>
    public override string ToString() => $"{nameof(Projection1D)}({Min}, {Max})";
}

/// <summary>
/// Provides extension methods for the <see cref="Projection1D"/> struct.
/// </summary>
public static class Projection1DExtensions
{
    /// <inheritdoc cref="Projection1D.Overlaps(Projection1D, Projection1D)" />
    public static bool Overlaps(this Projection1D left, Projection1D right) => Projection1D.Overlaps(left, right);

    /// <inheritdoc cref="Projection1D.Overlaps(Projection1D, Projection1D, out float)" />
    public static bool Overlaps(this Projection1D left, Projection1D right, out float depth) => Projection1D.Overlaps(left, right, out depth);

    /// <inheritdoc cref="Projection1D.ApproximatelyEquals(Projection1D, Projection1D, float)" />
    public static bool ApproximatelyEquals(this Projection1D left, Projection1D right, float epsilon = float.Epsilon) => Projection1D.ApproximatelyEquals(left, right, epsilon);
}