// IWYU pragma: no_include <bits/std_abs.h>
#include "game/entities/player.hpp"

#include <algorithm>  // Para max, min
#include <cmath>      // Para ceil, abs

#include "core/audio/audio.hpp"                       // Para Audio
#include "core/input/input.hpp"                       // Para Input, InputAction
#include "core/rendering/sprite/animated_sprite.hpp"  // Para AnimatedSprite
#include "core/resources/resource_cache.hpp"          // Para Resource
#include "game/defaults.hpp"                          // Para Defaults::Game::Player, Defaults::Sound::Files
#include "game/entities/solid_actor.hpp"              // Para SolidActor
#include "game/gameplay/room.hpp"                     // Para Room
#include "game/gameplay/solid_actor_manager.hpp"      // Para SolidActorManager
#include "game/gameplay/tile_collider.hpp"            // Para TileCollider
#include "game/options.hpp"                           // Para Cheat, Options
#include "utils/defines.hpp"                          // Para PlayArea, Collision

#ifdef _DEBUG
#include "core/system/debug.hpp"  // Para Debug
#endif

// Helpers NONE-aware para combinar un hit del TileCollider con un hit del
// SolidActorManager. Devuelven el valor más "clampante" (más a la derecha
// para left-wall, más a la izquierda para right-wall, más abajo para ceiling).
namespace {
    auto combineLeftWall(float tile_hit, float actor_hit) -> float {
        if (tile_hit == Collision::NONE) { return actor_hit; }
        if (actor_hit == Collision::NONE) { return tile_hit; }
        return std::max(tile_hit, actor_hit);
    }

    auto combineRightWall(float tile_hit, float actor_hit) -> float {
        if (tile_hit == Collision::NONE) { return actor_hit; }
        if (actor_hit == Collision::NONE) { return tile_hit; }
        return std::min(tile_hit, actor_hit);
    }

    auto combineCeiling(float tile_hit, float actor_hit) -> float {
        if (tile_hit == Collision::NONE) { return actor_hit; }
        if (actor_hit == Collision::NONE) { return tile_hit; }
        return std::max(tile_hit, actor_hit);
    }
}  // namespace

// ============================================================================
// Constructor
// ============================================================================

Player::Player(const Data& player)
    : room_(player.room) {
    initSprite(player.animations_path);
    applySpawnValues(player.spawn_data);
    placeSprite();
    initSounds();
    previous_state_ = state_;
}

// ============================================================================
// Render
// ============================================================================

void Player::render() {
    sprite_->render();
}

// ============================================================================
// Update — pipeline principal (6 fases)
// ============================================================================

void Player::update(float delta_time) {
    if (is_paused_) { return; }

    // 0. Carry de plataforma móvil (SolidActor con CARRY_ON_TOP).
    //    Snap absoluto del eje Y al top del AABB y desplazamiento horizontal
    //    por el delta del último frame del actor. Esto mantiene al Player
    //    pegado a la plataforma cuando sube/baja y lo arrastra lateralmente.
    if (current_carrier_ != nullptr) {
        const auto& aabb = current_carrier_->getAABB();
        x_ += current_carrier_->getLastDelta().x;
        y_ = aabb.y - HEIGHT;
    }

    // 1. Leer input
    handleInput();

    // 2. Calcular velocidades
    updateVelocity(delta_time);
    if (state_ == State::ON_AIR) {
        applyGravity(delta_time);
    }

    // 3. Saltar o caer a través de plataformas/slopes
    handleJumpAndDrop();

    // 4. Aplicar movimiento con colisión
    moveHorizontal(delta_time);
    moveVertical(delta_time);

    // 5. Detectar caída
    checkFalling();

    // 6. Kill tiles
    const auto& ktc = room_->getTileCollider();
    if (ktc.touchesKillTile(x_, y_, WIDTH, HEIGHT)) {
        markAsDead();
    }

    // 7. Finalizar
    syncSpriteAndCollider();
    animate(delta_time);
    border_ = handleBorders();

#ifdef _DEBUG
    Debug::get()->set("P.X", std::to_string(static_cast<int>(x_)));
    Debug::get()->set("P.Y", std::to_string(static_cast<int>(y_)));
    Debug::get()->set("P.LGP", std::to_string(last_grounded_position_));
    switch (state_) {
        case State::ON_GROUND:
            Debug::get()->set("P.STATE", "ON_GROUND");
            break;
        case State::ON_SLOPE:
            Debug::get()->set("P.STATE", "ON_SLOPE");
            break;
        case State::ON_AIR:
            Debug::get()->set("P.STATE", "ON_AIR");
            break;
    }
#endif
}

