#include "fade.h"

#include <SDL3/SDL.h>  // Para SDL_SetRenderTarget, SDL_FRect, SDL_GetRenderTarget, SDL_RenderFillRect, SDL_SetRenderDrawBlendMode, SDL_SetRenderDrawColor, Uint8, SDL_GetRenderDrawBlendMode, SDL_BLENDMODE_NONE, SDL_BlendMode, SDL_CreateTexture, SDL_DestroyTexture, SDL_RenderClear, SDL_RenderTexture, SDL_SetTextureAlphaMod, SDL_SetTextureBlendMode, SDL_BLENDMODE_BLEND, SDL_PixelFormat, SDL_TextureAccess

#include <algorithm>  // Para min, max
#include <cstdlib>    // Para rand, size_t

#include "color.h"   // Para Color
#include "param.h"   // Para Param, param, ParamGame, ParamFade
#include "screen.h"  // Para Screen

// Constructor
Fade::Fade()
    : renderer_(Screen::get()->getRenderer()) {
    // Crea la textura donde dibujar el fade
    backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
    SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);

    // Inicializa las variables
    init();
}

// Destructor
Fade::~Fade() {
    SDL_DestroyTexture(backbuffer_);
}

// Inicializa las variables
void Fade::init() {
    type_ = Type::CENTER;
    mode_ = Mode::OUT;
    counter_ = 0;
    r_ = 0;
    g_ = 0;
    b_ = 0;
    a_ = 0;
    post_duration_ = 0;
    post_start_time_ = 0;
    pre_duration_ = 0;
    pre_start_time_ = 0;
    num_squares_width_ = param.fade.num_squares_width;
    num_squares_height_ = param.fade.num_squares_height;
    random_squares_duration_ = param.fade.random_squares_duration_ms;  // Usar como duración en ms
    square_transition_duration_ = random_squares_duration_ / 4;        // 25% del tiempo total para la transición individual
    random_squares_start_time_ = 0;
}

// Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
void Fade::reset() {
    state_ = State::NOT_ENABLED;
    counter_ = 0;
    post_start_time_ = 0;
    pre_start_time_ = 0;
}

// Pinta una transición en pantalla
void Fade::render() {
    if (state_ != State::NOT_ENABLED) {
        // Para fade IN terminado, no renderizar (auto-desactivación visual)
        if (state_ == State::FINISHED && mode_ == Mode::IN) {
            return;
        }

        SDL_RenderTexture(renderer_, backbuffer_, nullptr, nullptr);
    }
}

// Actualiza las variables internas
void Fade::update() {
    switch (state_) {
        case State::PRE:
            updatePreState();
            break;
        case State::FADING:
            updateFadingState();
            break;
        case State::POST:
            updatePostState();
            break;
        default:
            break;
    }
}

// Compatibilidad delta-time (ignora el parámetro ya que usa SDL_GetTicks)
void Fade::update(float delta_time) {
    update();  // Llama al método original
}

void Fade::updatePreState() {
    // Sistema basado en tiempo únicamente
    Uint32 elapsed_time = SDL_GetTicks() - pre_start_time_;

    if (elapsed_time >= static_cast<Uint32>(pre_duration_)) {
        state_ = State::FADING;
        // CRÍTICO: Reinicializar tiempo de inicio para tipos que usan random_squares_start_time_
        if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
            random_squares_start_time_ = SDL_GetTicks();
        }
    }
}

void Fade::updateFadingState() {
    switch (type_) {
        case Type::FULLSCREEN:
            updateFullscreenFade();
            break;
        case Type::CENTER:
            updateCenterFade();
            break;
        case Type::RANDOM_SQUARE:
            updateRandomSquareFade();
            break;
        case Type::RANDOM_SQUARE2:
            updateRandomSquare2Fade();
            break;
        case Type::DIAGONAL:
            updateDiagonalFade();
            break;
        case Type::VENETIAN:
            updateVenetianFade();
            break;
        default:
            break;
    }
    counter_++;
}

void Fade::changeToPostState() {
    state_ = State::POST;
    post_start_time_ = SDL_GetTicks();
}

void Fade::updatePostState() {
    // Sistema basado en tiempo únicamente
    Uint32 elapsed_time = SDL_GetTicks() - post_start_time_;

    if (elapsed_time >= static_cast<Uint32>(post_duration_)) {
        state_ = State::FINISHED;
    }

    // Mantener el alpha final correcto para cada tipo de fade
    Uint8 post_alpha = a_;
    if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
        post_alpha = (mode_ == Mode::OUT) ? 255 : 0;
    }

    cleanBackbuffer(r_, g_, b_, post_alpha);
}

