#include <iostream>
#include <vector>

using namespace std;

template <typename T>
class ForwardList {
public:

    ForwardList() : size_(0), head_(nullptr) {}

    ForwardList(const ForwardList& other) : size_(other.size_), head_(nullptr) {
        if (other.head_ != nullptr) {
            head_ = new Node{ other.head_->value, nullptr };
            Node* temp = head_;
            Node* other_temp = other.head_;
            while (other_temp->next != nullptr) {
                other_temp = other_temp->next;
                temp->next = new Node{ other_temp->value, nullptr };
                temp = temp->next;
            }
        }
    }

    ForwardList(ForwardList&& other) : size_(other.size_), head_(other.head_) {
        other.head_ = nullptr;
    }

    ForwardList& operator=(const ForwardList& other) {
        if (this != &other) {
            clear();
            if (other.head_ != nullptr) {
                head_ = new Node{ other.head_->value, nullptr };
                Node* temp = head_;
                Node* other_temp = other.head_;
                while (other_temp->next != nullptr) {
                    other_temp = other_temp->next;
                    temp->next = new Node{ other_temp->value, nullptr };
                    temp = temp->next;
                }
            }
            size_ = other.size_;
        }
        return *this;
    }

    ForwardList& operator=(ForwardList&& other) {
        if (this != &other) {
            clear();
            head_ = other.head_;
            size_ = other.size_;
            other.head_ = nullptr;
        }
        return *this;
    }

    struct Node { //односвязный список состоит из узлов
        T value; // узел хранит информативную часть
        Node* next; // и указатель на следующий узел в списке
    };

    void push_front(const int& value) {
        head_ = new Node{ value, head_ };
        size_++;
    }

    void pop_front() {
        if (head_ != nullptr) {
            Node* temp = head_;
            head_ = head_->next;
            delete temp;
            size_--;
        }
    }

    void insert(const int index, const T value) {
        if (index == 0) {
            push_front(value);
            return;
        }
        if (index > 0 && index <= size_) {
            Node* temp = head_;
            for (int i = 0; i < index - 1; i++) {
                temp = temp->next;
            }
            temp->next = new Node{ value, temp->next };
            size_++;
        }
    }

    void erase(const int index) {
        if (index == 0) {
            pop_front();
            return;
        }
        Node* temp = head_;
        for (int i = 0; i < index - 1; i++) {
            temp = temp->next;
        }

        Node* buf = temp->next->next;
        delete temp->next;
        temp->next = buf;
        size_--;
    }

    T& operator[] (const int index) {
        if (index >= 0 && index < size_) {
            Node* temp = head_;
            for (int i = 0; i < index; i++) {
                temp = temp->next;
            }
            return temp->value;
        }
    }

    const T& operator[] (const int index) const {
        if (index >= 0 && index < size_) {
            Node* temp = head_;
            for (int i = 0; i < index; i++) {
                temp = temp->next;
            }
            return temp->value;
        }
    }

    bool operator==(const ForwardList& other) const {
        if (size_ != other.size_) {
            return false;
        }
        Node* temp = head_;
        Node* other_temp = other.head_;

        while (temp != nullptr) {
            if (temp->value != other_temp->value) {
                return false;
            }
            temp = temp->next;
            other_temp = other_temp->next;
        }
        return true;
    }

    bool operator!=(const ForwardList& other) const {
        return !(*this == other);
    }

    void print() {
        Node* temp = head_;
        while (temp != nullptr) {
            cout << temp->value << " ";
            temp = temp->next;
        }
        cout << endl;
    }

    T& front() {
        if (head_ != nullptr) {
            return head_->value;
        }
    }

    const T& front() const {
        if (head_ != nullptr) {
            return head_->value;
        }
    }

    int find(const T value) {
        Node* temp = head_;

        for (int i = 0; i < size_; i++) {
            if (temp->value == value) {
                return i;
            }
            temp = temp->next;
        }
        return -1;
    }

    void clear() {
        while (head_ != nullptr) {
            pop_front();
        }
    }

    int size() const {
        return size_;
    }

    ~ForwardList() {
        clear();
    }

private:
    int size_;
    Node* head_;
};

int main() {

    ForwardList<int> list1;

    for (int i = 0; i < 10; i++) {
        list1.push_front(i + 1);
    }
    list1.print();
    cout << list1.size() << endl;

    for (int i = 0; i < 3; i++) {
        list1.pop_front();
    }
    list1.print();
    cout << list1.size() << endl;

    cout << list1.front() << endl;

    list1.insert(3, 15);

    list1.erase(2);

    list1.front() = 22;

    list1.print();

    cout << list1.find(4) << endl;

    //list1.clear();

    //list1.print();

    cout << list1[3] << endl;

    ForwardList<int> list2;

    cout << (list1 == list2) << endl;

    cout << (list1 != list2) << endl;

}