// line_renderer.cpp - Implementació de renderitzat de línies
// © 1999 Visente i Sergi (versió Pascal)
// © 2025 Port a C++20 amb SDL3

#include "core/rendering/line_renderer.hpp"

#include <cmath>

#include "core/rendering/coordinate_transform.hpp"

namespace Rendering {

// [NUEVO] Color global compartit (actualitzat per ColorOscillator via
// SDLManager)
SDL_Color g_current_line_color = {255, 255, 255, 255};  // Blanc inicial

bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar, float brightness) {
    // Algorisme de Bresenham per dibuixar línies
    // Basat en el codi Pascal original

    // Helper function: retorna el signe d'un nombre
    auto sign = [](int x) -> int {
        if (x < 0)
            return -1;
        if (x > 0)
            return 1;
        return 0;
    };

    // Variables per a l'algorisme (no utilitzades fins Fase 10 - detecció de
    // col·lisions) int x = x1, y = y1; int xs = x2 - x1; int ys = y2 - y1; int
    // xm = sign(xs); int ym = sign(ys); xs = std::abs(xs); ys = std::abs(ys);

    // Suprimir warning de variable no usada
    (void)sign;

    // Detecció de col·lisió (TODO per Fase 10)
    // El codi Pascal original llegia pixels del framebuffer bit-packed
    // i comptava col·lisions. Per ara, usem SDL_RenderDrawLine i retornem false.
    bool colisio = false;

    // Dibuixar amb SDL3 (més eficient que Bresenham píxel a píxel)
    if (dibuixar && renderer) {
        // Transformar coordenades lògiques (640x480) a físiques (resolució real)
        float scale = g_current_scale_factor;
        int px1 = transform_x(x1, scale);
        int py1 = transform_y(y1, scale);
        int px2 = transform_x(x2, scale);
        int py2 = transform_y(y2, scale);

        // Aplicar brightness al color oscil·lat global
        SDL_Color color_final;
        color_final.r = static_cast<uint8_t>(g_current_line_color.r * brightness);
        color_final.g = static_cast<uint8_t>(g_current_line_color.g * brightness);
        color_final.b = static_cast<uint8_t>(g_current_line_color.b * brightness);
        color_final.a = 255;

        SDL_SetRenderDrawColor(renderer, color_final.r, color_final.g, color_final.b, 255);

        // Renderitzar amb coordenades físiques
        SDL_RenderLine(renderer, static_cast<float>(px1), static_cast<float>(py1), static_cast<float>(px2), static_cast<float>(py2));
    }

    // Algorisme de Bresenham original (conservat per a futura detecció de
    // col·lisió)
    /*
    if (xs > ys) {
        // Línia plana (<45 graus)
        int count = -(xs / 2);
        while (x != x2) {
            count = count + ys;
            x = x + xm;
            if (count > 0) {
                y = y + ym;
                count = count - xs;
            }
            // Aquí aniria la detecció de col·lisió píxel a píxel
        }
    } else {
        // Línia pronunciada (>=45 graus)
        int count = -(ys / 2);
        while (y != y2) {
            count = count + xs;
            y = y + ym;
            if (count > 0) {
                x = x + xm;
                count = count - ys;
            }
            // Aquí aniria la detecció de col·lisió píxel a píxel
        }
    }
    */

    return colisio;
}

// [NUEVO] Establir el color global de les línies
void setLineColor(SDL_Color color) { g_current_line_color = color; }

}  // namespace Rendering