// List.h
//
// A class list similar to the STL container list.
// Version 1.0
//
// Included in this version:
//   list(), ~list(), back(), push_back(e), pop_back()

#ifndef _List_h_
#define _List_h_

namespace CS142 {

template <class T>
class ListNode
// T is the type of element stored in the list.
{
public:
    ListNode() : element(), next(nullptr), previous(nullptr) {}
    ListNode(const T& e, ListNode* next0, ListNode* previous0):
        element(e), next(next0), previous(previous0) {}

    ~ListNode() { next = previous = nullptr; }

    T element;
    ListNode<T>* next;
    ListNode<T>* previous;
};


template <class T>
class list
// T is the type of element stored in the list.
{
public:
    list();
    ~list();

    int size() const { return size_; }

    T& back() { return head_node_->previous->element; }
    const T& back() const
    {
        return head_node_->previous->element;
    }

    void push_back(const T& new_element);
    void pop_back();

    void test_print() const;

private:
    ListNode<T>* head_node_;
    int size_;
};

template <class T>
inline list<T>::list() : size_(0)
{
    head_node_ = new ListNode<T>;
    head_node_->next = head_node_->previous = head_node_;
}

template <class T>
inline list<T>::~list()
{
    while (size_ != 0)
        pop_back();

    delete head_node_;
}

template <class T>
void list<T>::push_back(const T& new_element)
{
    auto last_node = head_node_->previous;

    auto new_node =
        new ListNode<T>(new_element, head_node_, last_node);

    last_node->next = new_node;
    head_node_->previous = new_node;

    ++size_;
}

template <class T>
void list<T>::pop_back()
{
    auto last_node = head_node_->previous;
    auto new_last_node = last_node->previous;

    new_last_node->next = head_node_;
    head_node_->previous = new_last_node;

    delete last_node;

    --size_;
}

template <class T>
void list<T>::test_print() const
{
    for (auto node = head_node_->next;
            node != head_node_;
            node = node->next) {
        cout << node->element << ' ';
    }
    cout << endl;
}

} // namespace CS142

#endif