#pragma once

#include <J3ML/LinearAlgebra/Vector2.h>

namespace J3ML::Geometry
{
    using LinearAlgebra::Vector2;
    // CaveGame AABB
    class AABB2D
    {
    public:

        Vector2 minPoint;
        Vector2 maxPoint;
        AABB2D() {}
        AABB2D(const Vector2& min, const Vector2& max):
        minPoint(min), maxPoint(max)
        {}

        float Width() const { return maxPoint.x - minPoint.x;  }
        float Height() const { return maxPoint.y - minPoint.y; }

        float DistanceSq(const Vector2& pt) const
        {
            Vector2 cp = pt.Clamp(minPoint, maxPoint);
            return cp.DistanceSq(pt);
        }

        void SetNegativeInfinity();

        void Enclose(const Vector2& point)
        {
            minPoint = Vector2::Min(minPoint, point);
            maxPoint = Vector2::Max(maxPoint, point);
        }

        bool Intersects(const AABB2D& rhs) const
        {
            return maxPoint.x >= rhs.minPoint.x &&
                   maxPoint.y >= rhs.minPoint.y &&
                   rhs.maxPoint.x >= minPoint.x &&
                   rhs.maxPoint.y >= minPoint.y;
        }

        bool Contains(const AABB2D& rhs) const
        {
            return rhs.minPoint.x >= minPoint.x && rhs.minPoint.y >= minPoint.y
                   && rhs.maxPoint.x <= maxPoint.x && rhs.maxPoint.y <= maxPoint.y;
        }

        bool Contains(const Vector2& pt) const
        {
            return pt.x >= minPoint.x && pt.y >= minPoint.y
                   && pt.x <= maxPoint.x && pt.y <= maxPoint.y;
        }

        bool Contains(int x, int y) const
        {
            return x >= minPoint.x && y >= minPoint.y
                   && x <= maxPoint.x && y <= maxPoint.y;
        }

        bool IsDegenerate() const
        {
            return minPoint.x >= maxPoint.x || minPoint.y >= maxPoint.y;
        }

        bool HasNegativeVolume() const
        {
            return maxPoint.x < minPoint.x || maxPoint.y < minPoint.y;
        }

        bool IsFinite() const
        {
            return minPoint.IsFinite() && maxPoint.IsFinite() && minPoint.MinElement() > -1e5f && maxPoint.MaxElement() < 1e5f;
        }

        Vector2 PosInside(const Vector2 &normalizedPos) const
        {
            return minPoint + normalizedPos.Mul(maxPoint - minPoint);
        }

        Vector2 ToNormalizedLocalSpace(const Vector2 &pt) const
        {
            return (pt - minPoint).Div(maxPoint - minPoint);
        }


        AABB2D operator+(const Vector2& pt) const
        {
            AABB2D a;
            a.minPoint = minPoint + pt;
            a.maxPoint = maxPoint + pt;
            return a;
        }

        AABB2D operator-(const Vector2& pt) const
        {
            AABB2D a;
            a.minPoint = minPoint - pt;
            a.maxPoint = maxPoint - pt;
            return a;
        }

    };
}