#pragma once

#include "precompiled.hpp"

namespace twg7
{
    template<class T> class Manager
    {
    protected:
        std::map<std::pair<std::string, int>, T*> objects;
        std::function<T*(const std::string&)> constructor;

    public:
        Manager(const std::function<T*(const std::string&)> &constructor = [](const std::string &name) -> T*
        {
            return new T(name);
        }) :
                constructor(constructor)
        {

        }

        ~Manager()
        {
            this->for_each_ptr([](T *object) -> void
            {
                delete object;
            });
        }

        T* add_ptr(const std::string &name, int id, bool addToList = true)
        {
            if (this->objects.count({name, id}) > 0) throw std::runtime_error("Object (" + name + "; " + std::to_string(id) + ") already in list!");
            T *element = this->constructor(name);
            if (addToList) this->objects.insert({std::make_pair(name, id), element});
            return element;
        }

        T* add_ptr(const std::string &name)
        {
            return this->add_ptr(name, this->objects.size());
        }

        T& add(const std::string &name, int id)
        {
            return *(this->add_ptr(name, id));
        }

        T& add(const std::string &name)
        {
            return *(this->add_ptr(name));
        }

        T* get_ptr(const std::string &name, int id = 0)
        {
            if (this->objects.count({name, id}) == 0) return this->add_ptr(name, id);
            return this->objects[{name, id}];
        }

        T& get(const std::string &name, int id = 0)
        {
            return *(this->get_ptr(name, id));
        }

        void for_each_ptr(const std::function<void(T*)> &processor)
        {
            for (std::pair<std::pair<std::string, int>, T*> pair : this->objects)
            {
                processor(pair.second);
            }
        }

        void for_each(const std::function<void(T&)> &processor)
        {
            this->for_each_ptr([&processor](T *object) -> void
            {
                processor(*object);
            });
        }
    };
}