// ============================================================================
// Fase 1: Input
// ============================================================================

void Player::handleInput() {
    if (ignore_input_) { return; }
    if (Input::get()->checkAction(InputAction::LEFT)) {
        wanna_go_ = Direction::LEFT;
    } else if (Input::get()->checkAction(InputAction::RIGHT)) {
        wanna_go_ = Direction::RIGHT;
    } else {
        wanna_go_ = Direction::NONE;
    }

    const bool JUMP_PRESSED = Input::get()->checkAction(InputAction::JUMP);
    wanna_jump_ = JUMP_PRESSED && !jump_held_;
    jump_held_ = JUMP_PRESSED;

    const bool DOWN_PRESSED = Input::get()->checkAction(InputAction::DOWN);
    wanna_down_ = DOWN_PRESSED && !down_held_;
    down_held_ = DOWN_PRESSED;
}

// ============================================================================
// Fase 2: Velocidades
// ============================================================================

auto Player::computeHorizontalTarget() const -> float {
    switch (wanna_go_) {
        case Direction::LEFT:
            return -HORIZONTAL_VELOCITY;
        case Direction::RIGHT:
            return HORIZONTAL_VELOCITY;
        default:
            return 0.0F;
    }
}

void Player::updateFacing(float target) {
    if (state_ == State::ON_AIR) { return; }

    // Detectar cambio de dirección (solo en suelo — en el aire no se gira)
    if (target != 0.0F) {
        const Direction NEW_FACING = (target > 0.0F) ? Direction::RIGHT : Direction::LEFT;
        if (NEW_FACING != facing_) {
            facing_ = NEW_FACING;
            turning_ = true;
            sprite_->resetAnimation();
        }
    }

    // Orientación del sprite
    if (target > 0.0F) {
        sprite_->setFlip(Flip::RIGHT);
    } else if (target < 0.0F) {
        sprite_->setFlip(Flip::LEFT);
    }
}

void Player::applyAirInertia(float target, float step) {
    // En el aire, permitir mantener velocidad boosteada si vamos en la misma dirección
    float air_target = target;
    if ((target > 0.0F && vx_ > target) || (target < 0.0F && vx_ < target)) {
        air_target = vx_;
    }
    if (vx_ < air_target) {
        vx_ = std::min(vx_ + step, air_target);
    } else if (vx_ > air_target) {
        vx_ = std::max(vx_ - step, air_target);
    }
}

void Player::applyGroundInertia(float target, float step, float delta_time) {
    if (target != 0.0F) {
        // Reset al cambiar de dirección: un giro breve también para en seco.
        if (vx_ != 0.0F && ((target > 0.0F) != (vx_ > 0.0F))) {
            walk_time_ = 0.0F;
        }
        vx_ = target;
        walk_time_ += delta_time;
        return;
    }
    if (walk_time_ < WALK_INERTIA_THRESHOLD) {
        // Tap corto: parada seca, sin inercia (permite pasos finos).
        vx_ = 0.0F;
        walk_time_ = 0.0F;
        return;
    }
    if (vx_ > 0.0F) {
        vx_ = std::max(vx_ - step, 0.0F);
    } else if (vx_ < 0.0F) {
        vx_ = std::min(vx_ + step, 0.0F);
    }
    if (vx_ == 0.0F) { walk_time_ = 0.0F; }
}

