#include "moving_sprite.h"

#include <utility>

#include "texture.h"  // Para Texture

// Constructor
MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, Rotate rotate, float horizontal_zoom, float vertical_zoom, SDL_FlipMode flip)
    : Sprite(std::move(texture), pos),
      rotate_(rotate),
      flip_(flip),
      x_(pos.x),
      y_(pos.y),
      horizontal_zoom_(horizontal_zoom),
      vertical_zoom_(vertical_zoom) {}

MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos)
    : Sprite(std::move(texture), pos),
      flip_(SDL_FLIP_NONE),
      x_(pos.x),
      y_(pos.y),
      horizontal_zoom_(1.0F),
      vertical_zoom_(1.0F) {}

MovingSprite::MovingSprite(std::shared_ptr<Texture> texture)
    : Sprite(std::move(texture)),
      flip_(SDL_FLIP_NONE),
      horizontal_zoom_(1.0F),
      vertical_zoom_(1.0F) { Sprite::clear(); }

// Reinicia todas las variables
void MovingSprite::clear() {
    stop();
    Sprite::clear();
}

// Elimina el movimiento del sprite
void MovingSprite::stop() {
    x_ = 0.0F;  // Posición en el eje X
    y_ = 0.0F;  // Posición en el eje Y

    vx_ = 0.0F;  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
    vy_ = 0.0F;  // Velocidad en el eje Y. Cantidad de pixeles a desplazarse

    ax_ = 0.0F;  // Aceleración en el eje X. Variación de la velocidad
    ay_ = 0.0F;  // Aceleración en el eje Y. Variación de la velocidad

    rotate_ = Rotate();  // Inicializa la estructura

    horizontal_zoom_ = 1.0F;  // Zoom aplicado a la anchura
    vertical_zoom_ = 1.0F;    // Zoom aplicado a la altura

    flip_ = SDL_FLIP_NONE;  // Establece como se ha de voltear el sprite
}

// Mueve el sprite (frame-based)
void MovingSprite::move() {
    x_ += vx_;
    y_ += vy_;

    vx_ += ax_;
    vy_ += ay_;

    pos_.x = static_cast<int>(x_);
    pos_.y = static_cast<int>(y_);
}

// Mueve el sprite (time-based)
void MovingSprite::move(float deltaTime) {
    x_ += vx_ * deltaTime;
    y_ += vy_ * deltaTime;

    vx_ += ax_ * deltaTime;
    vy_ += ay_ * deltaTime;

    pos_.x = static_cast<int>(x_);
    pos_.y = static_cast<int>(y_);
}

// Actualiza las variables internas del objeto (frame-based)
void MovingSprite::update() {
    move();
    rotate();
}

// Actualiza las variables internas del objeto (time-based)
void MovingSprite::update(float deltaTime) {
    move(deltaTime);
    rotate(deltaTime);
}

// Muestra el sprite por pantalla
void MovingSprite::render() { getTexture()->render(pos_.x, pos_.y, &sprite_clip_, horizontal_zoom_, vertical_zoom_, rotate_.angle, &rotate_.center, flip_); }

// Establece la rotacion (frame-based)
void MovingSprite::rotate() {
    if (rotate_.enabled) {
        ++rotate_.counter;
        if (rotate_.counter % rotate_.speed == 0) {
            updateAngle();
            rotate_.counter = 0;
        }
    }
}

// Establece la rotacion (time-based)
void MovingSprite::rotate(float deltaTime) {
    if (rotate_.enabled) {
        // Convertir speed (frames) a tiempo: speed frames = speed/60 segundos a 60fps
        float rotationSpeed = static_cast<float>(rotate_.speed) / 60.0f;
        rotate_.angle += rotate_.amount * (deltaTime / rotationSpeed);
    }
}

// Activa o desactiva el efecto de rotación
void MovingSprite::setRotate(bool enable) {
    rotate_.enabled = enable;
    rotate_.counter = 0;
}

// Establece la posición y_ el tamaño del objeto
void MovingSprite::setPos(SDL_FRect rect) {
    x_ = rect.x;
    y_ = rect.y;

    pos_ = rect;
}

// Establece el valor de las variables
void MovingSprite::setPos(float pos_x, float pos_y) {
    x_ = pos_x;
    y_ = pos_y;

    pos_.x = static_cast<int>(x_);
    pos_.y = static_cast<int>(y_);
}

// Establece el valor de la variable
void MovingSprite::setPosX(float pos_x) {
    x_ = pos_x;
    pos_.x = static_cast<int>(x_);
}

// Establece el valor de la variable
void MovingSprite::setPosY(float pos_y) {
    y_ = pos_y;
    pos_.y = static_cast<int>(y_);
}