#include <iostream>
#include <set>
#include <memory>
#include <vector>
#include <map>

// LPDIRECT3DDEVICE9
class Device { };



class OverlayObject
{
    class RenderInterface * const _interface;
    int _id;

protected:
    explicit OverlayObject(class RenderInterface * const interface, int id) : _interface(interface), _id(id) { }
    virtual ~OverlayObject() { }

public:
    class RenderInterface * const interface() { return _interface; }
    int id() const { return _id; }
};

class TextOverlay : public OverlayObject
{
    std::string _font;
public:
    explicit TextOverlay(class RenderInterface * const interface, int id, std::string font) : OverlayObject(interface, id), _font(font) { std::cout << "TextOverlay::TextOverlay" << std::endl; }
    ~TextOverlay() { std::cout << "~TextOverlay" << std::endl; }
};

class RenderInterface
{
    typedef std::shared_ptr<OverlayObject> overlay_ptr;
    typedef std::set<overlay_ptr> overlay_set;

    Device *_device;
    overlay_set overlays;
public:
    explicit RenderInterface(Device * const dev) : _device(dev) { }

    template<typename T, typename ...Args> std::shared_ptr<T> createOverlay(Args... params)
    {
        int id = 0;
        while (true)
        {
            bool flag = false;
            for (overlay_ptr ptr : overlays)
                if (id == ptr->id())
                    flag = true;

            if (!flag)
                break;

            id ++;
        }

        std::shared_ptr<T> ptr = std::make_shared<T>(this, id, params...);
        overlays.insert(ptr);

        return ptr;
    }

    template<typename T> void deleteOverlay(overlay_ptr obj)
    {
        overlays.erase(obj);
    }

    void deleteOverlay(int id)
    {
        for (auto obj : overlays)
        {
            if (obj->id() == id)
            {
                overlays.erase(obj);
                return;
            }
        }
    }

    template<typename T> std::shared_ptr<T> ptrByID(int id)
    {
        for (auto obj : overlays)
        {
            if (obj->id() == id)
            {
                return std::dynamic_pointer_cast<T>(obj);
            }
        }

        return nullptr;
    }
};

void main()
{
    // Könnte LPDIRECT3DDEVICE9 sein
    Device dev;

    RenderInterface interface(&dev);
    std::shared_ptr<TextOverlay> text_1 = interface.createOverlay<TextOverlay>("Arial");
    std::shared_ptr<TextOverlay> text_2 = interface.createOverlay<TextOverlay>("Arial");

    std::cout << text_1->id() << ' ' << text_2->id() << std::endl;

    std::shared_ptr<TextOverlay> text_3 = interface.ptrByID<TextOverlay>(0);
    if (text_3 == text_1)
        std::cout << "Gleich!" << std::endl;

    std::cin.get();
}