#include <gltexturend.hpp>

#include <functional>
#include <numeric>
#include <utility>

#include <globject.hpp>
#include <gltexture.hpp>

// NOLINTNEXTLINE
#define STR_EXCEPTION GLObject<>::Exception
#include <str.hpp>


/// Special member functions


template<std::size_t N>
inline GLTextureND<N>::GLTextureND(
    // NOLINTNEXTLINE
    std::string object_label,
    GLenum      target,
    GLenum      binding,
    GLenum      size_max_name,
    Size        size,
    GLenum      internal_format,
    GLenum      wrap,
    GLenum      min_filter,
    GLenum      mag_filter
)
:
    GLTexture(
        STR_JOIN(" ", it, it, {
            str_size_(size),
            std::move(object_label)
        }),
        target,
        binding,
        internal_format,
        wrap,
        min_filter,
        mag_filter
    ),
    size_{size}
{
    check_size_max_(size_max_name);
}


/// Core


template<std::size_t N>
std::size_t GLTextureND<N>::data_size_() const
{
    return std::accumulate(
        size_.begin(),
        size_.end(),
        std::size_t{1},
        std::multiplies<std::size_t>{}
    );
}


/// Check


template<std::size_t N>
void GLTextureND<N>::check_size_max_(GLenum size_max_name)
{
    auto static const size_max = integer(size_max_name);
    for (auto size : size_)
        if (size > size_max)
            STR_THROW(
                "Expected max size " << size_max         << ", " <<
                "got "               << str_size_(size_) << "."
            );
}


/// String


template<std::size_t N>
std::string GLTextureND<N>::str_size_(Size size)
{
    return STR("{" << STR_JOIN(", ", it, it, size) << "}");
}


/// Explicit template instantiation


template class GLTextureND<1>;
template class GLTextureND<2>;
template class GLTextureND<3>;