module;

#include <cassert>
#include <memory>
#include <SDL3/SDL.h>

export module core.engine;

import config;
import core.renderer;
import wrappers.sdl;

export namespace core
{
    using Window = sdl::Window;

    class Engine
    {
        // Whether this class is currently instantiated (to prevent multiple instances)
        static bool instantiated_;

        // If this is set to false, the application will exit
        bool keep_running_ = true;

        Window window_;
        Renderer renderer_;

        // Private constructor
        Engine(Window&& window, Renderer&& renderer)
            : window_{std::move(window)},
              renderer_{std::move(renderer)}
        {
            instantiated_ = true;
        }

        public:
            Engine() = delete;

            // No copy or move operations
            Engine(const Engine&) = delete;
            Engine& operator=(const Engine&) = delete;
            Engine(Engine&&) = delete;
            Engine& operator=(Engine&&) = delete;

            ~Engine()
            {
                instantiated_ = false;
            }

            static std::unique_ptr<Engine> create()
            {
                // Prevent the class from being instantiated multiple times
                assert(!instantiated_);

                auto [sdl_window, sdl_renderer] = sdl::CreateWindowAndRenderer(
                    config::get_window_title(),
                    config::window_width,
                    config::window_height,
                    0
                );

                return std::unique_ptr<Engine>{
                    new Engine{
                        std::move(sdl_window),
                        Renderer{std::move(sdl_renderer)}
                    }
                };
            }

            bool keep_running() const
            {
                return keep_running_;
            }

            Window& get_window()
            {
                return window_;
            }

            Renderer& get_renderer()
            {
                return renderer_;
            }

            // Handles an SDL event. Returns true if the event has been handled.
            bool handle_event(const sdl::Event* event)
            {
                if (event->type == SDL_EVENT_QUIT) {
                    // Exit the application
                    keep_running_ = false;
                    return true;
                }

                return false;
            }

            void update()
            {
            }

            void shutdown()
            {
            }
    };

    bool Engine::instantiated_ = false;
}