void Fade::updateFullscreenFade() {
    // Modifica la transparencia
    a_ = mode_ == Mode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
    SDL_SetTextureAlphaMod(backbuffer_, a_);

    // Comprueba si ha terminado
    if (counter_ >= 255 / 4) {
        changeToPostState();
    }
}

void Fade::updateCenterFade() {
    drawCenterFadeRectangles();

    // Comprueba si ha terminado
    if ((counter_ * 4) > param.game.height) {
        a_ = 255;
        changeToPostState();
    }
}

void Fade::drawCenterFadeRectangles() {
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);
    SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);

    for (int i = 0; i < counter_; i++) {
        rect1_.h = rect2_.h = i * 4;
        rect2_.y = param.game.height - (i * 4);

        SDL_RenderFillRect(renderer_, &rect1_);
        SDL_RenderFillRect(renderer_, &rect2_);

        value_ = calculateValue(0, counter_, i);
    }

    SDL_SetRenderTarget(renderer_, temp);
}

void Fade::updateRandomSquareFade() {
    Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
    float progress = static_cast<float>(elapsed_time) / random_squares_duration_;

    // Calcula cuántos cuadrados deberían estar activos
    int total_squares = num_squares_width_ * num_squares_height_;
    int active_squares = static_cast<int>(progress * total_squares);
    active_squares = std::min(active_squares, total_squares);

    // Dibuja los cuadrados activos
    drawRandomSquares(active_squares);

    value_ = calculateValue(0, total_squares, active_squares);

    // Comprueba si ha terminado
    if (elapsed_time >= static_cast<Uint32>(random_squares_duration_)) {
        changeToPostState();
    }
}

void Fade::updateRandomSquare2Fade() {
    Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;

    int total_squares = num_squares_width_ * num_squares_height_;

    // Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
    int activation_time = random_squares_duration_ - square_transition_duration_;
    activation_time = std::max(activation_time, square_transition_duration_);  // Mínimo igual a la duración de transición

    // Lógica diferente según el modo
    int squares_to_activate = 0;

    if (mode_ == Mode::OUT) {
        // OUT: Activa cuadrados gradualmente
        if (elapsed_time < static_cast<Uint32>(activation_time)) {
            float activation_progress = static_cast<float>(elapsed_time) / activation_time;
            squares_to_activate = static_cast<int>(activation_progress * total_squares);
        } else {
            squares_to_activate = total_squares;  // Activar todos
        }

        // Activa nuevos cuadrados y guarda su tiempo de activación
        for (int i = 0; i < squares_to_activate && i < total_squares; ++i) {
            if (square_age_[i] == -1) {
                square_age_[i] = elapsed_time;  // Guarda el tiempo de activación
            }
        }
    } else {
        // IN: Todos los cuadrados empiezan activos desde el inicio
        squares_to_activate = total_squares;

        // Activa cuadrados gradualmente con tiempo de inicio escalonado
        float activation_progress = static_cast<float>(elapsed_time) / activation_time;
        int squares_starting_transition = static_cast<int>(activation_progress * total_squares);

        // Asegurar que al menos 1 cuadrado se active desde el primer frame
        squares_starting_transition = std::max(squares_starting_transition, 1);
        squares_starting_transition = std::min(squares_starting_transition, total_squares);

        for (int i = 0; i < squares_starting_transition; ++i) {
            if (square_age_[i] == -1) {
                square_age_[i] = elapsed_time;  // Empieza la transición a transparente
            }
        }
    }

    drawRandomSquares2();

    value_ = calculateValue(0, total_squares, squares_to_activate);

    // Comprueba si ha terminado - todos los cuadrados han completado su transición
    bool all_completed = (squares_to_activate >= total_squares);
    if (all_completed) {
        // Verificar que todos han completado su transición individual
        for (int i = 0; i < total_squares; ++i) {
            if (square_age_[i] >= 0) {  // Cuadrado activado
                Uint32 square_elapsed = elapsed_time - square_age_[i];
                if (square_elapsed < static_cast<Uint32>(square_transition_duration_)) {
                    all_completed = false;
                    break;
                }
            }
        }

        if (all_completed) {
            // Pintar textura final: OUT opaca, IN transparente
            Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
            cleanBackbuffer(r_, g_, b_, final_alpha);
            changeToPostState();
        }
    }
}

