//Using SDL and standard IO
#include <SDL2/SDL.h>
// #include <SDL2/SDL_image.h>
// #include <SDL2/SDL_ttf.h>

#include <stdio.h>
#include <stdbool.h>

#include "../../truco.h"
#include "../../interfaces/truco_interfaz_comun.h"
#include "../../interfaces/truco_stdio.h"

//Screen dimension constants
#define ANCHO_PANTALLA 640
#define ALTURA_PANTALLA 480

#define MAX_INTERACTUABLES_MOUSE MAX_CARTAS_MANO

SDL_Window *ventana;
SDL_Renderer *renderer;

// SDL_Texture *cargar_textura_y_avisar_error(char *fn){
//     SDL_Texture *textura = IMG_LoadTexture(renderer, fn);
//     if(!textura) printf("Error cargando textura: %s\n", IMG_GetError());
//     return textura;
// }

typedef struct{
    SDL_Rect rect;
    uint8_t valor;
} InteractuableMouse;

int main( int argc, char* args[] )
{
    if(SDL_Init(SDL_INIT_EVERYTHING)) { printf("Error inicializando SDL: %s\n", SDL_GetError()); return 1; }
    
    InteractuableMouse interactuables_mouse[MAX_INTERACTUABLES_MOUSE];
    uint8_t interactuables_mouse_i = 0;

    EstadoPartida partida;

    partida.numero_jugadores = 2;
    partida.max_puntos = 30;
    SET_BIT(partida.flags_partida, FLAG_PARTIDA_FLOR);

    iniciar_partida(&partida);

    ventana = SDL_CreateWindow(
        "Truco C (SDL)",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        ANCHO_PANTALLA, ALTURA_PANTALLA,
        0
    );

    renderer = SDL_CreateRenderer(ventana, -1, 0);

    bool seguir = true;

    while(seguir){

        SDL_Event evento;

        uint8_t jugador_turno_actual = obtener_jugador_turno_actual(&partida);

        while(SDL_PollEvent(&evento)){
            switch(evento.type){
                case SDL_MOUSEBUTTONUP: {
                    for(uint8_t i = 0; i < interactuables_mouse_i; i++){
                        InteractuableMouse *interactuable = &interactuables_mouse[i];

                        if(!(evento.button.x >= interactuable->rect.x &&
                        evento.button.x <= interactuable->rect.x + interactuable->rect.w &&
                        evento.button.y >= interactuable->rect.y  &&
                        evento.button.y <= interactuable->rect.y + interactuable->rect.h)) continue;

                        for(uint8_t i = 0; i < MAX_CARTAS_MANO; i++){
                            uint8_t carta_i = partida.jugadores_cartas[jugador_turno_actual][i];

                            if(carta_i != interactuable->valor) continue;

                            TCIC_jugar_baza(&partida, jugador_turno_actual, i);
                            break;
                        }
                    }
                    break;
                }
                case SDL_QUIT: {
                    seguir = false;
                    break;
                }
                default: break;
            }
        }

        SDL_SetRenderDrawColor(renderer, 0, 128, 0, SDL_ALPHA_OPAQUE);

        SDL_RenderClear(renderer);

        for(uint8_t i = 0; i < MAX_INTERACTUABLES_MOUSE; i++){
            interactuables_mouse[i] = (InteractuableMouse){
                .rect = (SDL_Rect){
                    .x = ANCHO_PANTALLA + 1,
                    .y = ALTURA_PANTALLA + 1,
                    .w = 0,
                    .h = 0,
                },
                .valor = CARTA_INVALIDA,
            };
        }

        interactuables_mouse_i = 0;

        const int ancho_carta = 72;
        const int largo_carta = 140;
        const int marco_margen = 10;

        uint8_t cartas_en_orden[MAX_CARTAS_MANO];
        uint8_t cartas_en_mano = 0;

        for(uint8_t i = 0; i < MAX_CARTAS_MANO; i++){
            uint8_t carta_i = partida.jugadores_cartas[jugador_turno_actual][i];
            if(carta_i != CARTA_INVALIDA){
                cartas_en_orden[cartas_en_mano++] = carta_i;
            }
        }

        SDL_Rect rect;

        const int margen_ancho = ancho_carta + 20;

        for(uint8_t i = 0; i < cartas_en_mano; i++){

            uint8_t carta_i = cartas_en_orden[i];

            const int x = (ANCHO_PANTALLA - margen_ancho * cartas_en_mano) / 2 + i * (margen_ancho);
            const int y = (ALTURA_PANTALLA - largo_carta - 15);
            const int w = ancho_carta;
            const int h = largo_carta;


            rect.x = x;
            rect.y = y;
            rect.w = w;
            rect.h = h;

            interactuables_mouse[interactuables_mouse_i++] = (InteractuableMouse){
                .valor = carta_i,
                .rect = rect,
            };

            SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
            SDL_RenderFillRect(renderer, &rect);

            rect.x = x + marco_margen;
            rect.y = y + marco_margen;
            rect.w = w - marco_margen * 2;
            rect.h = h - marco_margen * 2;

            SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
            SDL_RenderDrawRect(renderer, &rect);
        }

        const int margen_largo = largo_carta + 10;

        for(uint8_t i = 0; i <= partida.baza_actual; i++){
            
            for(uint8_t j = 0; j < partida.numero_jugadores; j++){

                uint8_t carta_i = partida.cartas_bazas[i][j];

                if(carta_i == CARTA_INVALIDA) continue;

                const int x = ((ANCHO_PANTALLA - ancho_carta) / 3) + (i * margen_ancho);
                const int y = (10 * partida.numero_jugadores) / 3 + j * margen_largo;
                const int w = ancho_carta;
                const int h = largo_carta;


                rect.x = x;
                rect.y = y;
                rect.w = w;
                rect.h = h;

                SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
                SDL_RenderFillRect(renderer, &rect);

                rect.x = x + marco_margen;
                rect.y = y + marco_margen;
                rect.w = w - marco_margen * 2;
                rect.h = h - marco_margen * 2;

                SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
                SDL_RenderDrawRect(renderer, &rect);
            }

        }

        SDL_RenderPresent(renderer);
        SDL_Delay(50);
    }


    return 0;
}

ResultadoJugada TCIC_jugar_baza(EstadoPartida *partida, uint8_t jugador_i, uint8_t carta_i){
    return jugar_baza(partida, jugador_i, carta_i);
};

ResultadoJugada TCIC_cantar(EstadoPartida *partida, uint8_t jugador_i, uint8_t canto){};

ResultadoJugada TCIC_cantar_tanto(EstadoPartida *partida, uint8_t jugador_i){};