#pragma once

#include "iterator.h"

#include <iostream>
#include <memory>
#include <string>
#include <utility>

template <typename T>
struct Item {
    T value;
    std::unique_ptr<Item<T>> next;

    template <typename U>
    Item<T>(U&& val, std::unique_ptr<Item<T>>&& nxt) : value{ std::forward<U>(val) }, next{ std::move(nxt) } {
        std::cout << "Creating item: " << value << "\n";
    }

    ~Item<T>() {
        std::cout << "Deleting item: " << value << "\n";
    }

    Item<T>(const Item<T>& oth) = delete;

    Item<T>(Item<T>&& oth) noexcept {
        value = std::move(oth.value);
        next = std::move(oth.next);
    }

    Item<T>& operator=(const Item<T>& oth) = delete;

    Item<T>& operator=(Item<T>&& oth) noexcept {
        if (this != &oth) {
            value = std::move(oth.value);
            next = std::move(oth.next);
        }
        return *this;
    }

    Item<T>& operator[](int n) {
        auto item = this;
        for (int i = 0; i < n; ++i) {
            item = item->next.get();
        }
        return *item;
    }

    struct ItemIterator : Iterator<Item<T>> {

        ItemIterator(Item<T>* start) : Iterator<Item<T>>(start) {}

        Iterator<Item<T>>& operator++() override {
            this->item = this->item->next.get();
            return *this;
        }

        Iterator<Item<T>>& operator--() override {
            throw std::runtime_error("Decrement is unsupported!");
        }
    };

    ItemIterator begin() {
        return ItemIterator(this);
    }

    ItemIterator end() const {
        return ItemIterator(nullptr);
    }

    Item<T>* print_get_next() const {
        std::cout << value << (next ? ", " : "\n");
        return next.get();
    }
};