#include "game/entities/enemy.hpp"

#include <SDL3/SDL.h>

#include <cstdlib>  // Para rand

#include "core/rendering/sprite/animated_sprite.hpp"  // Para SAnimatedSprite
#include "core/resources/resource_cache.hpp"          // Para Resource
#include "utils/utils.hpp"

// Constructor
Enemy::Enemy(const Data& enemy)
    : sprite_(std::make_shared<AnimatedSprite>(Resource::Cache::get()->getAnimationData(enemy.animation_path))),
      x1_(enemy.x1),
      x2_(enemy.x2),
      y1_(enemy.y1),
      y2_(enemy.y2),
      should_flip_(enemy.flip),
      should_mirror_(enemy.mirror) {
    // Obten el resto de valores
    sprite_->setPosX(enemy.x);
    sprite_->setPosY(enemy.y);
    sprite_->setVelX(enemy.vx);
    sprite_->setVelY(enemy.vy);

    applyFlipMirror(enemy.vx);

    collider_ = getRect();

    // Coloca un frame al azar o el designado
    sprite_->setCurrentAnimationFrame((enemy.frame == -1) ? (rand() % sprite_->getCurrentAnimationSize()) : enemy.frame);
}

// Pinta el enemigo en pantalla
void Enemy::render() {
    sprite_->render();
}

// Actualiza las variables del objeto
void Enemy::update(float delta_time) {
    sprite_->update(delta_time);
    checkPath();
    collider_ = getRect();
}

#ifdef _DEBUG
// Solo actualiza la animación sin mover al enemigo
void Enemy::updateAnimation(float delta_time) {
    sprite_->animate(delta_time);
}

// Resetea el enemigo a su posición inicial (para editor)
void Enemy::resetToInitialPosition(const Data& data) {
    sprite_->setPosX(data.x);
    sprite_->setPosY(data.y);
    sprite_->setVelX(data.vx);
    sprite_->setVelY(data.vy);

    applyFlipMirror(data.vx);

    collider_ = getRect();
}
#endif

// Comprueba si ha llegado al limite del recorrido para darse media vuelta
void Enemy::checkPath() {  // NOLINT(readability-make-member-function-const)
    if (sprite_->getPosX() > x2_ || sprite_->getPosX() < x1_) {
        // Recoloca
        if (sprite_->getPosX() > x2_) {
            sprite_->setPosX(x2_);
        } else {
            sprite_->setPosX(x1_);
        }

        // Cambia el sentido
        sprite_->setVelX(sprite_->getVelX() * (-1));

        // Invierte el sprite
        if (should_flip_) {
            sprite_->flip();
        }
    }

    if (sprite_->getPosY() > y2_ || sprite_->getPosY() < y1_) {
        // Recoloca
        if (sprite_->getPosY() > y2_) {
            sprite_->setPosY(y2_);
        } else {
            sprite_->setPosY(y1_);
        }

        // Cambia el sentido
        sprite_->setVelY(sprite_->getVelY() * (-1));

        // Invierte el sprite
        if (should_flip_) {
            sprite_->flip();
        }
    }
}

// Aplica flip horizontal y/o mirror vertical al sprite
void Enemy::applyFlipMirror(float vx) {
    const int FLIP = (should_flip_ && vx < 0.0F) ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
    const int MIRROR = should_mirror_ ? SDL_FLIP_VERTICAL : SDL_FLIP_NONE;
    sprite_->setFlip(static_cast<SDL_FlipMode>(FLIP | MIRROR));  // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) SDL flags are designed for bitwise OR
}

// Devuelve el rectangulo que contiene al enemigo
auto Enemy::getRect() -> SDL_FRect {
    return sprite_->getRect();
}

// Obtiene el rectangulo de colision del enemigo
auto Enemy::getCollider() -> SDL_FRect& {
    return collider_;
}