#ifndef CONTAINERS_HPP_
#define CONTAINERS_HPP_

#include <functional>
#include <fstream>

namespace containers
{

template <typename T>
struct Node
{
    Node<T> *next;
    T value;

    explicit Node(T v, Node<T> *n) : next{n}, value{v} {}
};

template <typename T>
class Container
{
protected:
    Node<T> *head;
    Node<T> *tail;

public:
    Container() : head{nullptr}, tail{nullptr} {}

    virtual void push(T i) = 0;

    virtual ~Container()
    {
        auto tmp = head;
        while (tmp) {
            auto next = tmp->next;
            delete tmp;
            tmp = next;
        }
    }

    bool empty() const
    {
        return head == nullptr;
    }

    template <typename T_ = T,
        typename std::enable_if<std::is_arithmetic<T_>::value, T_>::type* = nullptr>
    void load(std::string filepath)
    {
        std::string s;
        std::ifstream f;
        f.open(filepath);
        while (std::getline(f, s))
            push(std::stoi(s));
    }

    template <typename T_ = T,
        typename std::enable_if<std::is_same<T_, std::string>::value, T_>::type* = nullptr>
    void load(std::string filepath)
    {
        std::string s;
        std::ifstream f;
        f.open(filepath);
        while (std::getline(f, s))
            push(s);
    }

    template <typename T_ = T,
        typename std::enable_if<!std::is_arithmetic<T_>::value, T_>::type*        = nullptr,
        typename std::enable_if<!std::is_same<T_, std::string>::value, T_>::type* = nullptr>
    void load(std::string filepath, std::function<T(const std::string&)> callback)
    {
        std::string s;
        std::ifstream f;
        f.open(filepath);
        while (std::getline(f, s))
            push(callback(s));
    }

    void save(std::string filepath) const
    {
        std::ifstream f;
        f.open(filepath);
        map([&f](const T& i) { f << i << '\n'; });
        f.close();
    }

    void save(std::string filepath, std::function<T(const std::string&)> callback) const
    {
        std::ifstream f;
        f.open(filepath);
        map([&f, &callback](const T& i) { f << callback(i) << '\n'; });
        f.close();
    }

    void map(std::function<void(T)> f) const
    {
        for(auto i = head; i; i = i->next)
            f(i->value);
    }

    void map(std::function<void(T&)> f)
    {
        for(auto i = head; i; i = i->next)
            f(i->value);
    }

    void map(std::function<void(const T&)> f) const
    {
        for(auto i = head; i; i = i->next)
            f(i->value);
    }

};

template <typename T>
class Stack : public Container<T>
{
    using Container<T>::head;

    void deepcopy(Node<T> *n)
    {
        if(n) {
            deepcopy(n->next);
            push(n->value);
        }
    }

public:
    Stack() : Container<T>{} {}

    template <typename ... Args>
    Stack(Args ... args) : Container<T>{}
    {
        push(args...);
    }

    Stack(const Stack &other) : Container<T>{}
    {
        deepcopy(other.head);
    }

    Stack& operator=(const Stack &other) = default;

    template <typename ... Args>
    void push(T i, Args ... args)
    {
        push(i);
        push(args...);
    }

    void push(T i)
    {
        head = new Node<T>{i, head};
    }

    T pop()
    {
        if(this->empty()) return T{};
        auto tmp = head;
        auto v = tmp->value;
        head = head->next;
        delete tmp;
        return v;
    }

};

template <typename T>
class Queue : public Container<T>
{
    using Container<T>::head;
    using Container<T>::tail;

    void deepcopy(Node<T> *n)
    {
        if(n) {
            push(n->value);
            deepcopy(n->next);
        }
    }

public:
    Queue() : Container<T>{} {}

    template <typename ... Args>
    Queue(Args ... args) : Container<T>{}
    {
        push(args...);
    }

    Queue(const Queue &other) : Container<T>{}
    {
        deepcopy(other.head);
    }

    Queue& operator=(const Queue &other) = default;

    template <typename ... Args>
    void push(T i, Args ... args)
    {
        push(i);
        push(args...);
    }

    void push(T i)
    {
        if (this->empty()) {
            auto tmp = new Node<T>{i, head};
            head = tail = tmp;
        } else {
            auto tmp = new Node<T>{i, nullptr};
            tail->next = tmp;
            tail = tmp;
        }
    }

    T pop()
    {
        if(this->empty()) return T{};
        auto tmp = head;
        auto v = tmp->value;
        head = head->next;
        if (this->empty())
            tail = nullptr;
        delete tmp;
        return v;
    }

};

template <typename T>
class List : public Container<T>
{
    using Container<T>::head;

    static const std::function<bool(const T&, const T&)> create_compare()
    {
        static auto c = [](const T &lhs, const T &rhs) -> bool { return lhs > rhs; };
        return c;
    }

    const std::function<bool(const T&, const T&)> compare = create_compare();

    void deepcopy(Node<T> *n)
    {
        if(n) {
            push(n->value);
            deepcopy(n->next);
        }
    }

public:
    List() : Container<T>{} {}

    List(std::function<bool(const T&, const T&)> compare_) : Container<T>{} , compare{compare_} {}

    template <typename ... Args>
    List(T i, Args ... args) : Container<T>{}
    {
        push(i);
        push(args...);
    }

    List(const List &other) : Container<T>{}
    {
        deepcopy(other.head);
    }

    List& operator=(const List &other) = default;

    template <typename ... Args>
    void push(T i, Args ... args)
    {
        push(i);
        push(args...);
    }

    void push(T i)
    {
        if (this->empty() || !compare(i, head->value)) {
            head = new Node<T>{i, head};
        } else {
            Node<T> *cur = head;
            while (cur->next && compare(i, cur->next->value)) cur = cur->next;
            cur->next = new Node<T>{i, cur->next};
        }
    }

    T pop()
    {
        return pop(1);
    }

    T pop(int pos)
    {
        if (this->empty()) return T{};
        if (pos == 1) {
            auto tmp = head;
            auto v = head->value;
            head = head->next;
            delete tmp;
            return v;
        } else {
            auto cur = head;
            for (int i = 2; i < pos && cur->next; ++i, cur = cur->next);
            if (!cur->next) return T{};
            auto tmp = cur->next;
            auto v = cur->next->value;
            cur->next = cur->next->next;
            delete tmp;
            return v;
        }
    }

    void erase(int v)
    {
        int index = 1;
        for (auto i = head; i; i = i->next, ++index)
            if (i->value == v)
                pop(index);
    }

};

} // namespace containers

#endif /* CONTAINERS_HPP_ */