#pragma once



#include <J3ML/Geometry.h>
#include <J3ML/LinearAlgebra/Matrix3x3.h>
#include <J3ML/LinearAlgebra/Matrix4x4.h>
#include <J3ML/Geometry/LineSegment.h>
#include <J3ML/Geometry/TriangleMesh.h>
#include <J3ML/Geometry/Shape.h>

namespace J3ML::Geometry
{
    using J3ML::LinearAlgebra::Matrix3x3;
    using J3ML::LinearAlgebra::Matrix4x4;

    // A mathematical representation of a 3-dimensional sphere
    class Sphere : public Shape
    {
    public:
        Vector3 Position;
        float Radius;
    public:
        Sphere() {}
        Sphere(const Vector3& pos, float radius) : Position(pos), Radius(radius) {}

        /// Generates a random point on the surface of this sphere
        /** The points are distributed uniformly.
            This function uses the rejection method to generate a uniform distribution of points on the surface.
            Therefore, it is assumed that this sphere is not degenerate, i.e. it has a positive radius.
            A fixed number of 1000 tries is performed, after which a fixed point on the surface is returned as a fallback.
            @param rng A pre-seeded random number generator object that is to be used by this function to generate random vlaues.
            @see class RNG, RandomPointInside(), IsDegenerate()
            @todo Add Sphere::PointOnSurface(polarYaw, polarPitch). */
        Vector3 RandomPointOnSurface(RNG& rng) const;
        static Vector3 RandomPointOnSurface(RNG& rng, const Vector3& center, float radius);

        /// Generates a random point inside this sphere.
        /** The points are distributed uniformly.
            This function uses the rejection method to generate a uniform distribution of points inside a sphere.
            Therefore, it is assumed that this sphere is not degenerate, i.e. it has a positive radius.
            A fixed number of 1000 tries is performed, after which the sphere center position is returned as a fallback.
            @param rng A pre-seeded random number generator object that is to be used by this function to generate random values.
            @see class RNG, RandomPointOnSurface(), IsDegenerate().
            @todo Add Sphere::Point(polarYaw, polarPitch, radius). */
        Vector3 RandomPointInside(RNG& rng);
        static Vector3 RandomPointInside(RNG& rng, const Vector3& center, float radius);
    public:
        /// Quickly returns an arbitrary point inside this Sphere. Used in GJK intersection test.
        [[nodiscard]] Vector3 AnyPointFast() const { return Position; }
        /// Computes the extreme point of this Sphere in the given direction.
        /** An extreme point is a farthest point of this Sphere in the given direction. For
            a Sphere, this point is unique.
            @param direction The direction vector of the direction to find the extreme point. This vector may
                be unnormalized, but may not be null.
            @return The extreme point of this Sphere in the given direction. */
        [[nodiscard]] Vector3 ExtremePoint(const Vector3 &direction) const;
        Vector3 ExtremePoint(const Vector3 &direction, float &projectionDistance) const;


        void Translate(const Vector3& offset);

        void Transform(const Matrix3x3& transform);

        void Transform(const Matrix4x4& transform);

        static inline float Cube(float inp);

        [[nodiscard]] float Volume() const;

        [[nodiscard]] float SurfaceArea() const;

        [[nodiscard]] bool IsFinite() const;

        [[nodiscard]] bool IsDegenerate() const;

        [[nodiscard]] bool Contains(const Vector3& point) const;

        [[nodiscard]] bool Contains(const Vector3& point, float epsilon) const;

        [[nodiscard]] bool Contains(const LineSegment& lineseg)  const;
        TriangleMesh GenerateUVSphere() const {}
        TriangleMesh GenerateIcososphere() const {}

        void ProjectToAxis(const Vector3 &direction, float &outMin, float &outMax) const;
    };
}