#include <iostream>
#include <initializer_list>
#include <utility>
#include <stdexcept>

template <typename T>
class Dek{

    T **elementi;
    int kapacitet;
    int i1, i2;
    void Realociraj();
    void Unisti();

    public:

    Dek() : elementi(new T *[10]), kapacitet(10), i1(5), i2(5){}
    Dek(std::initializer_list<T> l) : Dek(){
        for(auto x : l) DodajNaKraj(x);
    }
    ~Dek() {Unisti();}

    int DajVelicinu() const { return i2 - i1;}
    
    void DodajNaKraj(const T &x){
        if(i2 == kapacitet) Realociraj();
        elementi[i2] = new T (x);
        i2++;
        
        
    }
    void DodajNaPocetak(const T &x){
        if(i1 == 0) Realociraj();
        i1--;
        elementi [i1] = new T (x);
       

    }

    Dek(const Dek &d) 
    : elementi(new T* [d.kapacitet]), kapacitet(d.kapacitet), i1(d.i1), i2(d.i2){

        for(int i = i1; i < i2; i++){
            elementi[i] = new T (*d.elementi[i]);
        }

        
        
    }
    Dek(Dek &&d) : elementi(d.elementi), kapacitet(d.kapacitet), i1(d.i1), i2(d.i2){

        d.elementi = nullptr;
        d.kapacitet = d.i1 = d.i2 = 0;
        
    }

    Dek &operator=(Dek d){

        std::swap(elementi, d.elementi);
        std::swap(kapacitet, d.kapacitet);
        std::swap(i1, d.i1);
        std::swap(i2, d.i2);
        
        return *this;
        
    }

    const T &operator[] (int i) const{
        if(i < 0 || i >= DajVelicinu()) throw std::logic_error("Nedozvoljen index");
        return *(elementi[i1 + i]);
    }
     T &operator[] (int i) {
        if(i < 0 || i >= DajVelicinu()) throw std::logic_error("Nedozvoljen index");
        return *(elementi[i1 + i]);
    }
    
    
    
    
    
};

template<typename T>
void Dek<T>::Realociraj(){
    int novi_kapacitet = int (kapacitet * 1.5);
    T** novi = new T*[novi_kapacitet];

    int n1, n2;
    n1 = n2 = novi_kapacitet / 3;

    for(int i = i1; i < i2; i++){
        novi[n2] = elementi[i];
        n2++;
    }
    delete [] elementi;
    
    elementi = novi;
    i1 = n1;
    i2 = n2;
    kapacitet = novi_kapacitet;

    
}
template<typename T>
void Dek<T>::Unisti(){

    for(int i = i1; i < i2; i++) delete elementi[i];

    delete [] elementi;
}

int main() {
    Dek<int> d{3, 4, 5};

    std::cout << "Pocetni dek: ";
    for(int i = 0; i < d.DajVelicinu(); i++)
        std::cout << d[i] << " ";
    std::cout << std::endl;

    d.DodajNaPocetak(2);
    d.DodajNaPocetak(1);
    d.DodajNaKraj(6);
    d.DodajNaKraj(7);

    std::cout << "Nakon dodavanja na pocetak i kraj: ";
    for(int i = 0; i < d.DajVelicinu(); i++)
        std::cout << d[i] << " ";
    std::cout << std::endl;

    d[0] = 100;
    d[d.DajVelicinu() - 1] = 700;

    std::cout << "Nakon izmjene preko []: ";
    for(int i = 0; i < d.DajVelicinu(); i++)
        std::cout << d[i] << " ";
    std::cout << std::endl;

    Dek<int> kopija(d);

    std::cout << "Kopija: ";
    for(int i = 0; i < kopija.DajVelicinu(); i++)
        std::cout << kopija[i] << " ";
    std::cout << std::endl;

    Dek<int> pomjereni(std::move(kopija));

    std::cout << "Pomjereni: ";
    for(int i = 0; i < pomjereni.DajVelicinu(); i++)
        std::cout << pomjereni[i] << " ";
    std::cout << std::endl;

    std::cout << "Velicina kopije nakon move: " << kopija.DajVelicinu() << std::endl;

    Dek<int> dodjela;
    dodjela = pomjereni;

    std::cout << "Dodjela: ";
    for(int i = 0; i < dodjela.DajVelicinu(); i++)
        std::cout << dodjela[i] << " ";
    std::cout << std::endl;

    try {
        std::cout << dodjela[100] << std::endl;
    } catch(std::logic_error &e) {
        std::cout << "Uhvatili smo izuzetak: " << e.what() << std::endl;
    }

    return 0;
}