#pragma once
#include <iostream>
#include <initializer_list>
#include <iterator>

class Vector {
private:
    int* data_;
    size_t size_;
    size_t capacity_;

public:
    Vector() {
        size_ = 0;
        capacity_ = 1;
        data_ = new int[1];
    }

    explicit Vector(size_t size) {
        size_ = size;
        capacity_ = size;
        data_ = new int[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = 0;
        }
    }

    Vector(std::initializer_list<int> list) {
        size_ = list.size();
        capacity_ = list.size();
        data_ = new int[capacity_];
        size_t i = 0;
        for (const int& elem : list) {
            data_[i] = elem;
            ++i;
        }
    }

    Vector(const Vector& list) {
        size_ = list.size_;
        capacity_ = list.capacity_;
        data_ = new int[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = list.data_[i];
        }
    }

    Vector(Vector&& list) {
        size_ = list.size_;
        capacity_ = list.capacity_;
        data_ = list.data_;
        list.data_ = nullptr;
    }

    Vector& operator=(const Vector& list) {
        if (list.data_ == data_) {
            return *this;
        }
        delete[] data_;
        size_ = list.size_;
        capacity_ = list.capacity_;
        data_ = new int[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = list.data_[i];
        }
        return *this;
    }

    Vector& operator=(Vector&& list) {
        delete[] data_;
        size_ = list.size_;
        capacity_ = list.capacity_;
        data_ = list.data_;
        list.data_ = nullptr;
        return *this;
    }

    ~Vector() {
        delete[] data_;
    }

    void Swap(Vector& list) {
        std::swap(data_, list.data_);
        std::swap(size_, list.size_);
        std::swap(capacity_, list.capacity_);
    }

    int operator[](size_t i) const {
        return data_[i];
    }

    int& operator[](size_t i) {
        return data_[i];
    }

    size_t Size() const {
        return size_;
    }

    size_t Capacity() const {
        return capacity_;
    }

    void PushBack(int elem) {
        if (size_ != capacity_) {
            data_[size_] = elem;
            ++size_;
        } else {
            capacity_ *= 2;
            int* data = new int[capacity_];
            for (size_t i = 0; i < size_; ++i) {
                data[i] = data_[i];
            }

            data[size_] = elem;
            delete[] data_;
            ++size_;
            data_ = data;
        }
    }

    void PopBack() {
        --size_;
    }

    void Clear() {
        size_ = 0;
    }

    void Reserve(size_t capacity) {
        if (capacity > capacity_) {
            capacity_ = capacity;
            int* data = new int[capacity_];
            for (size_t i = 0; i < size_; ++i) {
                data[i] = data_[i];
            }
            delete[] data_;
            data_ = data;
        }
    }

    class Iterator : public std::iterator<std::forward_iterator_tag, int> {
    private:
        int* current_;

    public:
        Iterator() {
        }

        Iterator(int* current) {
            current_ = current;
        }

        bool operator==(const Iterator& iter) const {
            return current_ == iter.current_;
        }

        bool operator!=(const Iterator& iter) const {
            return !(*this == iter);
        }

        Iterator& operator++() {
            ++current_;
            return *this;
        }

        Iterator operator++(int) {
            Iterator cpy(*this);
            ++current_;
            return cpy;
        }

        Iterator& operator--() {
            --current_;
            return *this;
        }

        Iterator operator--(int) {
            Iterator cpy(*this);
            --current_;
            return cpy;
        }

        friend Iterator operator+(const Iterator kfirst, const int& klen) {
            Iterator result(kfirst.current_ + klen);
            return result;
        }

        friend int operator-(const Iterator kfirst, const Iterator ksecond) {
            return kfirst.current_ - ksecond.current_;
        }

        Iterator& operator+=(const int& klen) {
            current_ += klen;
            return *this;
        }

        Iterator& operator-=(const int& klen) {
            current_ -= klen;
            return *this;
        }

        int& operator*() {
            return *current_;
        }

        int* operator->() {
            return current_;
        }
    };

    Iterator Begin() {
        return Iterator(data_);
    }

    Iterator End() {
        return Iterator(data_ + size_);
    }

    Iterator begin() {  // NOLINT
        return Iterator(data_);
    }

    Iterator end() {  // NOLINT
        return Iterator(data_ + size_);
    }
};