#include "utils/utils.hpp"

#include <algorithm>      // Para find, transform
#include <cctype>         // Para tolower
#include <cmath>          // Para round, abs
#include <cstdlib>        // Para abs
#include <exception>      // Para exception
#include <filesystem>     // Para path
#include <iostream>       // Para basic_ostream, cout, basic_ios, ios, endl
#include <string>         // Para basic_string, string, char_traits, allocator
#include <unordered_map>  // Para unordered_map, operator==, _Node_const_iter...
#include <utility>        // Para pair

#include "core/resources/resource_cache.hpp"  // Para Resource

// Calcula el cuadrado de la distancia entre dos puntos
auto distanceSquared(int x1, int y1, int x2, int y2) -> double {
    const int DELTA_X = x2 - x1;
    const int DELTA_Y = y2 - y1;
    return (DELTA_X * DELTA_X) + (DELTA_Y * DELTA_Y);
}

// Detector de colisiones entre dos circulos
auto checkCollision(const Circle& a, const Circle& b) -> bool {
    // Calcula el radio total al cuadrado
    int total_radius_squared = a.r + b.r;
    total_radius_squared = total_radius_squared * total_radius_squared;

    // Si la distancia entre el centro de los circulos es inferior a la suma de sus radios
    return distanceSquared(a.x, a.y, b.x, b.y) < total_radius_squared;
}

// Detector de colisiones entre un circulo y un rectangulo
auto checkCollision(const Circle& a, const SDL_FRect& rect) -> bool {
    SDL_Rect b = toSDLRect(rect);
    // Closest point on collision box
    int c_x;
    int c_y;

    // Find closest x offset
    if (a.x < b.x) {
        c_x = b.x;
    } else if (a.x > b.x + b.w) {
        c_x = b.x + b.w;
    } else {
        c_x = a.x;
    }

    // Find closest y offset
    if (a.y < b.y) {
        c_y = b.y;
    } else if (a.y > b.y + b.h) {
        c_y = b.y + b.h;
    } else {
        c_y = a.y;
    }

    // If the closest point is inside the circle_t
    if (distanceSquared(a.x, a.y, c_x, c_y) < a.r * a.r) {
        // This box and the circle_t have collided
        return true;
    }

    // If the shapes have not collided
    return false;
}

// Detector de colisiones entre dos rectangulos
auto checkCollision(const SDL_FRect& rect_a, const SDL_FRect& rect_b) -> bool {
    SDL_Rect a = toSDLRect(rect_a);
    SDL_Rect b = toSDLRect(rect_b);
    // Calcula las caras del rectangulo a
    const int LEFT_A = a.x;
    const int RIGHT_A = a.x + a.w;
    const int TOP_A = a.y;
    const int BOTTOM_A = a.y + a.h;

    // Calcula las caras del rectangulo b
    const int LEFT_B = b.x;
    const int RIGHT_B = b.x + b.w;
    const int TOP_B = b.y;
    const int BOTTOM_B = b.y + b.h;

    // Si cualquiera de las caras de a está fuera de b
    if (BOTTOM_A <= TOP_B) {
        return false;
    }

    if (TOP_A >= BOTTOM_B) {
        return false;
    }

    if (RIGHT_A <= LEFT_B) {
        return false;
    }

    if (LEFT_A >= RIGHT_B) {
        return false;
    }

    // Si ninguna de las caras está fuera de b
    return true;
}

// Detector de colisiones entre un punto y un rectangulo
auto checkCollision(const SDL_FPoint& point, const SDL_FRect& rect) -> bool {
    SDL_Rect r = toSDLRect(rect);
    SDL_Point p = toSDLPoint(point);

    // Comprueba si el punto está a la izquierda del rectangulo
    if (p.x < r.x) {
        return false;
    }

    // Comprueba si el punto está a la derecha del rectangulo
    if (p.x > r.x + r.w) {
        return false;
    }

    // Comprueba si el punto está por encima del rectangulo
    if (p.y < r.y) {
        return false;
    }

    // Comprueba si el punto está por debajo del rectangulo
    if (p.y > r.y + r.h) {
        return false;
    }

    // Si no está fuera, es que está dentro
    return true;
}

