#pragma once

#include <memory>
#include <vector>

#include "game/bola.hpp"
#include "game/info.hpp"
#include "game/mapa.hpp"
#include "game/marcador.hpp"
#include "game/momia.hpp"
#include "game/prota.hpp"
#include "scenes/palette_fade.hpp"
#include "scenes/scene.hpp"

// Escena de gameplay pur. Reemplaça el vell `Go()` bloquejant amb
// l'interfície `scenes::Scene` tick-based: `onEnter()` arranca la
// música i un fade-in, el `tick()` avança un frame (Draw + Update
// gated per JG_ShouldUpdate), i quan la partida acaba fa un fade-out
// abans de retornar el next state.
//
// Tres fases internes:
//   1. FadingIn  — fade-in 32 passos mentre el render segueix viu.
//   2. Playing   — gameplay normal; `final_` es setja quan el prota mor
//                  o canvia de sala. `Update()` només avança cada 10 ms
//                  via `JG_ShouldUpdate` (ticker fix del jail).
//   3. FadingOut — fade-out 32 passos mantenint l'últim frame visible
//                  (substituïx el `JD8_FadeOut` bloquejant que feia el
//                  destructor legacy).
class ModuleGame : public scenes::Scene {
   public:
    ModuleGame();
    ~ModuleGame() override;

    void onEnter() override;
    void tick(int delta_ms) override;
    bool done() const override { return phase_ == Phase::Done; }
    int nextState() const override;

   private:
    enum class Phase {
        FadingIn,
        Playing,
        FadingOut,
        Done,
    };

    void Draw();    // render a `screen`; no crida JD8_Flip (ho fa el caller)
    void Update();  // gated per JG_ShouldUpdate

    void iniciarMomies();
    void applyFinalTransitions();  // muta info::ctx quan final_ passa a !=0

    Phase phase_{Phase::FadingIn};
    scenes::PaletteFade fade_;
    Uint8 final_{0};
    JD8_Surface gfx{nullptr};

    std::unique_ptr<Mapa> mapa;
    std::unique_ptr<Prota> sam;
    std::unique_ptr<Marcador> marcador;
    std::vector<std::unique_ptr<Momia>> momies;
    std::unique_ptr<Bola> bola;
};