void Player::updateVelocity(float delta_time) {
    const float TARGET = computeHorizontalTarget();
    updateFacing(TARGET);

    // Inercia: aire = gradual ambas direcciones, suelo = instantáneo arranque, gradual frenada
    const float STEP = HORIZONTAL_ACCEL * delta_time;
    if (state_ == State::ON_AIR) {
        applyAirInertia(TARGET, STEP);
    } else {
        applyGroundInertia(TARGET, STEP, delta_time);
    }
}

void Player::applyGravity(float delta_time) {
    const float GRAVITY = (vy_ < 0.0F && !jump_held_)
        ? GRAVITY_FORCE * LOW_JUMP_GRAVITY_MULT
        : GRAVITY_FORCE;
    vy_ += GRAVITY * delta_time;
    vy_ = std::min(vy_, MAX_VY);
}

// ============================================================================
// Fase 3: Saltar y drop-through
// ============================================================================

void Player::handleJumpAndDrop() {
    if (state_ == State::ON_AIR) { return; }

    if (wanna_jump_) {
        // No saltar si hay techo justo encima (pasillo de altura justa).
        // Sin esta comprobación se reproducían sonido de salto + landing y un frame
        // de salto antes de colisionar inmediatamente con el techo.
        const auto& tc = room_->getTileCollider();
        if (tc.checkCeiling(x_, y_ - 1, WIDTH) != Collision::NONE) {
            return;
        }
        startJump();
        return;
    }

    // Drop-through: plataforma passable
    if (wanna_down_ && state_ == State::ON_GROUND) {
        const auto& tc = room_->getTileCollider();
        float foot_y = y_ + HEIGHT;
        int foot_row = tc.toTile(static_cast<int>(foot_y));
        int left_col = tc.toTile(static_cast<int>(x_));
        int right_col = tc.toTile(static_cast<int>(x_ + WIDTH - 1));

        for (int col = left_col; col <= right_col; ++col) {
            if (tc.getTileAt(col, foot_row) == TileCollider::Tile::PASSABLE) {
                y_ += 1.0F;
                vy_ = 0.0F;
                transitionToState(State::ON_AIR);
                return;
            }
        }
    }
}

void Player::startJump() {
    vy_ = JUMP_VELOCITY;
    vx_ *= JUMP_SPEED_BOOST;
    last_grounded_position_ = y_;
    Audio::get()->playSound(jump_sound_, Audio::Group::GAME);
    transitionToState(State::ON_AIR);
}

// ============================================================================
// Fase 4a: Movimiento horizontal
// ============================================================================

// Early exit del movimiento horizontal si el player ya está pegado a una
// pared en su dirección de movimiento. Sin esto, el player choca pero
// conserva vx_ != 0 y animate() reproduce "walk" continuamente.
auto Player::stuckAgainstWall() const -> bool {
    const auto& tc = room_->getTileCollider();
    const auto& sm = room_->getSolidActors();
    if (vx_ > 0.0F) {
        return tc.checkWallRight(x_, y_, WIDTH, HEIGHT) != Collision::NONE ||
            sm.checkWallRight(x_, y_, WIDTH, HEIGHT) != Collision::NONE;
    }
    if (vx_ < 0.0F) {
        return tc.checkWallLeft(x_, y_, WIDTH, HEIGHT) != Collision::NONE ||
            sm.checkWallLeft(x_, y_, WIDTH, HEIGHT) != Collision::NONE;
    }
    return false;
}