// Detector de colisiones entre una linea horizontal y un rectangulo
auto checkCollision(const LineHorizontal& l, const SDL_FRect& rect) -> bool {
    SDL_Rect r = toSDLRect(rect);
    // Comprueba si la linea esta por encima del rectangulo
    if (l.y < r.y) {
        return false;
    }

    // Comprueba si la linea esta por debajo del rectangulo
    if (l.y >= r.y + r.h) {
        return false;
    }

    // Comprueba si el inicio de la linea esta a la derecha del rectangulo
    if (l.x1 >= r.x + r.w) {
        return false;
    }

    // Comprueba si el final de la linea esta a la izquierda del rectangulo
    if (l.x2 < r.x) {
        return false;
    }

    // Si ha llegado hasta aquí, hay colisión
    return true;
}

// Detector de colisiones entre una linea vertical y un rectangulo
auto checkCollision(const LineVertical& l, const SDL_FRect& rect) -> bool {
    SDL_Rect r = toSDLRect(rect);
    // Comprueba si la linea esta por la izquierda del rectangulo
    if (l.x < r.x) {
        return false;
    }

    // Comprueba si la linea esta por la derecha del rectangulo
    if (l.x >= r.x + r.w) {
        return false;
    }

    // Comprueba si el inicio de la linea esta debajo del rectangulo
    if (l.y1 >= r.y + r.h) {
        return false;
    }

    // Comprueba si el final de la linea esta encima del rectangulo
    if (l.y2 < r.y) {
        return false;
    }

    // Si ha llegado hasta aquí, hay colisión
    return true;
}

// Detector de colisiones entre una linea horizontal y un punto
auto checkCollision(const LineHorizontal& l, const SDL_FPoint& point) -> bool {
    SDL_Point p = toSDLPoint(point);

    // Comprueba si el punto esta sobre la linea
    if (p.y > l.y) {
        return false;
    }

    // Comprueba si el punto esta bajo la linea
    if (p.y < l.y) {
        return false;
    }

    // Comprueba si el punto esta a la izquierda de la linea
    if (p.x < l.x1) {
        return false;
    }

    // Comprueba si el punto esta a la derecha de la linea
    if (p.x > l.x2) {
        return false;
    }

    // Si ha llegado aquí, hay colisión
    return true;
}

// Detector de colisiones entre dos lineas
auto checkCollision(const Line& l1, const Line& l2) -> SDL_Point {
    const float X1 = l1.x1;
    const float Y1 = l1.y1;
    const float X2 = l1.x2;
    const float Y2 = l1.y2;

    const float X3 = l2.x1;
    const float Y3 = l2.y1;
    const float X4 = l2.x2;
    const float Y4 = l2.y2;

    // calculate the direction of the lines
    float u_a = (((X4 - X3) * (Y1 - Y3)) - ((Y4 - Y3) * (X1 - X3))) / (((Y4 - Y3) * (X2 - X1)) - ((X4 - X3) * (Y2 - Y1)));
    float u_b = (((X2 - X1) * (Y1 - Y3)) - ((Y2 - Y1) * (X1 - X3))) / (((Y4 - Y3) * (X2 - X1)) - ((X4 - X3) * (Y2 - Y1)));

    // if uA and uB are between 0-1, lines are colliding
    if (u_a >= 0 && u_a <= 1 && u_b >= 0 && u_b <= 1) {
        // Calcula la intersección
        const float X = X1 + (u_a * (X2 - X1));
        const float Y = Y1 + (u_a * (Y2 - Y1));

        return {.x = static_cast<int>(std::round(X)), .y = static_cast<int>(std::round(Y))};
    }
    return {.x = -1, .y = -1};
}

