#include <cassert>
#include <iostream>
#include <memory>

using namespace std;

class Node {
public:
    int data;
    unique_ptr<Node> next;

    Node()
    {
        data = 0;
        next = NULL;
    };

    Node(int data)
    {
        this->data = data;
        this->next = NULL;
    };
};

class MyLinkedList {
private:
    unique_ptr<Node> head;
    unique_ptr<Node> tail;

public:
    MyLinkedList()
    {
        head = NULL;
        // tail = NULL;
    }

    int get(int index)
    {
        auto current = head.get();

        int count { 0 };
        while (current != NULL) {
            if (count == index) {
                return current->data;
            }
            ++count;
            current = current->next.get();
        }

        assert(0);
    }

    void addAtHead(int val)
    {
        unique_ptr<Node> new_node = make_unique<Node>(val);
        new_node->next = move(head);
        head = move(new_node);
    }

    void addAtTail(int val)
    {
        unique_ptr<Node> new_node = make_unique<Node>(val);
        if (head == NULL) {
            head = move(new_node);
        } else {
            auto temp_head = head.get();
            while (temp_head->next != NULL) {
                temp_head = temp_head->next.get();
            }
            temp_head->next = move(new_node);
        }
    }

    void addAtIndex(int index, int val)
    {
        auto current = head.get();
        unique_ptr<Node> new_node = make_unique<Node>(val);

        int count { 0 };
        while (current != NULL) {
            if (count == index - 1) {
                new_node->next = move(current->next);
                current->next = move(new_node);
            }
            ++count;
            current = current->next.get();
        }
    }

    void deleteAtIndex(int index)
    {
        auto current = head.get();

        if (index == 0) {
            head = head->next;
        }

        int count { 0 };
        while (current != NULL) {

            if (count == index - 1) {
                current->next = move(current->next->next);
            }
            ++count;
            current = current->next.get();
        }
    }
};

#include <iostream>
#include <memory>

using namespace std;

class Node {
public:
    int data;
    unique_ptr<Node> next;

    Node()
    {
        data = 0;
        next = nullptr;
    };

    Node(int data)
    {
        this->data = data;
        this->next = nullptr;
    };
};

class MyLinkedList {
private:
    unique_ptr<Node> head;

public:
    MyLinkedList()
    {
        head = nullptr;
    }

    int get(int index)
    {
        auto current = head.get();

        int count { 0 };
        while (current != nullptr) {
            if (count == index) {
                return current->data;
            }
            ++count;
            current = current->next.get();
        }

        return -1;
    }

    void addAtHead(int val)
    {
        unique_ptr<Node> new_node = make_unique<Node>(val);
        new_node->next = move(head);
        head = move(new_node);
    }

    void addAtTail(int val)
    {
        unique_ptr<Node> new_node = make_unique<Node>(val);
        if (head == nullptr) {
            head = move(new_node);
        } else {
            auto temp_head = head.get();
            while (temp_head->next != nullptr) {
                temp_head = temp_head->next.get();
            }
            temp_head->next = move(new_node);
        }
    }

    void addAtIndex(int index, int val)
    {
        auto current = head.get();
        unique_ptr<Node> new_node = make_unique<Node>(val);

        if (index == 0) {
            new_node->next = move(head);
            head = move(new_node);
        } else {
            int count { 0 };
            while (current != nullptr) {
                if (count == index - 1) {
                    new_node->next = move(current->next);
                    current->next = move(new_node);
                }
                ++count;
                current = current->next.get();
            }
        }
    }

    void deleteAtIndex(int index)
    {
        auto current = head.get();

        if (index == 0) {
            head = move(head->next);
        } else {
            int count { 0 };
            while (current != nullptr) {

                if (count == index - 1 && current->next != nullptr) {
                    current->next = move(current->next->next);
                }
                if (count == index - 1 && current->next == nullptr) {
                    break;
                }
                ++count;
                current = current->next.get();
            }
        }
    }
};

{
    MyLinkedList myList;
    myList.addAtHead(10);
    myList.addAtHead(20);
    myList.addAtIndex(1, 15);
} // <-- call `myList` destructor `MyLinkedList::~MyLinkedList()`
  //    +--> call `head` destructor `unique_ptr<Node>::~unique_ptr<Node>()` [початок рекурсивного ланцюжка]
  //       +--> call `ptr` destructor `Node::~Node()`
  //          +--> call `next` destructor `unique_ptr<Node>::~unique_ptr<Node>()`
  //             +--> call `ptr` destructor `Node::~Node()`
  //                +--> call `next` destructor `unique_ptr<Node>::~unique_ptr<Node>()`
  //                 ...

