#ifndef _TOP_HPP
#define _TOP_HPP

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


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

            int size;
            std::shared_ptr<Node> top;
            const char* name;

        public:
            Stack();
            Stack(const char* name);
            bool isEmpty()const;
            void push(T);
            const int pop();
            const int getSize()const{return size;}
            const char& getName()const{return name;}
            void clear();

            Stack<T>& operator=(const Stack<T>&);
            //don't know why but when implement this friend fun beyond
            //class then main.cpp don't compile
            friend std::ostream&  operator<<(std::ostream& os,const Stack<T>& s){
                if(strcmp(s.name,"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():size(0),top(std::make_shared<Node>()),name("null"){
        top->prev=nullptr;
        top->value=0;
    }

    template <typename T>
    inline Stack<T>::Stack(const char* name):size(0),top(std::make_shared<Node>()),name(name){
        top->prev=nullptr;
        top->value=0;
    }

    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;
        add->prev=nullptr;
        if(isEmpty()) top=std::move(add);
        else{
            add->prev=std::move(top);
            top=std::move(add);
        }
        ++size;
    }

    template <typename T>
    const int Stack<T>::pop(){
        int p=top->value;
        if(isEmpty()){ std::cerr<<"stack is empty"<<std::endl; }
        else{
            top=top->prev; //this is good idea ?
            --size;
        }
            return p;
    }


     template <typename T>
     Stack<T>& Stack<T>::operator=(const Stack<T>& s){
         if(this!=&s){
             size=s.size;
             top=s.top;
         }
         return *this;
     }

    template <typename T>
    inline void Stack<T>::clear(){
        while(top){
            top=std::move(top->prev);i//how can i improve this ?
            --size;
        }
    }


#endif

#include<iostream>
#include<memory>
#include "stack.hpp"


using namespace std;


int main(){

    Stack<int> s("asd");
    Stack<int> q;
    s.push(12);
    s.push(13);
    s.push(14);
    s.push(15);

    q=s;

    cout<<s; //cout's normal display a stacks
    cout<<q;
    s.clear(); // after this fun on s

    cout<<s; // this stack is delete
    cout<<q; // this stack have only 15 (top of stack s) ;/


}