void Player::moveHorizontal(float delta_time) {
    if (stuckAgainstWall()) {
        vx_ = 0.0F;
        return;
    }

    const auto& tc = room_->getTileCollider();
    const auto& sm = room_->getSolidActors();
    float new_x = x_ + (vx_ * delta_time);

    // Comprobar ambos muros siempre (el tilemap extendido incluye paredes de rooms
    // adyacentes; comprobar ambos lados evita solapamiento en zona de borde).
    // Se combinan tiles + solid actors en cada lado tomando el muro más "clampante".
    const float LEFT_WALL = combineLeftWall(
        tc.checkWallLeft(new_x, y_, WIDTH, HEIGHT),
        sm.checkWallLeft(new_x, y_, WIDTH, HEIGHT));
    if (LEFT_WALL != Collision::NONE && LEFT_WALL > new_x) {
        new_x = LEFT_WALL;
    }
    const float RIGHT_WALL = combineRightWall(
        tc.checkWallRight(new_x, y_, WIDTH, HEIGHT),
        sm.checkWallRight(new_x, y_, WIDTH, HEIGHT));
    if (RIGHT_WALL != Collision::NONE) {
        const float CORRECTED = RIGHT_WALL - WIDTH;
        new_x = std::min(new_x, CORRECTED);
    }

    x_ = new_x;

    // Slope following y detección solo cuando hay movimiento horizontal
    if (vx_ == 0.0F) { return; }
    if (state_ == State::ON_SLOPE) { followSlope(); }
    if (state_ == State::ON_GROUND) { detectSlopeEntry(); }
}

// Ajusta Y del jugador para seguir la superficie de la slope mientras camina.
// Si el pie sale del tile actual, busca el siguiente tile de slope en la fila
// actual y la inferior (las slopes en escalera bajan una fila por tile).
// Si no encuentra slope, llama a exitSlope().
void Player::followSlope() {
    const auto& tc = room_->getTileCollider();

    // SLOPE_L (\): pie izquierdo. SLOPE_R (/): pie derecho.
    float foot_x = (slope_type_ == TileCollider::Tile::SLOPE_L) ? x_ : x_ + WIDTH - 1;

    // Calcular Y en la slope actual
    float surface_y = tc.getSlopeY(slope_tile_x_, slope_tile_y_, foot_x);
    y_ = surface_y - HEIGHT;

    // Comprobar si hemos salido del tile actual (coordenadas del mapa extendido)
    int foot_tile_x = tc.toTile(static_cast<int>(foot_x));
    int foot_tile_y = tc.toTile(static_cast<int>(y_ + HEIGHT));

    if (foot_tile_x != slope_tile_x_ || foot_tile_y != slope_tile_y_) {
        // Buscar slope en el tile calculado y en el de abajo (la escalera de slopes
        // siempre tiene el siguiente tile una fila arriba o abajo)
        for (int row = foot_tile_y; row <= foot_tile_y + 1; ++row) {
            auto new_tile = tc.getTileAt(foot_tile_x, row);
            if (new_tile == TileCollider::Tile::SLOPE_L || new_tile == TileCollider::Tile::SLOPE_R) {
                slope_tile_x_ = foot_tile_x;
                slope_tile_y_ = row;
                slope_type_ = new_tile;
                surface_y = tc.getSlopeY(slope_tile_x_, slope_tile_y_, foot_x);
                y_ = surface_y - HEIGHT;
                return;
            }
        }
        exitSlope();
    }
}

// El jugador ha salido del tile de slope sin encontrar otra slope adyacente.
// Comprueba si hay suelo debajo (foot_y y foot_y+1 para cubrir el boundary exacto
// entre filas cuando se sale por el extremo inferior de la slope).
// Si hay suelo, snapea al borde del tile. Si no, empieza a caer.
void Player::exitSlope() {
    const auto& tc = room_->getTileCollider();
    float foot_y = y_ + HEIGHT;

    // Comprobar suelo en la fila actual y la siguiente (al salir por abajo de una slope,
    // los pies pueden estar en el último pixel de la fila, justo antes del suelo)
    for (int check = 0; check <= 1; ++check) {
        float check_y = foot_y + check;
        if (tc.hasGroundBelow(x_, check_y, WIDTH)) {
            int row = tc.toTile(static_cast<int>(check_y));
            y_ = tc.toPixel(row) - HEIGHT;
            transitionToState(State::ON_GROUND);
            return;
        }
    }

    vy_ = 0.0F;
    transitionToState(State::ON_AIR);
}

