#include "utils.h"
#include <stdlib.h>      // for free, malloc, abs
#include <algorithm>     // for transform
#include <cctype>        // for tolower
#include <cmath>         // for round, abs
#include <exception>     // for exception
#include <filesystem>    // for path
#include <iostream>      // for basic_ostream, cout, basic_ios, ios, endl
#include <unordered_map> // for unordered_map
#include <string>        // for string

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

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

    // 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) < (totalRadiusSquared))
    {
        // Los circulos han colisionado
        return true;
    }

    // En caso contrario
    return false;
}

// Detector de colisiones entre un circulo y un rectangulo
bool checkCollision(Circle &a, SDL_Rect &b)
{
    // Closest point on collision box
    int cX, 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(SDL_Rect &a, SDL_Rect &b)
{
    // Calcula las caras del rectangulo a
    const int leftA = a.x;
    const int rightA = a.x + a.w;
    const int topA = a.y;
    const int bottomA = a.y + a.h;

    // Calcula las caras del rectangulo b
    const int leftB = b.x;
    const int rightB = b.x + b.w;
    const int topB = b.y;
    const int bottomB = b.y + b.h;

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

    if (topA >= bottomB)
    {
        return false;
    }

    if (rightA <= leftB)
    {
        return false;
    }

    if (leftA >= rightB)
    {
        return false;
    }

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

// Detector de colisiones entre un punto y un rectangulo
bool checkCollision(SDL_Point &p, SDL_Rect &r)
{
    // 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(h_line_t &l, SDL_Rect &r)
{
    // 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(v_line_t &l, SDL_Rect &r)
{
    // 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(h_line_t &l, SDL_Point &p)
{
    // 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(line_t &l1, line_t &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 uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
    float uB = ((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 (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1)
    {
        // Calcula la intersección
        const float x = x1 + (uA * (x2 - x1));
        const float y = y1 + (uA * (y2 - y1));

        return {(int)round(x), (int)round(y)};
    }
    return {-1, -1};
}

// Detector de colisiones entre dos lineas
SDL_Point checkCollision(d_line_t &l1, v_line_t &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 uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
    float uB = ((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 (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1)
    {
        // Calcula la intersección
        const float x = x1 + (uA * (x2 - x1));
        const float y = y1 + (uA * (y2 - y1));

        return {(int)x, (int)y};
    }
    return {-1, -1};
}

// Normaliza una linea diagonal
void normalizeLine(d_line_t &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(SDL_Point &p, d_line_t &l)
{
    // 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 color
Color stringToColor(Palette pal, const std::string &str)
{
    // Mapas de colores para cada paleta
    static const std::unordered_map<std::string, Color> zxSpectrumColors = {
        {"black", {0x00, 0x00, 0x00}},
        {"bright_black", {0x00, 0x00, 0x00}},
        {"blue", {0x00, 0x00, 0xD8}},
        {"bright_blue", {0x00, 0x00, 0xFF}},
        {"red", {0xD8, 0x00, 0x00}},
        {"bright_red", {0xFF, 0x00, 0x00}},
        {"magenta", {0xD8, 0x00, 0xD8}},
        {"bright_magenta", {0xFF, 0x00, 0xFF}},
        {"green", {0x00, 0xD8, 0x00}},
        {"bright_green", {0x00, 0xFF, 0x00}},
        {"cyan", {0x00, 0xD8, 0xD8}},
        {"bright_cyan", {0x00, 0xFF, 0xFF}},
        {"yellow", {0xD8, 0xD8, 0x00}},
        {"bright_yellow", {0xFF, 0xFF, 0x00}},
        {"white", {0xD8, 0xD8, 0xD8}},
        {"bright_white", {0xFF, 0xFF, 0xFF}}};

    static const std::unordered_map<std::string, Color> zxArneColors = {
        {"black", {0x00, 0x00, 0x00}},
        {"bright_black", {0x3C, 0x35, 0x1F}},
        {"blue", {0x31, 0x33, 0x90}},
        {"bright_blue", {0x15, 0x59, 0xDB}},
        {"red", {0xA7, 0x32, 0x11}},
        {"bright_red", {0xD8, 0x55, 0x25}},
        {"magenta", {0xA1, 0x55, 0x89}},
        {"bright_magenta", {0xCD, 0x7A, 0x50}},
        {"green", {0x62, 0x9A, 0x31}},
        {"bright_green", {0x9C, 0xD3, 0x3C}},
        {"cyan", {0x28, 0xA4, 0xCB}},
        {"bright_cyan", {0x65, 0xDC, 0xD6}},
        {"yellow", {0xE8, 0xBC, 0x50}},
        {"bright_yellow", {0xF1, 0xE7, 0x82}},
        {"white", {0xBF, 0xBF, 0xBD}},
        {"bright_white", {0xF2, 0xF1, 0xED}}};

    // Selecciona el mapa de colores adecuado según la paleta
    const std::unordered_map<std::string, Color> *paletteMap = nullptr;

    if (pal == Palette::ZXSPECTRUM)
    {
        paletteMap = &zxSpectrumColors;
    }
    else if (pal == Palette::ZXARNE)
    {
        paletteMap = &zxArneColors;
    }
    else
    {
        // Paleta desconocida, devolvemos negro por defecto
        return {0x00, 0x00, 0x00};
    }

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

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

// Convierte una cadena a un booleano
bool stringToBool(const std::string &str)
{
    std::string lowerStr = str;
    std::transform(lowerStr.begin(), lowerStr.end(), lowerStr.begin(), ::tolower);
    return (lowerStr == "true" || lowerStr == "1" || lowerStr == "yes" || lowerStr == "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);
}

// Convierte una cadena a minusculas
std::string toLower(std::string str)
{
    const char *original = str.c_str();
    char *lower = (char *)malloc(str.size() + 1);
    for (int i = 0; i < (int)str.size(); ++i)
    {
        char c = original[i];
        lower[i] = (c >= 65 && c <= 90) ? c + 32 : c;
    }
    lower[str.size()] = 0;
    std::string result(lower);
    free(lower);
    return result;
}

// Convierte una cadena a mayúsculas
std::string toUpper(std::string str)
{
    const char *original = str.c_str();
    char *upper = (char *)malloc(str.size() + 1);
    for (int i = 0; i < (int)str.size(); ++i)
    {
        char c = original[i];
        upper[i] = (c >= 97 && c <= 122) ? c - 32 : c;
    }
    upper[str.size()] = 0;
    std::string result(upper);
    free(upper);
    return result;
}

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