#ifndef _LISTANIZOM_H_
#define _LISTANIZOM_H_
#include<iostream>
#include<stdexcept>

template<typename T>
class ListaNizom {
  private:
    T* elementi_ = new T[maxSize_];
    size_t size_{0};
    size_t maxSize_;
    int front{0}, back{0};
  public:
    ListaNizom() = default;
    ListaNizom(T* elementi, size_t size, size_t maxSize) : elementi_{elementi}, size_{size}, maxSize_{maxSize} {}
    ListaNizom(const ListaNizom<T>& o);
    ListaNizom(ListaNizom<T>& o);
    const ListaNizom<T>& operator=(const ListaNizom<T>& o);
    const T& operator[](int index) const { return elementi_[index]; }
    T& operator[](int index) { return elementi_[index]; }
    void reallocate();
    size_t size() const { return size_; }
    size_t maxSize() { return maxSize_; }
    void push_back(const T& value);
    void push_back(const T&& value);
    void pop();
    void print(const ListaNizom<T>& lista) const;

};

template<typename T>
ListaNizom<T> :: ListaNizom(const ListaNizom<T>& o) {
  maxSize_ = o.maxSize_;
  size_ = o.size_;
  elementi_ = new T[maxSize_];
  for( size_t i = 0; i < size_; ++i ) {
    elementi_[i] = o.elementi_[i];
  }
}

template<typename T>
ListaNizom<T> :: ListaNizom(ListaNizom<T>& o) {
  maxSize_ = o.maxSize_;
  size_ = o.size_;
  elementi_ = o.elementi_;
  o.elementi_ = nullptr;
}
template<typename T>
const ListaNizom<T>& ListaNizom<T> :: operator=(const ListaNizom<T>& o) {
  if(this!=o) {
    delete [] elementi_;
    maxSize_ = o.maxSize_;
    size_ = o.size_;
    elementi_ = new T[maxSize_];
    for(size_t i = 1; i < size_; ++i)
      elementi_[i] = o.elementi_[i];
  }
  return *this;
}

template<typename T>
void ListaNizom<T> :: push_back(const T& value) {
  if(size_ == 0) elementi_[0] = value; back++; size_++;
  if(size_ != maxSize_) {
    back = (back + 1)  % maxSize_;
    elementi_[back] = value;
    ++size_;
    back++;
  }
}

template<typename T>
void ListaNizom<T> :: push_back(const T&& value) {
  if(size_ == 0) elementi_[0] = value;
   else if(size_ != maxSize_) {
    back = ( back + 1)  % size_;
    elementi_[back] = value;
    ++size_;
  }

}

template<typename T>
void ListaNizom<T> :: pop() {
  if(size_ == 0) throw std::out_of_range("Array is empty!");
  if(size_) {
    --size_;
  }
}

template<typename T>
void ListaNizom<T> :: print(const ListaNizom<T>& lista) const {
  for(int i = 0; i < lista.size(); ++i)
    std::cout << lista[i] << std::endl;
}

template<typename T>
void ListaNizom<T> :: reallocate() {
  maxSize_ *= 2;
  T* newElementi_ = new T[maxSize_];
  std::copy(elementi_, elementi_ + size_, newElementi_);
  delete[] elementi_;
  elementi_ = newElementi_;
}


#endif