#pragma once

#if !defined(MIJIN_CONTAINER_INLINE_ARRAY_HPP_INCLUDED)
#define MIJIN_CONTAINER_INLINE_ARRAY_HPP_INCLUDED 1

#include "./boxed_object.hpp"

namespace mijin
{

//
// public defines
//

//
// public constants
//

//
// public types
//

template<typename T, std::size_t maxSize>
class InlineArray
{
public:
    using element_type = T;
    using value_type = std::remove_cv_t<T>;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using iterator = BoxedObjectIterator<T>;
    using const_iterator = BoxedObjectIterator<const T>;
private:
    BoxedObject<T> elements_[maxSize]; // NOLINT(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
    size_type size_ = 0;
public:
    InlineArray() = default;
    InlineArray(const InlineArray& other);
    InlineArray(InlineArray&& other) noexcept;
    ~InlineArray();

    reference operator[](size_type index);
    const_reference operator[](size_type index) const;

    [[nodiscard]] iterator begin() { return BoxedObjectIterator<T>(&elements_[0], &elements_[0], &elements_[size_]); }
    [[nodiscard]] const_iterator begin() const { return BoxedObjectIterator<const T>(&elements_[0], &elements_[0], &elements_[size_]); }
    [[nodiscard]] const_iterator cbegin() const { return BoxedObjectIterator<const T>(&elements_[0], &elements_[0], &elements_[size_]); }
    [[nodiscard]] iterator end() { return BoxedObjectIterator<T>(&elements_[size_], &elements_[0], &elements_[size_]); }
    [[nodiscard]] const_iterator end() const { return BoxedObjectIterator<const T>(&elements_[size_], &elements_[0], &elements_[size_]); }
    [[nodiscard]] const_iterator cend() const { return BoxedObjectIterator<const T>(&elements_[size_], &elements_[0], &elements_[size_]); }

    [[nodiscard]] constexpr size_type size() const { return size_; }
    [[nodiscard]] constexpr size_type capacity() const { return maxSize; }
    [[nodiscard]] constexpr bool empty() const { return size_ == 0; }
    [[nodiscard]] constexpr reference at(size_type index) {
        MIJIN_ASSERT(index < size_, "InlineArray::at() attempt to access out-of-bounds index.");
        return elements_[index].get();
    }
    [[nodiscard]] constexpr const_reference at(size_type index) const {
        MIJIN_ASSERT(index < size_, "InlineArray::at() attempt to access out-of-bounds index.");
        return elements_[index].get();
    }

    void resize(size_type newSize);
    void clear() { resize(0); }
};

//
// public functions
//

template<typename T, std::size_t numElements>
InlineArray<T, numElements>::InlineArray(const InlineArray& other) : size_(other.size_)
{
    for (size_type idx = 0; idx < size_; ++idx) {
        other.elements_[idx].copyTo(elements_[idx]);
    }
}

template<typename T, std::size_t numElements>
InlineArray<T, numElements>::InlineArray(InlineArray&& other) noexcept : size_(other.size_)
{
    for (size_type idx = 0; idx < size_; ++idx) {
        other.elements_[idx].moveTo(elements_[idx]);
    }
    other.size_ = 0;
}

template<typename T, std::size_t numElements>
InlineArray<T, numElements>::~InlineArray()
{
    for (std::size_t idx = 0; idx < size_; ++idx) {
        elements_[idx].destroy();
    }
}

template<typename T, std::size_t numElements>
auto InlineArray<T, numElements>::operator[](size_type index) -> reference
{
    return at(index);
}

template<typename T, std::size_t numElements>
auto InlineArray<T, numElements>::operator[](size_type index) const -> const_reference
{
    return at(index);
}

template<typename T, std::size_t numElements>
void InlineArray<T, numElements>::resize(size_type newSize)
{
    MIJIN_ASSERT(newSize <= numElements, "InlineArray::resize(): Attempt to resize beyond maximum size.");
    if (newSize < size_) {
        for (size_type idx = newSize; idx < size_; ++idx) {
            elements_[idx].destroy();
        }
    }
    else {
        for (size_type idx = size_; idx < newSize; ++idx) {
            elements_[idx].construct();
        }
    }
    size_ = newSize;
}

} // namespace mijin

#endif // !defined(MIJIN_CONTAINER_INLINE_ARRAY_HPP_INCLUDED)