#pragma once

#if !defined(BAD_APPLE_OS_ARRAY_INCLUDED)
#define BAD_APPLE_OS_ARRAY_INCLUDED

#include <cstddef>
#include <stdexcept>
#include <utility>

namespace std
{
template<typename T, std::size_t N>
class array
{
public:
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using iterator = pointer;
    using const_iterator = const_pointer;

    T _elements;

    constexpr reference operator[](size_type pos) noexcept
    {
        return _elements[pos];
    }

    constexpr const_reference operator[](size_type pos) const noexcept
    {
        return _elements[pos];
    }

    [[nodiscard]] constexpr reference at(size_type pos)
    {
        if (pos >= N) {
            __ba_throw out_of_range();
        }
        return _elements[pos];
    }

    [[nodiscard]] constexpr const_reference at(size_type pos) const
    {
        if (pos >= N) {
            __ba_throw out_of_range();
        }
        return _elements[pos];
    }

    [[nodiscard]] constexpr reference front() noexcept
    {
        return _elements[0];
    }

    [[nodiscard]] constexpr const_reference front() const noexcept
    {
        return _elements[0];
    }

    [[nodiscard]] constexpr reference back() noexcept
    {
        return _elements[N - 1];
    }

    [[nodiscard]] constexpr const_reference back() const noexcept
    {
        return _elements[N - 1];
    }

    [[nodiscard]] constexpr pointer data() noexcept
    {
        return _elements;
    }

    [[nodiscard]] constexpr const_pointer data() const noexcept
    {
        return _elements;
    }

    [[nodiscard]] constexpr iterator begin() noexcept
    {
        return _elements;
    }

    [[nodiscard]] constexpr const_iterator begin() const noexcept
    {
        return _elements;
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept
    {
        return _elements;
    }

    [[nodiscard]] constexpr iterator end() noexcept
    {
        return &_elements[N];
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept
    {
        return &_elements[N];
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept
    {
        return &_elements[N];
    }

    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return N == 0;
    }

    [[nodiscard]] constexpr size_type size() const noexcept
    {
        return N;
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept
    {
        return N;
    }

    constexpr void fill(const T& value)
    {
        for (T& ele : *this) {
            ele = value;
        }
    }

    constexpr void swap(array& other)
    {
        for (size_type idx = 0; idx < N; ++idx) {
            std::swap((*this)[idx], other[idx]);
        }
    }
};
}

#endif // !defined(BAD_APPLE_OS_ARRAY_INCLUDED)