#pragma once

#include <iostream>
#include <assert.h>

using namespace std;

namespace Lenyiin
{
    template <class T>
    struct __list_node
    {
        __list_node<T> *_next; // 指向后一个节点的指针
        __list_node<T> *_prev; // 指向前一个节点的指针
        T _data;               // 节点存储的数据

        __list_node(const T &data = T())
            : _data(data), _next(nullptr), _prev(nullptr)
        {
        }
    };

    template <class T, class Ref, class Ptr>
    struct __list_iterator
    {
        typedef __list_node<T> Node;
        typedef __list_iterator<T, Ref, Ptr> Self;

        Node *_node;

        // 默认构造
        __list_iterator(Node *node)
            : _node(node)
        {
        }

        // 运算符重载
        // *it
        Ref operator*()
        {
            return _node->_data;
        }

        // it ->
        Ptr operator->()
        {
            return &_node->_data;
        }

        // ++it
        Self &operator++()
        {
            _node = _node->_next;
            return *this;
        }

        // it++
        Self operator++(int)
        {
            Self tmp(*this);
            ++(*this);
            return tmp;
        }

        // --it
        Self &operator--()
        {
            _node = _node->_prev;
            return *this;
        }

        // it--
        Self operator--(int)
        {
            Self tmp(*this);
            --(*this);
            return tmp;
        }

        // it != end()
        bool operator!=(const Self &it)
        {
            return _node != it._node;
        }

        bool operator==(const Self &it)
        {
            return _node == it._node;
        }
    };

    template <class T, class Ref, class Ptr>
    struct __list_reverse_iterator
    {
        typedef __list_node<T> Node;
        typedef __list_reverse_iterator<T, Ref, Ptr> Self;

        Node *_node;

        // 默认构造
        __list_reverse_iterator(Node *node)
            : _node(node)
        {
        }

        // 运算符重载
        // *it
        Ref operator*()
        {
            return _node->_data;
        }

        // it ->
        Ptr operator->()
        {
            return &_node->_data;
        }

        // ++it
        Self &operator++()
        {
            _node = _node->_prev;
            return *this;
        }

        // it++
        Self operator++(int)
        {
            Self tmp(*this);
            ++(*this);
            return tmp;
        }

        // --it
        Self &operator--()
        {
            _node = _node->_next;
            return *this;
        }

        // it--
        Self operator--(int)
        {
            Self tmp(*this);
            --(*this);
            return tmp;
        }

        // it != end()
        bool operator!=(const Self &it)
        {
            return _node != it._node;
        }

        bool operator==(const Self &it)
        {
            return _node == it._node;
        }
    };

    template <class T>
    class List
    {
        typedef __list_node<T> Node;

    public:
        typedef __list_iterator<T, T &, T *> iterator;
        typedef __list_iterator<T, const T &, const T *> const_iterator;
        typedef __list_reverse_iterator<T, T &, T *> reverse_iterator;
        typedef __list_reverse_iterator<T, const T &, const T *> const_reverse_iterator;

        iterator begin() // 返回头节点的下一个节点
        {
            return iterator(_head->_next);
        }

        iterator end() // 返回头节点
        {
            return iterator(_head);
        }

        const_iterator begin() const
        {
            return const_iterator(_head->_next);
        }

        const_iterator end() const
        {
            return const_iterator(_head);
        }

        reverse_iterator rbegin() // 返回头节点的下一个节点
        {
            return reverse_iterator(_head->_prev);
        }

        reverse_iterator rend() // 返回头节点
        {
            return reverse_iterator(_head);
        }

        const_reverse_iterator rbegin() const
        {
            return const_reverse_iterator(_head->_prev);
        }

        const_reverse_iterator rend() const
        {
            return const_reverse_iterator(_head);
        }

    public:
        // 带头双向循环链表
        // 默认构造
        List()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }

        // 拷贝构造
        List(const List<T> &lt)
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;

            for (const auto &e : lt)
            {
                push_back(e);
            }
        }

        // 赋值运算符
        // List<T>& operator=(const List<T>& lt)
        //{
        //	if (this != &lt)
        //	{
        //		clear();
        //		for (const auto& e : lt)
        //		{
        //			push_back(e);
        //		}
        //	}
        //	return *this;
        //}

        // 进阶写法
        List<T> &operator=(List<T> lt)
        {
            std::swap(_head, lt._head);
            return *this;
        }

        // 清除
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                erase(it++);
            }
        }

        // 析构函数
        ~List()
        {
            clear();
            delete _head;
            _head = nullptr;
        }

        // 结构设计的优势, 有没有数据, 插入的逻辑都是一样的
        // void push_back(const T& data)
        //{
        //	Node* tail = _head->_prev;
        //	Node* newnode = new Node(data);
        //	tail->_next = newnode;
        //	newnode->_prev = tail;
        //	newnode->_next = _head;
        //	_head->_prev = newnode;
        //}

        // void push_front(const T& data)
        //{
        //	Node* cur = _head->_next;
        //	Node* newnode = new Node(data);

        //	_head->_next = newnode;
        //	newnode->_prev = _head;
        //	newnode->_next = cur;
        //	cur->_prev = newnode;
        //}

        void push_back(const T &data)
        {
            insert(end(), data);
        }

        void push_front(const T &data)
        {
            insert(begin(), data);
        }

        // void pop_back()
        //{
        //	Node* tail = _head->_prev;
        //	Node* prev = tail->_prev;

        //	delete tail;
        //	prev->_next = _head;
        //	_head->_prev = prev;
        //}

        // void pop_front()
        //{
        //	Node* head = _head->_next;
        //	Node* next = head->_next;

        //	delete head;
        //	_head->_next = next;
        //	next->_prev = _head;
        //}

        void pop_back()
        {
            erase(--end());
        }

        void pop_front()
        {
            erase(begin());
        }

        void insert(iterator pos, const T &data)
        {
            Node *cur = pos._node;
            Node *prev = cur->_prev;
            Node *newnode = new Node(data);

            // prev newnode cur
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;
        }

        iterator erase(iterator pos)
        {
            assert(pos != end());

            Node *cur = pos._node;
            Node *prev = cur->_prev;
            Node *next = cur->_next;
            delete cur;

            prev->_next = next;
            next->_prev = prev;

            return next;
        }

    private:
        Node *_head;
    };
}