// entity.hpp - Clase base abstracta para todas las entidades del juego
// © 2025 Orni Attack - Arquitectura de entidades
//
// Cada Entity incluye un Physics::RigidBody como member. Las entidades que
// se simulen físicamente lo configuran en init() y registran en el
// PhysicsWorld del GameScene. Las que no, ignoran el body (queda con
// defaults inocuos: mass=1, radius=0).
//
// Flujo por frame (gestionado por GameScene):
//   1. entity.update(dt)        — aplicar fuerzas, decidir lógica
//   2. world.update(dt)         — integrar bodies, resolver colisiones
//   3. entity.postUpdate(dt)    — sincronizar mirror (center_, angle_)

#pragma once

#include <memory>

#include "core/graphics/shape.hpp"
#include "core/physics/rigid_body.hpp"
#include "core/rendering/render_context.hpp"
#include "core/types.hpp"

namespace Entities {

class Entity {
    public:
        virtual ~Entity() = default;

        // Interfaz principal (virtual pur)
        virtual void init() = 0;
        virtual void update(float delta_time) = 0;
        virtual void draw() const = 0;
        [[nodiscard]] virtual bool isActive() const = 0;

        // Sincronización post-física (override opcional).
        // Llamado por GameScene tras world.update(). Default: no-op.
        virtual void postUpdate(float /*delta_time*/) {}

        // Interfaz de colisión (override opcional)
        [[nodiscard]] virtual float getCollisionRadius() const { return 0.0F; }
        [[nodiscard]] virtual bool isCollidable() const { return false; }

        // Getters comunes (inline, sin overhead)
        [[nodiscard]] const Vec2& getCenter() const { return center_; }
        [[nodiscard]] float getAngle() const { return angle_; }
        [[nodiscard]] float getBrightness() const { return brightness_; }
        [[nodiscard]] const std::shared_ptr<Graphics::Shape>& getShape() const { return shape_; }

        // Acceso al cuerpo físico (Fase 6+). El PhysicsWorld lo registra
        // por puntero; la entidad lo configura en init().
        [[nodiscard]] auto getBody() -> Physics::RigidBody& { return body_; }
        [[nodiscard]] auto getBody() const -> const Physics::RigidBody& { return body_; }

    protected:
        // Estado común (acceso directo, sin overhead)
        Rendering::Renderer* renderer_;
        std::shared_ptr<Graphics::Shape> shape_;
        Vec2 center_;
        float angle_{0.0F};
        float brightness_{1.0F};

        // Cuerpo físico (Fase 6). Las entidades que se mueven por
        // física actualizan center_/angle_ en postUpdate() desde body_.
        Physics::RigidBody body_;

        // Constructor protegido (clase abstracta)
        Entity(Rendering::Renderer* renderer = nullptr)
            : renderer_(renderer),
              center_({.x = 0.0F, .y = 0.0F}) {}
};

}  // namespace Entities
