#include "utils/utils.hpp"

#include <stdlib.h>  // Para abs

#include <algorithm>      // Para find, transform
#include <cctype>         // Para tolower
#include <cmath>          // Para round, 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.hpp"  // Para Resource
#include "external/jail_audio.h"        // Para JA_GetMusicState, JA_Music_state, JA_PlayMusic

// Calcula el cuadrado de la distancia entre dos puntos
double distanceSquared(int x1, int y1, int x2, int y2) {
    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
bool checkCollision(const Circle& a, const Circle& b) {
    // 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
    if (distanceSquared(a.x, a.y, b.x, b.y) < (total_radius_squared)) {
        // Los circulos han colisionado
        return true;
    }

    // En caso contrario
    return false;
}

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

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

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

    // If the closest point is inside the circle_t
    if (distanceSquared(a.x, a.y, cX, cY) < 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
bool checkCollision(const SDL_FRect& rect_a, const SDL_FRect& rect_b) {
    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
bool checkCollision(const SDL_FPoint& point, const SDL_FRect& rect) {
    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
bool checkCollision(const LineHorizontal& l, const SDL_FRect& rect) {
    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
bool checkCollision(const LineVertical& l, const SDL_FRect& rect) {
    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
bool checkCollision(const LineHorizontal& l, const SDL_FPoint& point) {
    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
SDL_Point checkCollision(const Line& l1, const Line& l2) {
    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 {static_cast<int>(round(X)), static_cast<int>(round(Y))};
    }
    return {-1, -1};
}

// Detector de colisiones entre dos lineas
SDL_Point checkCollision(const LineDiagonal& l1, const LineVertical& l2) {
    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 {static_cast<int>(X), static_cast<int>(Y)};
    }
    return {-1, -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;
    }
}

// Detector de colisiones entre un punto y una linea diagonal
bool checkCollision(const SDL_FPoint& point, const LineDiagonal& l) {
    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
Uint8 stringToColor(const std::string& str) {
    // 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
int safeStoi(const std::string& value, int default_value) {
    try {
        return std::stoi(value);
    } catch (const std::exception&) {
        return default_value;
    }
}

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

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

// Compara dos colores
bool colorAreEqual(Color color1, Color color2) {
    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
std::string toLower(const std::string& str) {
    std::string lower_str = str;
    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), ::tolower);
    return lower_str;
}

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

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

// Obtiene la ruta eliminando el nombre del fichero
std::string getPath(const std::string& full_path) {
    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 << std::endl;
}

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

// Hace sonar la música
void playMusic(const std::string& music_path) {
    // Si la música no está sonando
    if (JA_GetMusicState() == JA_MUSIC_INVALID || JA_GetMusicState() == JA_MUSIC_STOPPED) {
        JA_PlayMusic(Resource::get()->getMusic(music_path));
    }
}

// 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);
}