#pragma once

#if !defined(MIJIN_GEO_GEOMETRY_TRAITS_HPP_INCLUDED)
#define MIJIN_GEO_GEOMETRY_TRAITS_HPP_INCLUDED 1

#include <concepts>
#include <ranges>

namespace mijin
{
template<typename T>
struct Vector2Traits;

template<typename T>
concept Vector2 = requires(const std::decay_t<T> constObject, std::decay_t<T> nonConstObject)
{
    { mijin::Vector2Traits<std::decay_t<T>>{}.getX(constObject) } -> std::convertible_to<float>;
    { mijin::Vector2Traits<std::decay_t<T>>{}.getY(constObject) } -> std::convertible_to<float>;
    { mijin::Vector2Traits<std::decay_t<T>>{}.setX(nonConstObject, 0.f) };
    { mijin::Vector2Traits<std::decay_t<T>>{}.setY(nonConstObject, 0.f) };
};

template<typename T>
struct Vector3Traits;

template<typename T>
concept Vector3 = requires(const std::decay_t<T> constObject, std::decay_t<T> nonConstObject)
{
    { mijin::Vector3Traits<std::decay_t<T>>{}.getX(constObject) } -> std::convertible_to<float>;
    { mijin::Vector3Traits<std::decay_t<T>>{}.getY(constObject) } -> std::convertible_to<float>;
    { mijin::Vector3Traits<std::decay_t<T>>{}.getZ(constObject) } -> std::convertible_to<float>;
    { mijin::Vector3Traits<std::decay_t<T>>{}.setX(nonConstObject, 0.f) };
    { mijin::Vector3Traits<std::decay_t<T>>{}.setY(nonConstObject, 0.f) };
    { mijin::Vector3Traits<std::decay_t<T>>{}.setZ(nonConstObject, 0.f) };
};

template<typename T>
struct Vector4Traits;

template<typename T>
concept Vector4 = requires(const std::decay_t<T> constObject, std::decay_t<T> nonConstObject)
{
    { mijin::Vector4Traits<std::decay_t<T>>{}.getX(constObject) } -> std::convertible_to<float>;
    { mijin::Vector4Traits<std::decay_t<T>>{}.getY(constObject) } -> std::convertible_to<float>;
    { mijin::Vector4Traits<std::decay_t<T>>{}.getZ(constObject) } -> std::convertible_to<float>;
    { mijin::Vector4Traits<std::decay_t<T>>{}.getW(constObject) } -> std::convertible_to<float>;
    { mijin::Vector4Traits<std::decay_t<T>>{}.setX(nonConstObject, 0.f) };
    { mijin::Vector4Traits<std::decay_t<T>>{}.setY(nonConstObject, 0.f) };
    { mijin::Vector4Traits<std::decay_t<T>>{}.setZ(nonConstObject, 0.f) };
    { mijin::Vector4Traits<std::decay_t<T>>{}.setW(nonConstObject, 0.f) };
};

template<typename T>
concept Index = std::convertible_to<T, std::size_t>;

template<typename T>
concept Vector2Iterator = requires(T object)
{
    { std::iterator_traits<T>::value_type } -> Vector2;
};

template<typename T>
concept Vector3Iterator = requires(T object)
{
    { std::iterator_traits<T>::value_type } -> Vector3;
};

template<typename T>
concept Vector4Iterator = requires(T object)
{
    { std::iterator_traits<T>::value_type } -> Vector4;
};

template<typename T>
concept Vector2Range = std::ranges::random_access_range<T> && Vector2<std::ranges::range_value_t<T>>;

template<typename T>
concept Vector3Range = std::ranges::random_access_range<T> && Vector3<std::ranges::range_value_t<T>>;

template<typename T>
concept Vector4Range = std::ranges::random_access_range<T> && Vector4<std::ranges::range_value_t<T>>;

template<typename T>
concept IndexRange = std::ranges::random_access_range<T> && Index<std::ranges::range_value_t<T>>;

template<typename T>
struct Mesh3DTraits;

template<typename T>
concept Mesh3D = requires(const T constObject, T nonConstObject, mijin::Mesh3DTraits<T>::index_t index, mijin::Mesh3DTraits<T>::vector3_t vec3Value)
{
    { typename mijin::Mesh3DTraits<T>::index_t() } -> Index;
    { typename mijin::Mesh3DTraits<T>::vector3_t() } -> Vector3;
    { mijin::Mesh3DTraits<T>{}.getNumFaces(constObject) } -> std::convertible_to<std::size_t>;
    { mijin::Mesh3DTraits<T>{}.getNumVertices(constObject) } -> std::convertible_to<std::size_t>;
    { mijin::Mesh3DTraits<T>{}.getFaceNumVertices(constObject, index) } -> std::convertible_to<std::size_t>;
    { mijin::Mesh3DTraits<T>{}.getPosition(constObject, index, index) } -> Vector3;
    { mijin::Mesh3DTraits<T>{}.setPosition(nonConstObject, index, index, vec3Value) };
};

template<typename T>
concept Mesh3DWithNormals = Mesh3D<T> && requires(const T constObject, T nonConstObject, mijin::Mesh3DTraits<T>::index_t index, mijin::Mesh3DTraits<T>::vector3_t vec3Value)
{
    { mijin::Mesh3DTraits<T>{}.getNormal(constObject, index, index) } -> Vector3;
    { mijin::Mesh3DTraits<T>{}.setNormal(nonConstObject, index, index, vec3Value) };
};

template<typename T>
concept Mesh3DWithTangents = Mesh3D<T> && requires(const T constObject, T nonConstObject, mijin::Mesh3DTraits<T>::index_t index, mijin::Mesh3DTraits<T>::vector4_t vec4Value)
{
    { typename mijin::Mesh3DTraits<T>::vector4_t() } -> Vector4;
    { mijin::Mesh3DTraits<T>{}.getTangent(constObject, index, index) } -> Vector4;
    { mijin::Mesh3DTraits<T>{}.setTangent(nonConstObject, index, index, vec4Value) };
};

template<typename T>
concept Mesh3DWithTexCoords = Mesh3D<T> && requires(const T constObject, T nonConstObject, mijin::Mesh3DTraits<T>::index_t index, mijin::Mesh3DTraits<T>::vector2_t vec2Value)
{
    { mijin::Mesh3DTraits<T>{}.getTexCoord(constObject, index, index) } -> Vector2;
    { mijin::Mesh3DTraits<T>{}.setTexCoord(nonConstObject, index, index, vec2Value) };
};

template<typename T>
concept FullMesh3D = Mesh3DWithNormals<T> && Mesh3DWithTangents<T> && Mesh3DWithTexCoords<T>;
}

#endif // MIJIN_GEO_GEOMETRY_TRAITS_HPP_INCLUDED