// Detector de colisiones entre dos lineas
auto checkCollision(const LineDiagonal& l1, const LineVertical& l2) -> SDL_Point {
    const float X1 = l1.x1;
    const float Y1 = l1.y1;
    const float X2 = l1.x2;
    const float Y2 = l1.y2;

    const float X3 = l2.x;
    const float Y3 = l2.y1;
    const float X4 = l2.x;
    const float Y4 = l2.y2;

    // calculate the direction of the lines
    float u_a = (((X4 - X3) * (Y1 - Y3)) - ((Y4 - Y3) * (X1 - X3))) / (((Y4 - Y3) * (X2 - X1)) - ((X4 - X3) * (Y2 - Y1)));
    float u_b = (((X2 - X1) * (Y1 - Y3)) - ((Y2 - Y1) * (X1 - X3))) / (((Y4 - Y3) * (X2 - X1)) - ((X4 - X3) * (Y2 - Y1)));

    // if uA and uB are between 0-1, lines are colliding
    if (u_a >= 0 && u_a <= 1 && u_b >= 0 && u_b <= 1) {
        // Calcula la intersección
        const float X = X1 + (u_a * (X2 - X1));
        const float Y = Y1 + (u_a * (Y2 - Y1));

        return {.x = static_cast<int>(std::round(X)), .y = static_cast<int>(std::round(Y))};
    }
    return {.x = -1, .y = -1};
}

// Normaliza una linea diagonal
void normalizeLine(LineDiagonal& l) {
    // Las lineas diagonales van de izquierda a derecha
    // x2 mayor que x1
    if (l.x2 < l.x1) {
        const int X = l.x1;
        const int Y = l.y1;
        l.x1 = l.x2;
        l.y1 = l.y2;
        l.x2 = X;
        l.y2 = Y;
    }
}

// Convierte SDL_FRect a SDL_Rect
auto toSDLRect(const SDL_FRect& frect) -> SDL_Rect {
    SDL_Rect rect = {
        .x = static_cast<int>(frect.x),
        .y = static_cast<int>(frect.y),
        .w = static_cast<int>(frect.w),
        .h = static_cast<int>(frect.h)};
    return rect;
}

// Convierte SDL_FPoint a SDL_Point
auto toSDLPoint(const SDL_FPoint& fpoint) -> SDL_Point {
    SDL_Point point = {
        .x = static_cast<int>(fpoint.x),
        .y = static_cast<int>(fpoint.y)};
    return point;
}

// Detector de colisiones entre un punto y una linea diagonal
auto checkCollision(const SDL_FPoint& point, const LineDiagonal& l) -> bool {
    SDL_Point p = toSDLPoint(point);

    // Comprueba si el punto está en alineado con la linea
    if (abs(p.x - l.x1) != abs(p.y - l.y1)) {
        return false;
    }

    // Comprueba si está a la derecha de la linea
    if (p.x > l.x1 && p.x > l.x2) {
        return false;
    }

    // Comprueba si está a la izquierda de la linea
    if (p.x < l.x1 && p.x < l.x2) {
        return false;
    }

    // Comprueba si está por encima de la linea
    if (p.y > l.y1 && p.y > l.y2) {
        return false;
    }

    // Comprueba si está por debajo de la linea
    if (p.y < l.y1 && p.y < l.y2) {
        return false;
    }

    // En caso contrario, el punto está en la linea
    return true;
}