// Detecta si el jugador ha pisado una slope caminando desde suelo plano.
// Las slopes en escalera están una fila arriba del suelo, así que checkSlopeBelow
// también mira la fila superior.
void Player::detectSlopeEntry() {
    const auto& tc = room_->getTileCollider();
    float foot_y = y_ + HEIGHT;

    auto slope = tc.checkSlopeBelow(x_, foot_y, WIDTH);
    if (slope.on_slope) {
        y_ = slope.surface_y - HEIGHT;
        slope_tile_x_ = slope.tile_x;
        slope_tile_y_ = slope.tile_y;
        slope_type_ = slope.type;
        transitionToState(State::ON_SLOPE);
    }
}

// ============================================================================
// Fase 4b: Movimiento vertical
// ============================================================================

// Subiendo: comprobar techo (tiles + solid actors). Si hay colisión,
// snap y parar vy.
void Player::moveVerticalUp(float displacement) {
    const auto& tc = room_->getTileCollider();
    const auto& sm = room_->getSolidActors();
    const float NEW_Y = y_ + displacement;
    const float CEILING = combineCeiling(
        tc.checkCeiling(x_, NEW_Y, WIDTH),
        sm.checkCeiling(x_, NEW_Y, WIDTH));
    if (CEILING != Collision::NONE) {
        y_ = CEILING;
        vy_ = 0.0F;
    } else {
        y_ = NEW_Y;
    }
}

// Bajando: comprobar suelo en tiles y en solid actors; el que esté antes
// (menor y) gana. Si es un SolidActor con CARRY_ON_TOP, guarda el carrier.
void Player::moveVerticalDown(float displacement) {
    const auto& tc = room_->getTileCollider();
    const auto& sm = room_->getSolidActors();
    const float FOOT_Y = y_ + HEIGHT;
    const float NEW_FOOT_Y = FOOT_Y + displacement;
    const auto TILE_HIT = tc.checkFloor(x_, FOOT_Y, WIDTH, NEW_FOOT_Y);
    const auto ACTOR_HIT = sm.checkFloor(x_, FOOT_Y, WIDTH, NEW_FOOT_Y);

    // El tile tiene prioridad si está igual o más arriba que el actor.
    const bool TILE_WINS = (TILE_HIT.y != Collision::NONE) &&
        (ACTOR_HIT.y == Collision::NONE || TILE_HIT.y <= ACTOR_HIT.y);
    const bool ACTOR_WINS = !TILE_WINS && (ACTOR_HIT.y != Collision::NONE);

    if (TILE_WINS) {
        y_ = TILE_HIT.y - HEIGHT;
        const bool IS_SLOPE = TILE_HIT.type == TileCollider::Tile::SLOPE_L ||
            TILE_HIT.type == TileCollider::Tile::SLOPE_R;
        if (IS_SLOPE) {
            slope_tile_x_ = TILE_HIT.tile_x;
            slope_tile_y_ = TILE_HIT.tile_y;
            slope_type_ = TILE_HIT.type;
            transitionToState(State::ON_SLOPE);
        } else {
            transitionToState(State::ON_GROUND);
        }
        current_carrier_ = nullptr;
        return;
    }
    if (ACTOR_WINS) {
        y_ = ACTOR_HIT.y - HEIGHT;
        transitionToState(State::ON_GROUND);
        current_carrier_ = ACTOR_HIT.carrier;
        return;
    }

    // Cae libremente
    y_ += displacement;
#ifdef _DEBUG
    if (y_ > PlayArea::BOTTOM + 100) { y_ = PlayArea::TOP + 2; }
#endif
}