void Fade::updateDiagonalFade() {
    Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;

    int total_squares = num_squares_width_ * num_squares_height_;

    // Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
    int activation_time = random_squares_duration_ - square_transition_duration_;
    activation_time = std::max(activation_time, square_transition_duration_);

    // Calcula cuántas diagonales deberían estar activas
    int max_diagonal = num_squares_width_ + num_squares_height_ - 1;  // Número total de diagonales
    int active_diagonals = 0;

    if (mode_ == Mode::OUT) {
        // OUT: Activa diagonales gradualmente desde esquina superior izquierda
        if (elapsed_time < static_cast<Uint32>(activation_time)) {
            float activation_progress = static_cast<float>(elapsed_time) / activation_time;
            active_diagonals = static_cast<int>(activation_progress * max_diagonal);
        } else {
            active_diagonals = max_diagonal;  // Activar todas
        }

        // Activa cuadrados por diagonales
        for (int diagonal = 0; diagonal < active_diagonals; ++diagonal) {
            activateDiagonal(diagonal, elapsed_time);
        }
    } else {
        // IN: Todas las diagonales empiezan activas, van desapareciendo
        active_diagonals = max_diagonal;

        // Activa diagonales gradualmente para transición
        if (elapsed_time < static_cast<Uint32>(activation_time)) {
            float activation_progress = static_cast<float>(elapsed_time) / activation_time;
            int diagonals_starting_transition = static_cast<int>(activation_progress * max_diagonal);

            for (int diagonal = 0; diagonal < diagonals_starting_transition; ++diagonal) {
                activateDiagonal(diagonal, elapsed_time);
            }
        } else {
            // Activar transición en todas las diagonales restantes
            for (int diagonal = 0; diagonal < max_diagonal; ++diagonal) {
                activateDiagonal(diagonal, elapsed_time);
            }
        }
    }

    drawDiagonal();

    value_ = calculateValue(0, total_squares, active_diagonals * (total_squares / max_diagonal));

    // Comprueba si ha terminado - todas las diagonales activadas y último cuadrado completó transición
    bool all_completed = (active_diagonals >= max_diagonal);
    if (all_completed) {
        // Verificar que todos han completado su transición individual
        for (int i = 0; i < total_squares; ++i) {
            if (square_age_[i] >= 0) {  // Cuadrado activado
                Uint32 square_elapsed = elapsed_time - square_age_[i];
                if (square_elapsed < static_cast<Uint32>(square_transition_duration_)) {
                    all_completed = false;
                    break;
                }
            }
        }

        if (all_completed) {
            // Pintar textura final: OUT opaca, IN transparente
            Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
            cleanBackbuffer(r_, g_, b_, final_alpha);
            changeToPostState();
        }
    }
}

void Fade::activateDiagonal(int diagonal_index, Uint32 current_time) {
    // Para cada diagonal, activamos los cuadrados que pertenecen a esa diagonal
    // Diagonal 0: (0,0)
    // Diagonal 1: (1,0), (0,1)
    // Diagonal 2: (2,0), (1,1), (0,2)
    // etc.

    for (int x = 0; x < num_squares_width_; ++x) {
        int y = diagonal_index - x;

        // Verificar que y está dentro de los límites
        if (y >= 0 && y < num_squares_height_) {
            // Convertir coordenadas (x,y) a índice en el vector
            int index = y * num_squares_width_ + x;

            if (index >= 0 && index < static_cast<int>(square_age_.size())) {
                if (square_age_[index] == -1) {
                    square_age_[index] = current_time;  // Guarda el tiempo de activación
                }
            }
        }
    }
}

void Fade::drawDiagonal() {
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);

    // CRÍTICO: Limpiar la textura antes de dibujar
    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
    SDL_RenderClear(renderer_);

    SDL_BlendMode blend_mode;
    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);  // Usar BLEND para alpha

    Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;

    // Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
    for (size_t i = 0; i < square_.size(); ++i) {
        Uint8 current_alpha = 0;

        if (square_age_[i] == -1) {
            // Cuadrado no activado
            if (mode_ == Mode::OUT) {
                current_alpha = 0;  // OUT: transparente si no activado
            } else {
                current_alpha = a_;  // IN: opaco si no activado
            }
        } else {
            // Cuadrado activado - calculamos progreso
            Uint32 square_elapsed = current_time - square_age_[i];
            float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);

            if (mode_ == Mode::OUT) {
                current_alpha = static_cast<Uint8>(progress * a_);  // 0 → 255
            } else {
                current_alpha = static_cast<Uint8>((1.0f - progress) * a_);  // 255 → 0
            }
        }

        if (current_alpha > 0) {
            SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
            SDL_RenderFillRect(renderer_, &square_[i]);
        }
    }

    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
    SDL_SetRenderTarget(renderer_, temp);
}

