#pragma once

#include <cstddef>

namespace st6
{
    template<class T>
    class allocator
    {
    public:
        using size_type = size_t;
        using difference_type = ptrdiff_t;
        using pointer = T*;
        using const_pointer = const T*;
        using reference = T&;
        using const_reference = const T&;
        using value_type = T;
    };

    template <class T, class A = allocator<T>>
    class list
    {
        struct Node;
        using NodePtr = Node*;

        struct Node
        {
            NodePtr next;
            NodePtr prev;
            T value;
        };

    public:
        class iterator
        {
        public:
            iterator() : ptr_(nullptr) {}
            explicit iterator(NodePtr ptr) : ptr_(ptr) {}

            T& operator*() const { return ptr_->value; }
            T* operator->() const { return &ptr_->value; }

            iterator& operator++()
            {
                ptr_ = ptr_->next;
                return *this;
            }

            bool operator==(const iterator& other) const { return ptr_ == other.ptr_; }
            bool operator!=(const iterator& other) const { return ptr_ != other.ptr_; }

        private:
            NodePtr ptr_;
        };

        iterator begin() { return iterator(head_->next); }
        iterator end() { return iterator(head_); }

        A allocator_;
        NodePtr head_;
        size_t size_;
    };
}