#include "enemy.h"
#include <SDL2/SDL_render.h>   // for SDL_RendererFlip, SDL_FLIP_NONE, SDL_FL...
#include <stdlib.h>            // for rand
#include "s_animated_sprite.h" // for AnimatedSprite
#include "options.h"           // for Options, OptionsVideo, options
#include "resource.h"          // for Resource
#include "surface.h"           // for Texture

// Constructor
Enemy::Enemy(const EnemyData &enemy)
    : sprite_(std::make_shared<AnimatedSprite>(Resource::get()->getSurface(enemy.texture_path), Resource::get()->getAnimations(enemy.animation_path))),
      color_string_(enemy.color),
      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
    setPalette(options.video.palette);
    sprite_->setPosX(enemy.x);
    sprite_->setPosY(enemy.y);
    sprite_->setVelX(enemy.vx);
    sprite_->setVelY(enemy.vy);
    sprite_->setWidth(enemy.w);
    sprite_->setHeight(enemy.h);

    const SDL_RendererFlip FLIP = (should_flip_ && enemy.vx < 0.0f) ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
    const SDL_RendererFlip MIRROR = should_mirror_ ? SDL_FLIP_VERTICAL : SDL_FLIP_NONE;
    sprite_->setFlip(static_cast<SDL_RendererFlip>(FLIP | MIRROR));

    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_->getTexture()->setColor(color_.r, color_.g, color_.b);
    sprite_->render();
    sprite_->getTexture()->setColor(255, 255, 255);
}

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

// Comprueba si ha llegado al limite del recorrido para darse media vuelta
void Enemy::checkPath()
{
    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();
        }
    }
}

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

// Obtiene el rectangulo de colision del enemigo
SDL_Rect &Enemy::getCollider()
{
    return collider_;
}

// Recarga la textura
void Enemy::reLoadTexture()
{
    sprite_->getTexture()->reLoad();
}

// Asigna la paleta
void Enemy::setPalette(Palette pal)
{
    color_ = stringToColor(pal, color_string_);
}