#include <iostream>
#include "StackT.h"

using namespace std;

struct StackNodeT {
    DataT data;
    StackNodeT * next;
};

StackT::StackT(){
    size = 0;
    stack = nullptr;
}

StackNodeT * CopyList(const StackNodeT * other) {
    StackNodeT * rv{nullptr};
    StackNodeT * travel,
               * tail,
               * current;
           
    travel = const_cast<StackNodeT *> (other);
    while (travel != nullptr) {
        current = new StackNodeT;
        current->data = travel->data;
        current->next = nullptr;
        if (rv == nullptr) {
             rv = current;
             tail = current;
        } else {
             tail->next = current;
             tail = tail->next;
        }
        travel = travel->next;
    }
    return rv;
}

StackT::StackT(const StackT & other){
     stack = CopyList(other.stack);
     size = other.size;
}

void DeleteList(StackNodeT  * &  stack) {
    StackNodeT * tmp;
    while(stack != nullptr) {
        tmp = stack;
        stack = stack->next;
        delete tmp;
    }
}

StackT::~StackT(){
     DeleteList(stack);
}

StackT & StackT::operator =(const StackT & other){
     if (&other != this) {
         DeleteList(stack);
         stack = CopyList(other.stack);
         size = other.size;
     }
     return *this;
}

void StackT::Push( DataT d){
    StackNodeT * tmp;
    tmp = new StackNodeT;
    tmp-> next = stack;
    tmp-> data = d;
    stack = tmp;
    size++;
}

void StackT::Pop(void){
    StackNodeT * tmp;
    if (stack == nullptr) {
       cout << "Error, can not Pop empty stack." << endl;
    } else {
       tmp = stack;
       stack = stack->next;
       delete tmp;
       size--;
    }

}

DataT StackT::Top(void) const{
    DataT d{0};
    if (stack == nullptr) {
       cout << "Error, can not Top empty stack." << endl;
    } else {
       d = stack -> data;
    }

    return d;
}

size_t StackT::Size(void) const{
    return size;
}

bool StackT::IsEmpty(void) const{
    return stack == nullptr;
}