#pragma once

#include <cassert>
#include <initializer_list>
#include <stdexcept>

using namespace std;

template <typename Type>
class SimpleVector {
public:
    using Iterator = Type*;
    using ConstIterator = const Type*;

    SimpleVector() noexcept : data(nullptr), size(0), capacity(0) {}

    explicit SimpleVector(size_t size) : size(size), capacity(size) {
        data = size > 0 ? new Type[size] : nullptr;
        for (size_t i = 0; i < size; ++i) {
            data[i] = Type();  // Initialize with default value
        }
    }

    SimpleVector(size_t size, const Type& value) : size(size), capacity(size) {
        data = size > 0 ? new Type[size] : nullptr;
        for (size_t i = 0; i < size; ++i) {
            data[i] = value;
        }
    }

    SimpleVector(std::initializer_list<Type> init) : size(init.size()), capacity(init.size()) {
        data = size > 0 ? new Type[size] : nullptr;
        size_t i = 0;
        for (const auto& item : init) {
            data[i++] = item;
        }
    }

    size_t GetSize() const noexcept {
        return size;
    }

    size_t GetCapacity() const noexcept {
        return capacity;
    }

    bool IsEmpty() const noexcept {
        return size == 0;
    }

    Type& operator[](size_t index) noexcept {
        if (index >= size) {
            //throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    const Type& operator[](size_t index) const noexcept {
        if (index < size) {
           // throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    Type& At(size_t index) noexcept {
       if (index >= size) throw std::out_of_range("Index is too large!");
        return (*this)[index];
    }

    const Type& At(size_t index) const noexcept {
       if (index >= size) throw std::out_of_range("Index is too large!");
        return (*this)[index];
    }

    void Clear() noexcept {
        size = 0;
    }

    void Resize(size_t new_size) {
        if (new_size > capacity) {
            Type* new_data = new Type[new_size];
            for (size_t i = 0; i < size; ++i) {
                new_data[i] = data[i];
            }
            for (size_t i = size; i < new_size; ++i) {
                new_data[i] = Type();  // Initialize new elements with default value
            }
            delete[] data;
            data = new_data;
            capacity = new_size;
        }
        size = new_size;
    }

    Iterator begin() noexcept {
        return data;
    }

    Iterator end() noexcept {
        return data + size;
    }

    ConstIterator begin() const noexcept {
        return data;
    }

    ConstIterator end() const noexcept {
        return data + size;
    }

    ConstIterator cbegin() const noexcept {
        return data;
    }

    ConstIterator cend() const noexcept {
        return data + size;
    }

    ~SimpleVector() {
        delete[] data;
    }

private:
    Type* data;
    size_t size;
    size_t capacity;
};