#pragma once

#include <vector>

template <typename T>
class vector_t{
private:

  void set_capacity_power_of_two(int x){
    if(x == 0){
      my_capacity = 0;
      return;
    }

    int y = 0;

    while (std::pow(2, y) < x){
      y++;
    }

    my_capacity = std::pow(2, y);
  }

  int my_capacity{0};
  T* arr{nullptr};
  int pos{0};

public:
  vector_t() = default;

  vector_t(size_t n, const T& m = T()){
    if (n != 0){
      set_capacity_power_of_two(n);

      arr = new T[my_capacity]();

      for(int i = 0; i < n; i++){
        arr[i] = m;
      }

      pos = n;
    }
  }

  vector_t(const vector_t<T> &other){
    if(other.pos != 0){
      pos = other.pos;
      set_capacity_power_of_two(pos);

      arr = new T[my_capacity]();

      for(int i = 0; i < pos; i++){
        arr[i] = other.arr[i];
      }
    }
  }

  vector_t<T>& operator=(const vector_t<T> &other){
    vector_t<T> temp(other);
    swap(temp);
    return *this;
  }

  void swap(vector_t<T> &other){
    std::swap(pos, other.pos);
    std::swap(my_capacity, other.my_capacity);
    std::swap(arr, other.arr);
  }

  ~vector_t(){
    clear();
  }

  T& operator[](int i) const{
    return arr[i];
  }

  T& front() const{
    return arr[0];
  }

  T& back() const{
    return arr[pos-1];
  }

  bool empty() const{
    if(pos == 0){
      return true;
    }else{
      return false;
    }
  }

  int size() const{
    return pos;
  }

  void reserve(int new_cap){
    if(my_capacity < new_cap){
      set_capacity_power_of_two(new_cap);

      T* new_arr = new T[my_capacity]();

      for(int i = 0; i < pos; i++){
        new_arr[i] = arr[i];
      }

      delete[] arr;
      arr = new_arr;
    }
  }

  T* data() const{
    return arr;
  }

  int capacity() const{
    return my_capacity;
  }

  void shrink_to_fit(){
    int prev_capacity = my_capacity;

    set_capacity_power_of_two(pos);

    if(my_capacity == 0){
      pos = 0;
      delete[] arr;
      arr = nullptr;
    }

    if(prev_capacity < my_capacity){
      T* new_arr = new T[my_capacity]();

      for(int i = 0; i < pos; i++){
        new_arr[i] = arr[i];
      }

      delete[] arr;
      arr = new_arr;
    }
  }

  void clear(){
    my_capacity = 0;
    pos = 0;

    delete[] arr;
    arr = nullptr;
  }

  void insert(size_t first, const T& m){
    insert(first, 1, m);
  }

  void insert(size_t first, size_t n, const T& m){
    if(n != 0){
      reserve(pos + n);

      for(int i = pos + n - 1; i >= first + n; i--){
        arr[i] = arr[i-n];
      }

      for(int i = first; i < first + n; i++){
        arr[i] = m;
      }

      pos += n;
    }
  }

  void erase(size_t first){
    erase(first, first + 1);
  }


  void erase(size_t first, size_t second){
    int n = second - first;
    pos -= n;

    for(int i = first; i < pos; i++){
      arr[i] = arr[i + n];
    }

  }

  void push_back(const T& m){
    insert(pos, m);
  }

  void pop_back(){
    erase(pos - 1);
  }

  void resize(size_t new_size, const T&val = T()){
    if(pos < new_size){
      reserve(new_size);

      for(int i = pos; i < new_size; i++){
        arr[i] = val;
      }

      pos = new_size;
    }else{
      erase(new_size, pos);
    }
  }

  friend bool operator==(const vector_t<T> &self, const vector_t<T> &other){
    if(self.pos != other.pos){
      return false;
    }else{
      for(int i = 0; i < self.pos; i++){
        if(self[i] != other[i]){
          return false;
        }
      }

      return true;
    }
  }

  friend bool operator!=(const vector_t<T> &self, const vector_t<T> &other){
    return !(self == other);
  }

  friend bool operator>(const vector_t<T> &self, const vector_t<T> &other){
    for(int i = 0; i < std::min(self.pos, other.pos); i++){
      if(self[i] > other[i]){
        return true;
      }
      if(self[i] < other[i]){
        return false;
      }
    }

    if(self.pos > other.pos){
      return true;
    }

    if(self.pos < other.pos){
      return false;
    }

    return false;
  }

  friend bool operator<(const vector_t<T> &self, const vector_t<T> &other){
    return !(self > other) && !(self == other);
  }

  friend bool operator>=(const vector_t<T> &self, const vector_t<T> &other){
    return !(self < other);
  }

  friend bool operator<=(const vector_t<T> &self, const vector_t<T> &other){
    return !(self > other);
  }
};