module;

#include <cassert>
#include <memory>

export module core.engine;

import config;
import core.render_server;
import wrappers.sdl;

export namespace core
{
    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;

        sdl::Window window_;
        RenderServer render_server_;

        // Private constructor
        Engine(sdl::Window&& window, sdl::Renderer&& renderer)
            : window_{std::move(window)},
              render_server_{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),
                        std::move(sdl_renderer)
                    }
                };
            }

            bool keep_running() const
            {
                return keep_running_;
            }

            sdl::Window& get_window()
            {
                return window_;
            }

            RenderServer& get_render_server()
            {
                return render_server_;
            }

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

                return false;
            }

            void update()
            {
            }

            void shutdown()
            {
            }
    };

    bool Engine::instantiated_ = false;
}