//
// Created by stas on 6/2/19.
//

#pragma once

#include <iterator>

template <typename T>
class FNode {
public:
    explicit FNode(const FNode* next = nullptr) : next_(next) {};
    explicit FNode(const T& value, const FNode* next = nullptr) :
            value_(value),
            next_(next) {};

    FNode* next_;
    T value_;
};

template <typename T>
class ForwardList {
public:
    ForwardList();
    explicit ForwardList(unsigned int size);
    ForwardList(unsigned int size, const T& value);
    ForwardList(const ForwardList<T>& other);

    template <typename InputIt>
    ForwardList(InputIt fst, InputIt lst);

    ~ForwardList();

    void clear();
    FNode<T>* erase_after(FNode<T>* node);
    ForwardList<T>& operator= (const ForwardList<T>& other);

    void assign(unsigned int size, const T& value);

    template <typename InputIt>
    void assign(InputIt fst, InputIt lst);

    unsigned int size() const;

private:
    FNode<T>* before_top_;
};

template <typename T>
unsigned int ForwardList<T>::size() const {
    unsigned size = 0;
    FNode<T>* node = before_top_;
    for (; node->next_ != nullptr; node = node->next_)
        ++size;
    return size;
}

template <typename T>
ForwardList<T>::ForwardList() {
    before_top_ = new FNode<T>;
    before_top_->next_ = nullptr;
}

template <typename T>
ForwardList<T>::ForwardList(unsigned int size) {
    before_top_ = new FNode<T>[size + 1];
    for (unsigned i = 0; i < size; ++i) {
        before_top_[i].next_ = before_top_ + i + 1;
    }
    before_top_[size].next_ = nullptr;
}

template <typename T>
ForwardList<T>::ForwardList(unsigned int size, const T& value) :
    ForwardList(size)
{
    before_top_ = new FNode<T>[size + 1];
    for (unsigned i = 0; i < size; ++i) {
        before_top_[i].next_ = before_top_ + i + 1;
        before_top_[i].next_->value_ = value;
    }
    before_top_[size].next_ = nullptr;
}

template <typename T>
template <typename InputIt>
ForwardList<T>::ForwardList(InputIt fst, InputIt lst) :
    ForwardList(std::distance(fst, lst) + 1)
{
    FNode<T>* node = before_top_;
    for (auto it = fst; it != lst; ++it, node = node->next_)
        node->next_->value_ = *it;
}

template <typename T>
ForwardList<T>::ForwardList(const ForwardList<T> &other) {
    before_top_ = new FNode<T>[other.size() + 1];
    FNode<T>* other_node = other.before_top_;
    FNode<T>* node = before_top_;
    while (other_node->next_ != nullptr) {
        node->next_ = node + 1;
        node->next_->value_ = other_node->next_->value_;
        node = node->next_;
        other_node = other_node->next_;
    }
    node->next_ = nullptr;
}

template <typename T>
FNode<T>* ForwardList<T>::erase_after(FNode<T>* node) {
    FNode<T>* res = node->next_->next_;
    delete node->next_;
    return node->next_ = res;
}

template <typename T>
void ForwardList<T>::clear() {
    FNode<T>* node = before_top_->next_;
    FNode<T>* next_node = node->next_;
    while (next_node != nullptr) {
        delete node;
        node = next_node;
        next_node = node->next_;
    }
    delete node;
}

template <typename T>
ForwardList<T>::~ForwardList() {
    clear();
    delete before_top_;
}

template <typename T>
ForwardList<T>& ForwardList<T>::operator=(const ForwardList<T> &other) {
    if (*this == other)
        return *this;

    clear();

    before_top_ = new FNode<T>[other.size() + 1];
    FNode<T>* other_node = other.before_top_;
    FNode<T>* node = before_top_;
    while (other_node->next_ != nullptr) {
        node->next_ = node + 1;
        node->next_->value_ = other_node->next_->value_;
        node = node->next_;
        other_node = other_node->next_;
    }
    node->next_ = nullptr;
}

template <typename T>
void ForwardList<T>::assign(unsigned int size, const T &value) {
    clear();

    before_top_ = new FNode<T>[size + 1];
    for (unsigned i = 0; i < size; ++i) {
        before_top_[i].next_ = before_top_ + i + 1;
        before_top_[i].next_->value_ = value;
    }
    before_top_[size].next_ = nullptr;
}

template <typename T>
template <typename InputIt>
void ForwardList<T>::assign(InputIt fst, InputIt lst) {
    clear();

    before_top_ = new FNode<T>[std::distance(fst, lst) + 1];
    FNode<T>* node = before_top_;
    for (auto it = fst; it != lst; ++it, node = node->next_) {

    }
}