#pragma once
#include <vector>
#include "extern.h"

class singleton;

class singleton_initliazer {
public:
    bool has_init(singleton* s);

    void init_singleton(singleton* s);

    template<class T>
    T* require() {
        auto instance = T::get();
        if (has_init(instance)) {
            return instance;
        }
        init_singleton(instance);
        return instance;
    }

    std::vector<singleton*> singletons_{};
};

class singleton_release_guard {
public:
    singleton_release_guard(bool begin_release)
        : begin_release_(begin_release) {
    }

    bool has_release(singleton* s);
    void release_singleton(singleton* s);

    template<class T>
    void require_release() {
        auto instance = T::get();
        if (has_release(instance)) {
            return;
        }
        release_singleton(instance);
    }

    std::vector<singleton*> release_singletons_{};
private:
    bool begin_release_;
};

class CORE_API singleton_manager {
public:
    static singleton_manager* get() {
        static singleton_manager instance;
        return &instance;
    }

    void add(singleton* s);

    void init();
    void release() const;

private:
    std::vector<singleton*> singletons_;
};