void Player::moveVertical(float delta_time) {
    if (state_ != State::ON_AIR) { return; }
    const float DISPLACEMENT = vy_ * delta_time;
    if (vy_ < 0.0F) {
        moveVerticalUp(DISPLACEMENT);
    } else if (vy_ > 0.0F) {
        moveVerticalDown(DISPLACEMENT);
    }
}

// ============================================================================
// Fase 5: Detección de caída
// ============================================================================

void Player::checkFalling() {
    if (state_ == State::ON_AIR) { return; }

    const auto& tc = room_->getTileCollider();
    const auto& sm = room_->getSolidActors();

    if (state_ == State::ON_SLOPE) {
        // Verificar que el tile de slope sigue existiendo
        auto tile = tc.getTileAt(slope_tile_x_, slope_tile_y_);
        if (tile != TileCollider::Tile::SLOPE_L && tile != TileCollider::Tile::SLOPE_R) {
            vy_ = 0.0F;
            transitionToState(State::ON_AIR);
        }
        return;
    }

    // ON_GROUND: comprobar si sigue habiendo suelo (tile o solid actor).
    // El tilemap extendido incluye tiles de las rooms adyacentes, así que
    // no hace falta cross-room para tiles.
    float foot_y = y_ + HEIGHT;
    const bool TILE_GROUND = tc.hasGroundBelow(x_, foot_y, WIDTH);
    const bool ACTOR_GROUND = sm.hasGroundBelow(x_, foot_y, WIDTH);

    if (!TILE_GROUND && !ACTOR_GROUND) {
        // Sticking: si no hay suelo pero hay slope debajo, snapear a ella
        // para transición suave suelo→slope (bajada de rampas sin caer)
        auto slope = tc.checkSlopeBelow(x_, foot_y, WIDTH);
        if (slope.on_slope) {
            y_ = slope.surface_y - HEIGHT;
            slope_tile_x_ = slope.tile_x;
            slope_tile_y_ = slope.tile_y;
            slope_type_ = slope.type;
            transitionToState(State::ON_SLOPE);
            return;
        }

        vy_ = 0.0F;
        transitionToState(State::ON_AIR);
        return;
    }

    // Refrescar current_carrier_ para la próxima iteración: si hay actor
    // debajo, comprobar si lleva CARRY_ON_TOP y guardarlo; si no, limpiarlo.
    if (ACTOR_GROUND) {
        auto hit = sm.checkFloor(x_, foot_y, WIDTH, foot_y + 1.0F);
        current_carrier_ = hit.carrier;
    } else {
        current_carrier_ = nullptr;
    }
}

// ============================================================================
// Gestión de estado
// ============================================================================

void Player::transitionToState(State state) {
    previous_state_ = state_;
    state_ = state;

    switch (state) {
        case State::ON_GROUND:
        case State::ON_SLOPE:
            vy_ = 0;
            // Clamp vx al aterrizar (el salto puede dar un boost extra)
            vx_ = std::clamp(vx_, -HORIZONTAL_VELOCITY, HORIZONTAL_VELOCITY);
            if (previous_state_ == State::ON_AIR) {
                Audio::get()->playSound(land_sound_, Audio::Group::GAME);
            }
            break;
        case State::ON_AIR:
            last_grounded_position_ = static_cast<int>(y_);
            current_carrier_ = nullptr;  // Perder carry al despegar
            walk_time_ = 0.0F;           // Al aterrizar volverá a contar desde 0
            break;
    }
}

// ============================================================================
// Bordes de pantalla
// ============================================================================

auto Player::handleBorders() const -> Room::Border {
    const float CENTER_X = x_ + (WIDTH / 2.0F);
    const float CENTER_Y = y_ + (HEIGHT / 2.0F);

    if (CENTER_X < PlayArea::LEFT) { return Room::Border::LEFT; }
    if (CENTER_X > PlayArea::RIGHT) { return Room::Border::RIGHT; }
    if (CENTER_Y < PlayArea::TOP) { return Room::Border::TOP; }
    if (CENTER_Y > PlayArea::BOTTOM) { return Room::Border::BOTTOM; }
    return Room::Border::NONE;
}

