core/Layer.hpp

#pragma once

#include <functional>
#include <iostream>
#include <limits>
#include <memory>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>

#include <SFML/Graphics/Drawable.hpp>
#include <SFML/Graphics/Rect.hpp>
#include <SFML/System/Vector2.hpp>

#include <NasNas/core/data/Introspection.hpp>

namespace ns {
    class Scene;

    class Layer {
    public:
        explicit Layer(std::string name);

        Layer(const Layer&) = delete;
        Layer(Layer&&) = default;
        Layer& operator=(const Layer&) = delete;
        Layer& operator=(Layer&&) = default;

        void clear();

        template <typename T, typename = std::enable_if_t<std::is_base_of_v<sf::Drawable, T>>>
        void add(const T& dr);

        template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>, typename = std::enable_if_t<std::is_base_of_v<sf::Drawable, std::remove_pointer_t<T>>>>
        void add(T dr);

        template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>, typename = std::enable_if_t<std::is_base_of_v<sf::Drawable, std::remove_pointer_t<T>>>>
        void addRaw(T dr);

        template <typename T, typename = std::enable_if_t<std::is_base_of_v<sf::Drawable, T>>>
        void remove(const T& dr);

        template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>, typename = std::enable_if_t<std::is_base_of_v<sf::Drawable, std::remove_pointer_t<T>>>>
        void remove(T dr);

        auto allDrawables() const -> const std::vector<const sf::Drawable*>&;

        auto getDrawablePosition(const sf::Drawable* dr) const -> sf::Vector2f;
        auto getDrawableBounds(const sf::Drawable* dr) const -> sf::FloatRect;

        void ySort();

        auto getName() const -> const std::string&;

    private:
        std::string m_name;
        std::vector<const sf::Drawable*> m_drawables;
        std::vector<std::unique_ptr<const sf::Drawable>> m_gc;
        std::unordered_map<const sf::Drawable*, std::function<sf::Vector2f()>> m_position_getters;
        std::unordered_map<const sf::Drawable*, std::function<sf::FloatRect()>> m_bounds_getters;
    };

    template <typename T, typename>
    void Layer::add(const T& dr) {
        static constexpr auto float_min = std::numeric_limits<float>::lowest();
        static constexpr auto float_max = std::numeric_limits<float>::max();

        m_drawables.emplace_back(&dr);
        if constexpr(introspect::has_getPosition_v<T>)
            m_position_getters[&dr] = [&dr]() { return dr.getPosition(); };
        else
            m_position_getters[&dr] = []() { return sf::Vector2f{0, float_min}; };

        if constexpr(introspect::has_getGlobalBounds_v<T>)
            m_bounds_getters[&dr] = [&dr]() { return dr.getGlobalBounds(); };
        else if constexpr(introspect::has_getBounds_v<T>)
            m_bounds_getters[&dr] = [&dr]() { return dr.getBounds(); };
        else
            m_bounds_getters[&dr] = []() { return sf::FloatRect(float_min/2.f, float_min/2.f, float_max, float_max); };
    }

    template <typename T, typename, typename>
    void Layer::add(const T dr) {
        add(*dr);
        m_gc.emplace_back(dr);
    }

    template <typename T, typename, typename>
    void Layer::addRaw(const T dr) {
        add(*dr);
    }

    template <typename T, typename>
    void Layer::remove(const T& dr) {
        auto it = std::find(m_drawables.begin(), m_drawables.end(), &dr);
        if (it != m_drawables.end()) {
            m_drawables.erase(it);
            m_position_getters.erase(&dr);
            m_bounds_getters.erase(&dr);
        }
        else
            std::cout << "Warning : trying to remove a non existent drawable from Layer.\n";
    }

    template <typename T, typename, typename>
    void Layer::remove(const T dr) {
        remove(*dr);
        m_gc.erase(
            std::remove_if(m_gc.begin(), m_gc.end(), [dr](auto& uptr) { return uptr.get() == dr; }),
            m_gc.end()
        );
    }

}