#ifndef ARBUTILS_LIST_HPP
#define ARBUTILS_LIST_HPP
#include <algorithm>
#include <sstream>
#include <stdexcept>
#include <vector>

namespace Arbutils::Collections {
    template <class ValueT> class List {
    private:
        std::vector<ValueT> _vector;
        using reference = typename std::vector<ValueT>::reference;
        using const_reference = typename std::vector<ValueT>::const_reference;
        using iterator = typename std::vector<ValueT>::iterator;
        using const_iterator = typename std::vector<ValueT>::const_iterator;

    public:
        List() : _vector() {}
        explicit List(size_t capacity) : _vector(capacity) {}
        explicit List(const std::initializer_list<ValueT>& l) : _vector(l) {}
        List(const ValueT* begin, const ValueT* end) : _vector(begin, end) {}

        inline void Clear() { _vector.clear(); }

        inline reference At(size_t index) {
#ifndef NO_ASSERT
            if (index >= _vector.size() || index < 0) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds.";
                throw std::logic_error(ss.str());
            }
#endif
            return _vector.at(index);
        }

        inline const_reference At(size_t index) const {
#ifndef NO_ASSERT
            if (index >= _vector.size() || index < 0) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds.";
                throw std::logic_error(ss.str());
            }
#endif
            return _vector.at(index);
        }

        inline const_reference Set(size_t index, const ValueT& value) {
#ifndef NO_ASSERT
            if (index >= _vector.size() || index < 0) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds.";
                throw std::logic_error(ss.str());
            }
#endif
            _vector[index] = value;
        }

        inline bool Contains(const ValueT& value) const {
            return std::find(_vector.begin(), _vector.end(), value) != _vector.end();
        }

        /// Find the index of the first occurrence of a value in the list, return -1 if none is found.
        /// \param value The value we want the index for.
        /// \return The index of the first occurrence of the value in the list, or -1 if none is found.
        inline size_t IndexOf(const ValueT& value) const {
            auto it = std::find(_vector.begin(), _vector.end(), value);
            if (it == _vector.end())
                return -1;
            return std::distance(_vector.begin(), it);
        }

        inline void Append(const ValueT& value) { _vector.push_back(value); }

        inline void Insert(size_t index, const ValueT& value) { _vector.insert(index, value); }

        inline reference operator[](size_t index) { return At(index); }
        inline const_reference operator[](size_t index) const { return At(index); }

        inline size_t Count() const { return _vector.size(); }
        inline void Resize(size_t size) { _vector.resize(size); }
        inline void Resize(size_t size, const ValueT& defaultValue) { _vector.resize(size, defaultValue); }

        inline void Remove(size_t index) { _vector.erase(_vector.begin() + index); }

        iterator begin() { return _vector.begin(); }
        const_iterator begin() const { return _vector.begin(); }

        iterator end() { return _vector.end(); }
        const_iterator end() const { return _vector.end(); }

        const ValueT* RawData() const { return _vector.data(); }

        const std::vector<ValueT>& GetStdList() const { return _vector; }
        std::vector<ValueT>& GetStdList() { return _vector; }
    };
}

#endif // ARBUTILS_LIST_HPP