#include "player.h"

// Constructor
Player::Player(SDL_Renderer *renderer, Asset *asset, Input *input, Map *map)
{
    this->asset = asset;
    this->renderer = renderer;
    this->input = input;
    this->map = map;

    sound_jump = JA_LoadSound(asset->get("sound_player_jump.wav").c_str());
    sound_death = JA_LoadSound(asset->get("sound_player_death.wav").c_str());
    sound_coin = JA_LoadSound(asset->get("sound_player_coin.wav").c_str());

    texture = new LTexture();
    loadTextureFromFile(texture, asset->get("player.png"), renderer);

    sprite = new AnimatedSprite(texture, renderer, asset->get("player.ani"));

    x = 3 * 16;
    y = 40;
    vx = 0;
    vy = 0;
    const SDL_Rect rect = {(int)x, (int)y, 16, 24};
    sprite->setPos(rect);
    sprite->setCurrentAnimation("stand");
    sprite->setFlip(SDL_FLIP_HORIZONTAL);

    gravity = 0.3f;
    can_jump = true;
    standing = true;
    invulnerable = true;
    jumpforce = 10;
    enabled = true;
    cooldown = 0;
    lifes = 10;
    coins = 0;
    key.insert(key.end(), {0, 0, 0, 0, 0, 0});
    const SDL_Point p = {0, 0};
    collider.insert(collider.end(), {p, p, p, p, p, p});
}

// Destructor
Player::~Player()
{
    JA_DeleteSound(sound_jump);
    JA_DeleteSound(sound_death);
    JA_DeleteSound(sound_coin);

    texture->unload();
    delete texture;

    delete sprite;
}

// Actualiza todas las variables
void Player::update()
{
    checkInput();
    addGravity();
    move();
}

// Dibuja el objeto
void Player::render()
{
    sprite->render();
}

// Comprueba las entradas y modifica variables
void Player::checkInput()
{
    const float speed = 1.0f;
    // Solo comprueba las entradas de dirección cuando está de pie
    if (input->checkInput(INPUT_LEFT, REPEAT_TRUE))
    {
        vx = -speed;
        sprite->setFlip(SDL_FLIP_NONE);
        sprite->setCurrentAnimation("walk");
    }
    else if (input->checkInput(INPUT_RIGHT, REPEAT_TRUE))
    {
        vx = speed;
        sprite->setFlip(SDL_FLIP_HORIZONTAL);
        sprite->setCurrentAnimation("walk");
    }
    else
    {
        vx = 0;
        sprite->setCurrentAnimation("stand");
    }

    if (input->checkInput(INPUT_UP, REPEAT_FALSE))
    {
        vy = -5.0f;
    }
}

// Aplica la gravedad
void Player::addGravity()
{
    vy = std::min(vy += gravity, 2.0f);
}

// Actualiza los puntos de colisión
void Player::updateColliders()
{
    const SDL_Point p = {(int)x, (int)y};

    collider[0] = p;
    collider[1] = {p.x, p.y + 12};
    collider[2] = {p.x, p.y + 23};
    collider[3] = {p.x + 15, p.y};
    collider[4] = {p.x + 15, p.y + 12};
    collider[5] = {p.x + 15, p.y + 23};
}

// Compruena las colisiones con el mapa
bool Player::checkMapCollisions()
{
    bool collision = false;

    updateColliders();

    for (auto c : collider)
    {
        collision |= (map->getTile(c) == wall);
    }

    return collision;
}

// Mueve al jugador en función de la velocidad/desplazamiento
void Player::move()
{
    const float old_x = x;
    x += vx;
    if (checkMapCollisions())
    {
        x = old_x;
    }

    // const float old_y = y;
    y += vy;
    if (checkMapCollisions())
    {
        // y = old_y;
        if (vy > 0)
        {
            do
            {
                y--;
            } while (checkMapCollisions());
        }
        else
        {
            do
            {
                y++;
            } while (checkMapCollisions());
        }

        vy = 0;
    }

    sprite->setPosX(x);
    sprite->setPosY(y);
    sprite->update();
}