// Convierte una cadena a un indice de la paleta
auto stringToColor(const std::string& str) -> Uint8 {
    // Mapas de colores para cada paleta
    static const std::unordered_map<std::string, Uint8> PALETTE_MAP = {
        {"black", 0},
        {"bright_black", 1},

        {"blue", 2},
        {"bright_blue", 3},

        {"red", 4},
        {"bright_red", 5},

        {"magenta", 6},
        {"bright_magenta", 7},

        {"green", 8},
        {"bright_green", 9},

        {"cyan", 10},
        {"bright_cyan", 11},

        {"yellow", 12},
        {"bright_yellow", 13},

        {"white", 14},
        {"bright_white", 15},

        {"transparent", 255}};

    // Busca el color en el mapa
    auto it = PALETTE_MAP.find(str);
    if (it != PALETTE_MAP.end()) {
        return it->second;
    }  // Si no se encuentra el color, devolvemos negro por defecto
    return 0;
}

// Convierte una cadena a un entero de forma segura
auto safeStoi(const std::string& value, int default_value) -> int {
    try {
        return std::stoi(value);
    } catch (const std::exception&) {
        return default_value;
    }
}

// Convierte una cadena a un booleano
auto stringToBool(const std::string& str) -> bool {
    std::string lower_str = str;
    std::ranges::transform(lower_str, lower_str.begin(), ::tolower);
    return (lower_str == "true" || lower_str == "1" || lower_str == "yes" || lower_str == "on");
}

// Convierte un booleano a una cadena
auto boolToString(bool value) -> std::string {
    return value ? "1" : "0";
}

// Compara dos colores
auto colorAreEqual(Color color1, Color color2) -> bool {
    const bool R = color1.r == color2.r;
    const bool G = color1.g == color2.g;
    const bool B = color1.b == color2.b;

    return (R && G && B);
}

// Función para convertir un string a minúsculas
auto toLower(const std::string& str) -> std::string {
    std::string lower_str = str;
    std::ranges::transform(lower_str, lower_str.begin(), ::tolower);
    return lower_str;
}

// Función para convertir un string a mayúsculas
auto toUpper(const std::string& str) -> std::string {
    std::string upper_str = str;
    std::ranges::transform(upper_str, upper_str.begin(), ::toupper);
    return upper_str;
}

// Convierte guiones a espacios ("crt-live" → "crt live")
auto prettyName(const std::string& str) -> std::string {
    std::string result = str;
    std::ranges::replace(result, '-', ' ');
    return result;
}

// Obtiene el nombre de un fichero a partir de una ruta completa
auto getFileName(const std::string& path) -> std::string {
    return std::filesystem::path(path).filename().string();
}

// Obtiene la ruta eliminando el nombre del fichero
auto getPath(const std::string& full_path) -> std::string {
    std::filesystem::path path(full_path);
    return path.parent_path().string();
}

// Imprime por pantalla una linea de texto de tamaño fijo rellena con puntos
void printWithDots(const std::string& text1, const std::string& text2, const std::string& text3) {
    std::cout.setf(std::ios::left, std::ios::adjustfield);
    std::cout << text1;

    std::cout.width(50 - text1.length() - text3.length());
    std::cout.fill('.');
    std::cout << text2;

    std::cout << text3 << '\n';
}

// Comprueba si una vector contiene una cadena
auto stringInVector(const std::vector<std::string>& vec, const std::string& str) -> bool {
    return std::ranges::find(vec, str) != vec.end();
}

// Rellena una textura de un color
void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a) {
    // Guardar el render target actual
    SDL_Texture* previous_target = SDL_GetRenderTarget(renderer);

    // Establecer la textura como el render target
    SDL_SetRenderTarget(renderer, texture);

    // Establecer el color deseado
    SDL_SetRenderDrawColor(renderer, r, g, b, a);

    // Pintar toda el área
    SDL_RenderClear(renderer);

    // Restaurar el render target previo
    SDL_SetRenderTarget(renderer, previous_target);
}

// Añade espacios entre las letras de un string
auto spaceBetweenLetters(const std::string& input) -> std::string {
    std::string result;
    for (size_t i = 0; i < input.size(); ++i) {
        result += input[i];
        if (i != input.size() - 1) {
            result += ' ';
        }
    }
    return result;
}