#ifndef _TOP_HPP
#define _TOP_HPP

#include<memory>
#include<iostream>
#include<cstring>

    template <typename T>
    class Stack{
        private:
            struct Node{
                Node():prev(nullptr){};
                std::shared_ptr<Node> prev;
                T value;
            };

            int size;
            std::shared_ptr<Node> top;
            std::string name;

            void deepCopy(const Stack<T>&s){
                 if(this!=&s){
                    size=s.size;
                    auto s_top=s.top;
                    auto this_top=top;
                    //copy values
                    while(s_top){
                        this_top->value=s_top->value;
                        //if  solve with display 0 such a last value problem
                        if(s_top->prev)   this_top->prev=std::make_shared<Node>();
                        this_top=this_top->prev;
                        s_top=s_top->prev;
                    }
                 }
            }

        public:
            Stack():size(0),top(std::make_shared<Node>()),name("null"){};
            Stack(const std::string name):size(0),top(std::make_shared<Node>()),name(name){};
            Stack(const Stack<T>&s):size(0),top(std::make_shared<Node>()),name("null"){ deepCopy(s);}
            Stack(const std::string name,const Stack<T>&s):size(0),top(std::make_shared<Node>()),name(name){ deepCopy(s);}
            Stack(Stack<T>&&);
            bool isEmpty()const;
            void push(T);
            const T pop();
            void clear();
            Stack<T>& operator=(const Stack<T>&);
            Stack<T>& operator=(Stack<T>&&);

            friend std::ostream&  operator<<(std::ostream& os,const Stack<T>& s){
                if(s.size==0) return os<<std::endl;
                if(s.name.compare("null")) os<<"Name: "<<s.name<<"  Size "<<s.size<<std::endl;
                auto temp=s.top.get();
                while(temp){
                    os<<temp->value<<std::endl;
                    temp=temp->prev.get();
                }
                return os<<std::endl;
            }
    };

    template <typename T>
    inline Stack<T>::Stack(Stack<T>&& s):size(0),top(std::make_shared<Node>()),name("null"){
        deepCopy(s);
        if(s.name.compare(name)); name=s.name;
        s.clear();
    }

    template <typename T>
    inline bool Stack<T>::isEmpty()const{
        if(size==0) return true;
        return false;
    }

    template <typename T>
    void Stack<T>::push(T x){
        std::shared_ptr<Node> add =std::make_shared<Node>();
        add->value=x;
        if(isEmpty()){
            top=std::move(add);
            ++size;
            return;
        }
            add->prev=std::move(top);
            top=std::move(add);
            ++size;
    }

    template <typename T>
    const T Stack<T>::pop(){
        T p=top->value;
        if(isEmpty()){
            std::cerr<<std::endl;
            return -1;
        }else{
            top=std::move(top->prev);
            --size;
            return p;
        }
    }

    template <typename T>
    inline void Stack<T>::clear(){
        while(top){
            top=std::move(top->prev);
            --size;
        }
    }

    template <typename T>
    Stack<T>& Stack<T>::operator=(const Stack<T>&s){
         top =std::make_shared<Node>();
         deepCopy(s);
         return *this;
    }

    template <typename T>
    Stack<T>& Stack<T>::operator=(Stack<T>&& s){
         top =std::make_shared<Node>();
         deepCopy(s);
         if(s.name.compare(name)) name=s.name;
         s.clear();
         return *this;
    }
#endif