module;

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

export module game.game;

import core.engine;
import core.render_server;
import game.sprite;
import wrappers.sdl;
import wrappers.sdl_image;

export namespace game
{
    class Game
    {
        // Whether this class is currently instantiated (to prevent multiple instances)
        static bool instantiated_;

        // Reference to the engine
        core::Engine& engine_;

        // Sprites for testing
        Sprite player_sprite_;
        std::vector<Sprite> sprites_;

        // Private constructor
        explicit Game(core::Engine& engine)
            : engine_(engine),
              player_sprite_{
                  engine_.get_render_server().load_texture("assets/neocat.png"),
                  sdl::FRect{0, 0, 100, 100}
              }
        {}

        public:
            Game() = delete;

            // No copy or move operations because we have a reference to the engine
            Game(const Game&) = delete;
            Game& operator=(const Game&) = delete;
            Game(Game&&) = delete;
            Game& operator=(Game&&) = delete;

            ~Game()
            {
                instantiated_ = false;
            }

            static std::unique_ptr<Game> create(core::Engine& engine)
            {
                // Prevent the class from being instantiated multiple times
                assert(!instantiated_);
                return std::unique_ptr<Game>{
                    new Game(engine)
                };
            }

            // Handles an SDL event. Returns true if the event has been handled.
            bool handle_event(const sdl::Event* event)
            {
                if (event->type == SDL_EVENT_MOUSE_MOTION) {
                    player_sprite_.move(
                        event->motion.x - 50,
                        event->motion.y - 50
                    );
                    return true;
                }

                if (event->type == SDL_EVENT_MOUSE_BUTTON_UP) {
                    sprites_.emplace_back(
                        engine_.get_render_server().load_texture("assets/neofox.png"),
                        sdl::FRect{
                            event->motion.x - 50,
                            event->motion.y - 50,
                            100, 100
                        }
                    );
                    return true;
                }

                return false;
            }

            void update()
            {
            }

            void render() const
            {
                const auto& render_server = engine_.get_render_server();
                render_server.start_frame();

                for (const Sprite& sprite : sprites_) {
                    sprite.draw(render_server);
                }
                player_sprite_.draw(render_server);

                render_server.finish_frame();
            }

            void shutdown()
            {
            }
    };

    bool Game::instantiated_ = false;
}