#include <iostream>

/*
  Värt att notera om live-kod:
  - Detta är inte nödvändigtvid en komplett lösning som är helt korrekt. Det är exakt det
    som koms fram till under föreläsning. Det kan saknas bitar eller finnas saker som hade
    resulterat i komplettering vid inlämning.
  - Koden ligger i en fil för att underlätta i föreläsningssammanhang. Det kommer krävas korrekt
    filuppdelning i de uppgifter ni ska göra.
 */

class Pile
{
public:
    Pile()
        : top {nullptr}
    {}

    Pile(Pile const& other)
        : top {nullptr}
    {
        Node* tmp {other.top};
        while(tmp != nullptr)
        {
            insert(tmp->value);
            tmp = tmp->next;
        }
    }

    ~Pile()
    {
        while(not is_empty())
        {
            remove();
        }
    }

    Pile& operator=(Pile const& rhs)
    {
        Pile tmp {rhs};
        std::swap(tmp.top, top);
        return *this;
    }

    Pile& operator=(Pile && rhs)
    {
        std::swap(rhs.top, top);
        return *this;
    }

    Pile(Pile && other)
        : top {other.top}
    {
        other.top = nullptr;
    }

    void insert(int i)
    {
        top = new Node{i, top};
    }
    
    void remove()
    {
        // seg-fault om högen är tom
        Node* tmp {top};
        top = top->next;
        delete tmp;
        tmp = nullptr;
    }
        
    bool is_empty() const
    {
        return top == nullptr;
    }

    int size() const
    {
        int counter {};
        Node* tmp {top};
        while(tmp != nullptr)
        {
            tmp = tmp->next;
            ++counter;
        }
        return counter;
    }

private:

    struct Node
    {
        int value;
        Node* next;
    };

    Node* top;
};

int main()
{
    Pile p{};

    p.insert(4);
    p.insert(5);
    p.insert(7);

    Pile p2 {};
    p2.insert(5);

    p2 = std::move(p);
    
    p2.remove();
    p.remove();

    return 0;
}