#define v val
#define p prev
#define n next
#define S(s, t, o, o_init) \
    struct s {             \
        t v; o p; o n;     \
        s(t v) : v(v), p(o_init), n(o_init) { } \
        s(t v, o p, o n) : v(v), p(p), n(n) { } \
    }
#define N node_t
#define C node_const_t
S(N, int, N *, this);
S(C, int const, C const *const, this);

#define i index
#define o origin
#define L MyLinkedList
union L {
    public:
        struct {
            int const length;
            C const *const tail;
            C const *const head;
        };
        // C const c;
    protected:
        N o;
        int l;
    public:
        L() : o(0) { }
        ~L() { deleteNodes(); }
    protected:
        N *getNode(int i) {
            int c = l + 1, h = c >> 1;
            i = (i + 1 + h) % c - h;
            N *x = &o;
            while(i < 0) { x = x->p; ++i; }
            while(0 < i) { x = x->n; --i; }
            return x;
        }
        void addAfterNode(N *p, int v) {
            p->n = p->n->p = new N(v, p, p->n);
            ++l;
        }
        void deleteNode(N *x) {
            --l;
            x->p->n = x->n;
            x->n->p = x->p;
            delete x;
        }
    private:
        // This method deletes all nodes except the origin.
        // All additional memory allocated by the instance will be free.
        // The state of the instance will be corrupted after deleteNodes() call.
        // Please make sure you validated the state before use of the instance.
        void deleteNodes() {
            N *x = o.n, *n = o.n->n;
            while(x != &o) {
                delete x;
                x = n;
                n = n->n;
            }
        }
    public:
        int get(int i) {
            if(i < 0 || l <= i) return -1;
            return getNode(i)->v;
        }
        void addAtHead(int v) {
            addAfterNode(&o, v);
        }
        void addAtTail(int v) {
            addAfterNode(o.p, v);
        }
        void addAtIndex(int i, int v) {
            if(i < 0 || l < i) return;
            addAfterNode(getNode(--i), v);
            // addAfterNode(getNode(i)->p, v);
        }
        void deleteAtIndex(int i) {
            if(i < 0 || l <= i) return;
            deleteNode(getNode(i));
        }
        void clear() {
            l = 0;
            deleteNodes();
            o.p = o.n = &o;
        }
};

#undef v
#undef p
#undef n
#undef S
#undef N
#undef C

#undef i
#undef o
#undef L

#include <iostream>
#include <memory>

class Node {
public:
    int data;
    std::unique_ptr<Node> next;

    Node(int data_ = 0)
        : data(data_)
        , next(nullptr)
    { };
    ~Node() {
        std::cout << "\ndesructor Node\n";
    };
};
class MyLinkedList {
public:
    std::unique_ptr<Node> head;

    MyLinkedList(int first_elem)
        : head(new Node(first_elem))
    { }
    ~MyLinkedList() {
        if(head.get() != nullptr)
            delete_all();
    }
    void addAtHead(int val) {
        auto old_head = std::move(head);
        auto tobe_new_head = std::unique_ptr<Node>(new Node(val));
        head = std::move(tobe_new_head);
        head->next = std::move(old_head);
    }
    Node *delete_head() {
        head = std::move(head->next);
        return head.get();
    }
    void delete_all() {
        while(delete_head() != nullptr);
    }
    void print() {
        std::cout << "\nlist content:\n";
        auto current = head.get();
        for(; current != nullptr; current = current->next.get()) {
            std::cout << current->data << ' ';
        }
        cout << "\n";
    }
};

int main() {
    MyLinkedList lst(1);
    lst.addAtHead(2);
    lst.addAtHead(3);
    lst.print();
    {
        lst.delete_head();
        // there we have message from the deleted head destructor\
        before the next one: "\nhead deleted\n"
    }
    std::cout << "\nhead deleted\n";
    std::cout << "\nnew 321\n";
    lst.addAtHead(1);
    lst.addAtHead(2);
    lst.addAtHead(3);
    lst.print();
    return 0;
}