void Player::switchBorders() {
    switch (border_) {
        case Room::Border::TOP:
            y_ += PlayArea::HEIGHT;
            last_grounded_position_ = static_cast<int>(y_);
            break;
        case Room::Border::BOTTOM:
            y_ -= PlayArea::HEIGHT;
            last_grounded_position_ = static_cast<int>(y_);
            break;
        case Room::Border::RIGHT:
            x_ -= PlayArea::WIDTH;
            break;
        case Room::Border::LEFT:
            x_ += PlayArea::WIDTH;
            break;
        default:
            break;
    }
    border_ = Room::Border::NONE;
    syncSpriteAndCollider();
}

// ============================================================================
// Geometría y renderizado
// ============================================================================

void Player::syncSpriteAndCollider() {
    placeSprite();
    collider_box_ = getRect();
}

void Player::placeSprite() {
    sprite_->setPos(x_, y_);
}

void Player::animate(float delta_time) {
    if (state_ == State::ON_AIR) {
        turning_ = false;
        const bool NEAR_PEAK = vy_ > JUMP_VELOCITY * 0.5F && vy_ < -JUMP_VELOCITY * 0.5F;
        sprite_->setCurrentAnimation(NEAR_PEAK ? "jump_peak" : "jump");
    } else if (vx_ != 0) {
        if (turning_) {
            sprite_->setCurrentAnimation("turn_walk");
        } else {
            sprite_->setCurrentAnimation("walk");
        }
        sprite_->update(delta_time);
    } else {
        turning_ = false;
        sprite_->setCurrentAnimation("stand");
    }
}

// ============================================================================
// Skin
// ============================================================================

auto Player::skinToAnimationPath(const std::string& skin_name) -> std::string {
    if (skin_name == Defaults::Game::Player::SKIN) { return Defaults::Game::Player::DEFAULT_ANIMATION; }
    return skin_name + ".yaml";
}

// ============================================================================
// Inicialización
// ============================================================================

void Player::initSprite(const std::string& animations_path) {
    const auto& animation_data = Resource::Cache::get()->getAnimationData(animations_path);
    sprite_ = std::make_unique<AnimatedSprite>(animation_data);
    sprite_->setWidth(WIDTH);
    sprite_->setHeight(HEIGHT);
    sprite_->setCurrentAnimation("walk");
}

void Player::initSounds() {
    jump_sound_ = Resource::Cache::get()->getSound(Defaults::Sound::Files::JUMP);
    land_sound_ = Resource::Cache::get()->getSound(Defaults::Sound::Files::LAND);
}

void Player::applySpawnValues(const SpawnData& spawn) {
    x_ = spawn.x;
    y_ = spawn.y;
    vx_ = spawn.vx;
    vy_ = spawn.vy;
    last_grounded_position_ = spawn.last_grounded_position;
    state_ = spawn.state;
    sprite_->setFlip(spawn.flip);
    facing_ = (spawn.flip == Flip::LEFT) ? Direction::LEFT : Direction::RIGHT;
}

// ============================================================================
// Utilidades
// ============================================================================

void Player::markAsDead() {
    is_alive_ = (Options::cheats.invincible == Options::Cheat::State::ENABLED);
}

#ifdef _DEBUG
void Player::setDebugPosition(float x, float y) {
    x_ = x;
    y_ = y;
    syncSpriteAndCollider();
}

void Player::finalizeDebugTeleport() {
    vx_ = 0.0F;
    vy_ = 0.0F;
    last_grounded_position_ = static_cast<int>(y_);
    slope_tile_x_ = 0;
    slope_tile_y_ = 0;
    slope_type_ = TileCollider::Tile::EMPTY;
    transitionToState(State::ON_GROUND);
    syncSpriteAndCollider();
}
#endif
