#pragma once
#include <array>
#include <cstddef>
#include <functional>
#include <memory>
#include <mutex>
#include <string>

#include <game.hpp>
#include <mesh.hpp>

namespace openceg::render {
class InputMap;
}

namespace openceg {

class Actor {
   private:
    size_t id;
    std::string nickName_;
    mutable std::mutex transform_mutex_;
    std::array<float, 2> position_{0.0F, 0.0F};
    std::array<float, 2> facing_{1.0F, 0.0F};
    std::shared_ptr<Mesh> mesh_;

    float age_ = 0.0F;
    bool initialized_ = false;
    std::function<void(Actor&)> init_handler_;
    std::function<void(Actor&, float, const render::InputMap&)> tick_handler_;

   public:
    Actor() noexcept = default;
    virtual ~Actor() = default;

    Actor(const Actor&) = delete;
    Actor& operator=(const Actor&) = delete;
    Actor(Actor&&) noexcept = delete;
    Actor& operator=(Actor&&) noexcept = delete;

    Actor(std::string nickName, Game& game) {
        id = game.new_id();
        nickName_ = std::move(nickName);
    }

    Actor(std::string nickName, Game& game, std::shared_ptr<Mesh> mesh)
        : Actor(std::move(nickName), game) {
        mesh_ = std::move(mesh);
    }

    static Actor& getInstance() {
        static Actor instance;
        return instance;
    }

    const std::string& name() const { return nickName_; }

    float age() const { return age_; }

    void set_init_handler(std::function<void(Actor&)> handler) {
        init_handler_ = std::move(handler);
    }

    void set_tick_handler(
        std::function<void(Actor&, float, const render::InputMap&)> handler) {
        tick_handler_ = std::move(handler);
    }

    // 类似 Godot 的 _ready()。
    void initialize() {
        if (initialized_) {
            return;
        }
        initialized_ = true;
        if (init_handler_) {
            init_handler_(*this);
        }
    }

    // 类似 Godot 的 _process(delta)。
    void process(float dt, const render::InputMap& input) {
        age_ += dt;
        if (tick_handler_) {
            tick_handler_(*this, dt, input);
        }
    }

    std::array<float, 2> position() const {
        std::lock_guard<std::mutex> lock(transform_mutex_);
        return position_;
    }

    void set_position(std::array<float, 2> position) {
        std::lock_guard<std::mutex> lock(transform_mutex_);
        position_ = position;
    }

    std::array<float, 2> facing() const {
        std::lock_guard<std::mutex> lock(transform_mutex_);
        return facing_;
    }

    void set_facing(std::array<float, 2> facing) {
        std::lock_guard<std::mutex> lock(transform_mutex_);
        facing_ = facing;
    }

    const std::shared_ptr<Mesh>& mesh() const { return mesh_; }
    void set_mesh(std::shared_ptr<Mesh> mesh) { mesh_ = std::move(mesh); }
};

}  // namespace openceg