void Fade::drawRandomSquares(int active_count) {
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);

    SDL_BlendMode blend_mode;
    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
    SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);

    // Dibuja solo los cuadrados activos
    for (int i = 0; i < active_count && i < static_cast<int>(square_.size()); ++i) {
        SDL_RenderFillRect(renderer_, &square_[i]);
    }

    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
    SDL_SetRenderTarget(renderer_, temp);
}

void Fade::drawRandomSquares2() {
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);

    // CRÍTICO: Limpiar la textura antes de dibujar
    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
    SDL_RenderClear(renderer_);

    SDL_BlendMode blend_mode;
    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);  // Usar BLEND para alpha

    Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;

    // Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
    for (size_t i = 0; i < square_.size(); ++i) {
        Uint8 current_alpha = 0;

        if (square_age_[i] == -1) {
            // Cuadrado no activado
            if (mode_ == Mode::OUT) {
                current_alpha = 0;  // OUT: transparente si no activado
            } else {
                current_alpha = a_;  // IN: opaco si no activado
            }
        } else {
            // Cuadrado activado - calculamos progreso
            Uint32 square_elapsed = current_time - square_age_[i];
            float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);

            if (mode_ == Mode::OUT) {
                current_alpha = static_cast<Uint8>(progress * a_);  // 0 → 255
            } else {
                current_alpha = static_cast<Uint8>((1.0f - progress) * a_);  // 255 → 0
            }
        }

        if (current_alpha > 0) {
            SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
            SDL_RenderFillRect(renderer_, &square_[i]);
        }
    }

    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
    SDL_SetRenderTarget(renderer_, temp);
}

void Fade::updateVenetianFade() {
    if (square_.back().h < param.fade.venetian_size) {
        drawVenetianBlinds();
        updateVenetianRectangles();
        calculateVenetianProgress();
    } else {
        changeToPostState();
    }
}

void Fade::drawVenetianBlinds() {
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);

    SDL_BlendMode blend_mode;
    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
    SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);

    for (const auto &rect : square_) {
        SDL_RenderFillRect(renderer_, &rect);
    }

    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
    SDL_SetRenderTarget(renderer_, temp);
}

void Fade::updateVenetianRectangles() {
    const auto H = counter_ / 2;
    for (size_t i = 0; i < square_.size(); ++i) {
        square_.at(i).h = i == 0 ? H : std::max(static_cast<int>(square_.at(i - 1).h) - 2, 0);
    }
}

void Fade::calculateVenetianProgress() {
    int completed = 0;
    for (const auto &square : square_) {
        if (square.h >= param.fade.venetian_size) {
            ++completed;
        }
    }
    value_ = calculateValue(0, square_.size() - 1, completed);
}

