/*
 * Copyright 2022 Rive
 */

#ifndef _RIVE_SPAN_HPP_
#define _RIVE_SPAN_HPP_

#include "rive/rive_types.hpp"

#include <initializer_list>
#include <type_traits>
#include <iterator>

/*
 *  Span : cheap impl of std::span (which is C++20)
 *
 *  Inspired by Skia's SkSpan
 */

namespace rive
{
namespace internal
{

template <typename T, typename = void> struct IsSpannableImpl : std::false_type
{};

// A type is "spannable" if it has a data() member that returns a pointer and a
// size() member that returns an integer. This is true for Span, std::span,
// std::vector, etc.
template <typename T>
struct IsSpannableImpl<
    T,
    std::enable_if_t<std::is_pointer_v<decltype(std::declval<T>().data())> &&
                         std::is_integral_v<decltype(std::declval<T>().size())>,
                     void>> : std::true_type
{};

template <typename T> constexpr bool IsSpannable = IsSpannableImpl<T>::value;

template <typename SpannableType, typename ElementType, typename = void>
struct IsTypedSpannableImpl : std::false_type
{};

template <typename SpannableType, typename ElementType>
struct IsTypedSpannableImpl<
    SpannableType,
    ElementType,
    std::enable_if_t<
        std::is_assignable_v<ElementType*&,
                             decltype(std::declval<SpannableType>().data())>,
        void>> : IsSpannableImpl<SpannableType>
{};

template <typename S, typename E>
constexpr bool IsTypedSpannable = IsTypedSpannableImpl<S, E>::value;

template <typename S, typename = std::enable_if_t<IsSpannable<S>, void>>
using SpannableElementType =
    std::remove_pointer_t<decltype(std::declval<S>().data())>;

} // namespace internal

template <typename T> class Span
{
    T* m_Ptr;
    size_t m_Size;

public:
    constexpr Span() : m_Ptr(nullptr), m_Size(0) {}
    constexpr Span(T* ptr, size_t size) : m_Ptr(ptr), m_Size(size)
    {
        assert(ptr <= ptr + size);
    }

    template <size_t N> constexpr Span(T (&array)[N]) : m_Ptr(array), m_Size(N)
    {}

    // Handle assignment from any types that have data and size members
    template <
        typename U,
        typename =
            typename std::enable_if_t<internal::IsTypedSpannable<U, T>, U>>
    constexpr Span(U& that) : Span(that.data(), that.size())
    {}

    template <typename U,
              typename = typename std::
                  enable_if_t<internal::IsTypedSpannable<const U, T>, U>>
    constexpr Span(const U& that) : Span(that.data(), that.size())
    {}

    T& operator[](size_t index) const
    {
        assert(index < m_Size);
        return m_Ptr[index];
    }

    constexpr T* data() const { return m_Ptr; }
    constexpr size_t size() const { return m_Size; }
    constexpr bool empty() const { return m_Size == 0; }

    constexpr T* begin() const { return m_Ptr; }
    constexpr T* end() const { return m_Ptr + m_Size; }

    constexpr T& front() const { return (*this)[0]; }
    constexpr T& back() const { return (*this)[m_Size - 1]; }

    // returns byte-size of the entire span
    constexpr size_t size_bytes() const { return m_Size * sizeof(T); }

    constexpr size_t count() const { return m_Size; }

    Span<T> subset(size_t offset, size_t size) const
    {
        assert(offset <= m_Size);
        assert(size <= m_Size - offset);
        return {m_Ptr + offset, size};
    }

    // Makes rive::Span std::Container compatible
    // https://en.cppreference.com/w/cpp/named_req/Container
    typedef typename std::remove_cv<T>::type value_type;
    typedef T& reference;
    typedef T const& const_reference;
    typedef T* iterator;
    typedef T const* const_iterator;
    typedef std::ptrdiff_t difference_type;
    typedef size_t size_type;

    bool operator!=(const Span<T>& that) const
    {
        return m_Ptr != that.m_Ptr || m_Size != that.m_Size;
    }
    bool operator==(const Span<T>& that) const
    {
        return m_Ptr == that.m_Ptr && m_Size == that.m_Size;
    }
};

// Deduction guides so that spannable types will deduce the template type
// properly.
template <typename T>
Span(const T&) -> Span<internal::SpannableElementType<const T>>;

template <typename T> Span(T&) -> Span<internal::SpannableElementType<const T>>;

// Deduction guide to make array conversions automatic
template <typename T, size_t N> Span(T (&)[N]) -> Span<T>;

template <typename T> Span<T> make_span(T* ptr, size_t size)
{
    return Span<T>(ptr, size);
}

template <typename T, size_t N> Span<T> make_span(T (&ptr)[N])
{
    return Span<T>(ptr, N);
}
} // namespace rive

#endif