#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED

#include <cstdlib>
#include <stdexcept>
#include <iostream>

template <class T>
class Stack;

template <class T>
std::ostream& operator<<(std::ostream& os, const Stack<T> &s);

template <class T>
class Stack {
private:
    T *data;
    size_t sz;
    size_t limit;
public:

    Stack();
    explicit Stack(size_t n);

    Stack(const Stack &other);
    Stack& operator=(const Stack& other);

    Stack(Stack &&other);
    Stack& operator=(Stack &&other);

    ~Stack();

    void Push(const T &val);
    T& Pop();

    size_t size() {return sz;}

    friend std::ostream& operator<< <> (std::ostream& os, const Stack<T> &s);

};

template <class T>
std::ostream& operator<<(std::ostream& os, const Stack<T> &s){
    os << "size: " << s.sz << std::endl;
    os << "limit: " << s.limit << std::endl;
    for (size_t i = 0; i != s.sz; ++i)
            os << s.data[i] << " ";
    os << std::endl;

    return os;
}

template <class T>
Stack<T>::Stack() {
    limit = 1;
    data = new T[limit];
    sz = 0;
}

template <class T>
Stack<T>::Stack(size_t n) {
    limit = n;
    data = new T[limit];
    sz = n;

    for (size_t i = 0; i != sz; ++i)
        data[i] = 0;
}


template <class T>
Stack<T>::Stack(const Stack &other) {
    limit = other.limit;
    data = new T[limit];
    sz = other.sz;
    for (size_t i = 0; i != sz; ++i)
        data[i] = other.data[i];
}


template <class T>
Stack<T>& Stack<T>::operator=(const Stack &other) {
    if (&other != this) {
        delete[] data;

        limit = other.limit;
        data = new T[limit];
        sz = other.sz;
        for (size_t i = 0; i != sz; ++i)
            data[i] = other.data[i];
    }

    return *this;
}

template <class T>
Stack<T>::Stack(Stack &&other) {
    limit = other.limit;
    data = other.data;
    sz = other.sz;

    other.data = nullptr;
    other.limit = other.sz = 0;
}


template <class T>
Stack<T>& Stack<T>::operator=(Stack &&other) {
    if (&other != this) {
        delete[] data;

        limit = other.limit;
        data = other.data;
        sz = other.sz;

        other.data = nullptr;
        other.limit = other.sz = 0;
    }

    return *this;
}

template <class T>
Stack<T>::~Stack() {
    delete[] data;
}

template <class T>
void Stack<T>::Push(const T &val) {
    if (sz == limit || limit == 0) {
        T *newData = new T[limit * 2];
        limit *= 2;

        for (size_t i = 0; i != sz; ++i)
            newData[i] = data[i];

        delete[] data;
        data = newData;
    }

    data[sz++] = val;
}

template <class T>
T& Stack<T>::Pop() {
    if (sz == 0)
        throw std::underflow_error("stack underflow");

    return data[--sz];
}



#endif // STACK_H_INCLUDED