App.hpp

#pragma once


#include <array>
#include <functional>
#include <list>
#include <memory>
#include <stack>
#include <string>
#include <type_traits>
#include <vector>

#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/RenderTexture.hpp>
#include <SFML/System/Clock.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/Window/Event.hpp>

#include <NasNas/core/data/Config.hpp>
#include <NasNas/core/data/Rect.hpp>
#include <NasNas/core/data/ShaderHolder.hpp>

#include <NasNas/core/AppState.hpp>
#include <NasNas/core/Camera.hpp>
#include <NasNas/core/Debug.hpp>
#include <NasNas/core/Scene.hpp>
#include <NasNas/core/Window.hpp>

namespace ns {

    class StateMachineApp;
    class StateStackApp;

    class App : public AppStateInterface, public ShaderHolder {
        friend StateMachineApp;
        friend StateStackApp;
    public:
        App();

        App(std::string  title, sf::Vector2u resolution,
            float scale=1.f,
            int fps=Settings::user_config.frame_rate,
            int ups=Settings::user_config.update_rate
        );

        virtual ~App();

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

        auto getWindow() -> AppWindow&;

        auto getMousePosition() const -> sf::Vector2f;

        auto getMousePosition(Camera& cam) const -> sf::Vector2f;

        auto getTouchPosition(int finger) const -> sf::Vector2f;

        auto getTouchPosition(int finger, Camera& cam) const -> sf::Vector2f;


        auto allScenes() -> std::list<Scene>&;

        auto getScene(const std::string& name) -> Scene&;

        auto allCameras() -> std::list<Camera>&;

        auto getCamera(const std::string& name) -> Camera&;

        void toggleFullscreen();

        auto getDt() const -> float;

        void run();

    protected:

        auto createScene(const std::string& name) -> Scene&;

        auto createCamera(
                const std::string& name, int order,
                const ns::IntRect& view={{0, 0}, sf::Vector2i(Settings::user_config.resolution)},
                const ns::FloatRect& viewport={0, 0, 1.f, 1.f}
        ) -> Camera&;

        auto createCamera(const std::string& name, int order, const ns::FloatRect& viewport) -> Camera&;

        void addDebugText(const std::string& label, const sf::Vector2f& position, const sf::Color& color = ns::DebugTextInterface::color);

        template<typename T>
        void addDebugText(const std::string& label, T* var_address, const sf::Vector2f& position, const sf::Color& color = ns::DebugTextInterface::color);

        template<typename T>
        void addDebugText(const std::string& label, std::function<T()> fn, const sf::Vector2f& position, const sf::Color& color = ns::DebugTextInterface::color);

        void sleep();

        void awake();

        void onEvent(const sf::Event& event) override;

        void update() override;

    private:
        AppWindow m_window;     
        sf::RenderTexture m_renderer;
        std::string m_title;    
        bool m_fullscreen;      
        int m_ups;              
        int m_fps;              
        sf::Clock m_fps_clock;  
        float m_dt;             
        bool m_sleeping = false;

        std::list<Camera> m_cameras;
        std::list<Scene> m_scenes;
        std::vector<std::unique_ptr<DebugTextInterface>> m_debug_texts;
        std::vector<sf::Vertex> m_debug_bounds;

        std::function<void(const sf::Event&)> m_cb_onevent=[](const sf::Event&){};
        std::function<void()> m_cb_update=[]{};
        std::function<void()> m_cb_prerender=[]{};

        static void storeInputs(const sf::Event& event);

        void render();

        void renderDebugBounds();
        void storeDrawableDebugRects(const ns::FloatRect& drawable_bounds, Camera& cam,
                                     const sf::FloatRect& render_bounds, sf::Vector2f& offset,
                                     const sf::FloatRect& global_vport, const sf::FloatRect& local_vport);
    };

    template<typename T>
    void App::addDebugText(const std::string& label, T* var_address, const sf::Vector2f& position, const sf::Color& color) {
        auto* dbg_txt = new DebugText<T>(label, var_address, position);
        dbg_txt->setFillColor(color);
        m_debug_texts.emplace_back(dbg_txt);
    }

    template<typename T>
    void App::addDebugText(const std::string& label, std::function<T()> fn, const sf::Vector2f& position, const sf::Color& color) {
        auto* dbg_txt = new DebugText<T>(label, fn, position);
        dbg_txt->setFillColor(color);
        m_debug_texts.emplace_back(dbg_txt);
    }

    class StateMachineApp : public App {
        std::unique_ptr<AppState> m_state = nullptr;
    public:
        using App::App;
        virtual void update() {}

        template <typename T, typename... Targs, typename = std::enable_if<std::is_base_of_v<AppState, T>>>
        void setState(Targs... args) {
            m_state.reset();
            m_state = std::make_unique<T>(std::forward<Targs>(args)...);
            m_state->setup();
            m_cb_onevent = [&](const auto& event) { m_state->onEvent(event); };
            m_cb_update = [&] { m_state->update(); };
            m_cb_prerender = [&] { m_state->preRender(); };
        }
    };

    class StateStackApp : public App {
        std::stack<std::unique_ptr<AppState>> m_state_stack;
    public:
        using App::App;
        virtual void update() {}

        template <typename T, typename... Targs, typename = std::enable_if<std::is_base_of_v<AppState, T>>>
        void pushState(Targs... args) {
            m_state_stack.emplace(std::make_unique<T>(std::forward<Targs>(args)...));
            m_state_stack.top()->setup();
            m_cb_onevent = [&](const sf::Event& event) { m_state_stack.top()->onEvent(event); };
            m_cb_update = [&] { m_state_stack.top()->update(); };
            m_cb_prerender = [&] { m_state_stack.top()->preRender(); };
        }

        inline void popState() {
            if (m_state_stack.empty())
                return;

            m_state_stack.pop();

            if (m_state_stack.empty()) {
                m_cb_onevent = [&](const sf::Event& event) {};
                m_cb_update = [&] {};
                m_cb_prerender = [&] {};
            } else {
                m_state_stack.top()->setup();
                m_cb_onevent = [&](const sf::Event& event) { m_state_stack.top()->onEvent(event); };
                m_cb_update = [&] { m_state_stack.top()->update(); };
                m_cb_prerender = [&] { m_state_stack.top()->preRender(); };
            }
        }
    };
}