// Activa el fade
void Fade::activate() {
    // Si ya está habilitado, no hay que volverlo a activar
    if (state_ != State::NOT_ENABLED) {
        return;
    }

    state_ = State::PRE;
    counter_ = 0;
    pre_start_time_ = SDL_GetTicks();

    switch (type_) {
        case Type::FULLSCREEN: {
            // Pinta el backbuffer_ de color sólido
            cleanBackbuffer(r_, g_, b_, 255);
            break;
        }

        case Type::CENTER: {
            rect1_ = {.x = 0, .y = 0, .w = param.game.width, .h = 0};
            rect2_ = {.x = 0, .y = 0, .w = param.game.width, .h = 0};
            a_ = 64;
            break;
        }

        case Type::RANDOM_SQUARE: {
            rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
            square_.clear();

            // Añade los cuadrados al vector
            for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
                rect1_.x = (i % num_squares_width_) * rect1_.w;
                rect1_.y = (i / num_squares_width_) * rect1_.h;
                square_.push_back(rect1_);
            }

            // Desordena el vector de cuadrados
            auto num = num_squares_width_ * num_squares_height_;
            while (num > 1) {
                auto num_arreu = rand() % num;
                SDL_FRect temp = square_[num_arreu];
                square_[num_arreu] = square_[num - 1];
                square_[num - 1] = temp;
                num--;
            }

            // Limpia la textura
            a_ = mode_ == Mode::OUT ? 0 : 255;
            cleanBackbuffer(r_, g_, b_, a_);

            // Deja el color listo para usar
            a_ = mode_ == Mode::OUT ? 255 : 0;

            // Inicializa el tiempo de inicio
            random_squares_start_time_ = SDL_GetTicks();

            break;
        }

        case Type::RANDOM_SQUARE2: {
            rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
            square_.clear();
            square_age_.clear();

            // Añade los cuadrados al vector
            for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
                rect1_.x = (i % num_squares_width_) * rect1_.w;
                rect1_.y = (i / num_squares_width_) * rect1_.h;
                square_.push_back(rect1_);
                square_age_.push_back(-1);  // -1 indica cuadrado no activado aún
            }

            // Desordena el vector de cuadrados y edades
            auto num = num_squares_width_ * num_squares_height_;
            while (num > 1) {
                auto num_arreu = rand() % num;
                SDL_FRect temp_rect = square_[num_arreu];
                int temp_age = square_age_[num_arreu];
                square_[num_arreu] = square_[num - 1];
                square_age_[num_arreu] = square_age_[num - 1];
                square_[num - 1] = temp_rect;
                square_age_[num - 1] = temp_age;
                num--;
            }

            // Textura inicial: OUT transparente, IN opaca
            Uint8 initial_alpha = (mode_ == Mode::OUT) ? 0 : 255;
            cleanBackbuffer(r_, g_, b_, initial_alpha);

            // Deja el color listo para usar (alpha target para los cuadrados)
            a_ = 255;  // Siempre usar 255 como alpha target

            // Inicializa el tiempo de inicio y recalcula la duración de transición
            random_squares_start_time_ = SDL_GetTicks();
            square_transition_duration_ = std::max(random_squares_duration_ / 4, 100);  // Mínimo 100ms

            break;
        }

        case Type::DIAGONAL: {
            rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
            square_.clear();
            square_age_.clear();

            // Añade los cuadrados al vector en orden (sin desordenar)
            for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
                rect1_.x = (i % num_squares_width_) * rect1_.w;
                rect1_.y = (i / num_squares_width_) * rect1_.h;
                square_.push_back(rect1_);
                square_age_.push_back(-1);  // -1 indica cuadrado no activado aún
            }

            // Textura inicial: OUT transparente, IN opaca
            Uint8 initial_alpha = (mode_ == Mode::OUT) ? 0 : 255;
            cleanBackbuffer(r_, g_, b_, initial_alpha);

            // Deja el color listo para usar (alpha target para los cuadrados)
            a_ = 255;  // Siempre usar 255 como alpha target

            // Inicializa el tiempo de inicio y recalcula la duración de transición
            random_squares_start_time_ = SDL_GetTicks();
            square_transition_duration_ = std::max(random_squares_duration_ / 4, 100);  // Mínimo 100ms

            break;
        }

        case Type::VENETIAN: {
            // Limpia la textura
            a_ = mode_ == Mode::OUT ? 0 : 255;
            cleanBackbuffer(r_, g_, b_, a_);

            // Deja el color listo para usar
            a_ = mode_ == Mode::OUT ? 255 : 0;

            // Añade los cuadrados al vector
            square_.clear();
            rect1_ = {.x = 0, .y = 0, .w = param.game.width, .h = 0};
            const int MAX = param.game.height / param.fade.venetian_size;

            for (int i = 0; i < MAX; ++i) {
                rect1_.y = i * param.fade.venetian_size;
                square_.push_back(rect1_);
            }

            break;
        }
    }
}

// Establece el color del fade
void Fade::setColor(Uint8 r, Uint8 g, Uint8 b) {
    r_ = r;
    g_ = g;
    b_ = b;
}

// Establece el color del fade
void Fade::setColor(Color color) {
    r_ = color.r;
    g_ = color.g;
    b_ = color.b;
}

// Limpia el backbuffer
void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a) {
    // Dibujamos sobre el backbuffer_
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);

    // Pintamos la textura con el color del fade
    SDL_SetRenderDrawColor(renderer_, r, g, b, a);
    SDL_RenderClear(renderer_);

    // Vuelve a dejar el renderizador como estaba
    SDL_SetRenderTarget(renderer_, temp);
}

// Calcula el valor del estado del fade
auto Fade::calculateValue(int min, int max, int current) -> int {
    if (current < min) {
        return 0;
    }

    if (current > max) {
        return 100;
    }

    return static_cast<int>(100.0 * (current - min) / (max - min));
}