#pragma once

#include <Orange/Core/Types.h>
#include <Orange/Core/Traits.h>

namespace orange
{
    template <typename T, size_t N>
    struct Array
    {
        constexpr Array()
            : m_data{ } {}

        constexpr Array(const T components[N])
        {
            Copy(&components[0], &components[N], begin());
        }

        constexpr Array(std::initializer_list<T> list)
        {
            Copy(list.begin(), list.end(), begin());
        }

        template <typename... Args>
        constexpr Array(const Args&... args)
            : m_data {{ args... }}
        {
            static_assert(sizeof...(Args) == N);
        }

        constexpr       T* data()       { return &m_data[0]; }
        constexpr const T* data() const { return &m_data[0]; }

        constexpr size_t size() const { return N; }

        constexpr Array(const Array& other) = default;

        constexpr       T& operator[](size_t index)       { return m_data[index]; }
        constexpr const T& operator[](size_t index) const { return m_data[index]; }


        constexpr const T* begin() const { return &m_data[0]; }
        constexpr       T* begin()       { return &m_data[0]; }
        constexpr const T* end()   const { return &m_data[N]; }
        constexpr       T* end()         { return &m_data[N]; }


        constexpr bool operator==(const Array& other) const
        {
            return Equal(begin(), end(), other.begin());
        }

        constexpr bool operator!=(const Array& other) const
        {
            return !operator==(other);
        }

    private:

        T m_data[N];

    };

}