#include "screen.h"
#include <string>
#include <stdio.h>

// Constructor
Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, options_t *options, int gameInternalResX, int gameInternalResY)
{
    // Inicializa variables
    this->window = window;
    this->renderer = renderer;
    this->options = options;

    gameCanvasWidth = gameInternalResX;
    gameCanvasHeight = gameInternalResY;

    // Establece el modo de video
    setVideoMode(options->fullScreenMode);

    // Define el color del borde para el modo de pantalla completa
    borderColor = {0x00, 0x00, 0x00};

    // Crea la textura donde se dibujan los graficos del juego
    gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, gameCanvasWidth, gameCanvasHeight);
    if (gameCanvas == NULL)
        printf("TitleSurface could not be created!\nSDL Error: %s\n", SDL_GetError());

    // Calcula los anclajes
    anchor.left = 0;
    anchor.right = gameCanvasWidth;
    anchor.center = gameCanvasWidth / 2;
    anchor.top = 0;
    anchor.bottom = gameCanvasHeight;
    anchor.middle = gameCanvasHeight / 2;
}

// Destructor
Screen::~Screen()
{
    renderer = nullptr;
}

// Limpia la pantalla
void Screen::clean(color_t color)
{
    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
    SDL_RenderClear(renderer);
}

// Prepara para empezar a dibujar en la textura de juego
void Screen::start()
{
    SDL_SetRenderTarget(renderer, gameCanvas);
}

// Vuelca el contenido del renderizador en pantalla
void Screen::blit()
{
    // Vuelve a dejar el renderizador en modo normal
    SDL_SetRenderTarget(renderer, NULL);

    // Borra el contenido previo
    SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
    SDL_RenderClear(renderer);

    // Copia la textura de juego en el renderizador en la posición adecuada
    SDL_RenderCopy(renderer, gameCanvas, NULL, &dest);

    // Muestra por pantalla el renderizador
    SDL_RenderPresent(renderer);
}

// Establece el modo de video
void Screen::setVideoMode(int fullScreenMode)
{
    // Aplica el modo de video
    SDL_SetWindowFullscreen(window, fullScreenMode);

    // Si está activo el modo ventana quita el borde
    if (fullScreenMode == 0)
    {
        screenWidth = gameCanvasWidth;
        screenHeight = gameCanvasHeight;
        dest = {0, 0, gameCanvasWidth, gameCanvasHeight};

        // Modifica el tamaño del renderizador y de la ventana
        SDL_RenderSetLogicalSize(renderer, screenWidth, screenHeight);
        SDL_SetWindowSize(window, screenWidth * options->windowSize, screenHeight * options->windowSize);
    }

    // Si está activo el modo de pantalla completa añade el borde
    else if (fullScreenMode == SDL_WINDOW_FULLSCREEN_DESKTOP)
    {
        // Obten el alto y el ancho de la ventana
        SDL_GetWindowSize(window, &screenWidth, &screenHeight);

        // Aplica el escalado al rectangulo donde se pinta la textura del juego
        if (options->integerScale)
        {
            // Calcula el tamaño de la escala máxima
            int scale = 0;
            while (((gameCanvasWidth * (scale + 1)) <= screenWidth) && ((gameCanvasHeight * (scale + 1)) <= screenHeight))
            {
                scale++;
            }

            dest.w = gameCanvasWidth * scale;
            dest.h = gameCanvasHeight * scale;
            dest.x = (screenWidth - dest.w) / 2;
            dest.y = (screenHeight - dest.h) / 2;
        }
        else if (options->keepAspect)
        {
            float ratio = (float)gameCanvasWidth / (float)gameCanvasHeight;
            if ((screenWidth - gameCanvasWidth) >= (screenHeight - gameCanvasHeight))
            {
                dest.h = screenHeight;
                dest.w = (int)((screenHeight * ratio) + 0.5f);
                dest.x = (screenWidth - dest.w) / 2;
                dest.y = (screenHeight - dest.h) / 2;
            }
            else
            {
                dest.w = screenWidth;
                dest.h = (int)((screenWidth / ratio) + 0.5f);
                dest.x = (screenWidth - dest.w) / 2;
                dest.y = (screenHeight - dest.h) / 2;
            }
        }
        else
        {
            dest.w = screenWidth;
            dest.h = screenHeight;
            dest.x = dest.y = 0;
        }

        // Modifica el tamaño del renderizador
        SDL_RenderSetLogicalSize(renderer, screenWidth, screenHeight);
    }

    // Actualiza el valor de la variable
    options->fullScreenMode = fullScreenMode;
}

// Camibia entre pantalla completa y ventana
void Screen::switchVideoMode()
{
    if (options->fullScreenMode == 0)
    {
        setVideoMode(SDL_WINDOW_FULLSCREEN_DESKTOP);
    }
    else
    {
        setVideoMode(0);
    }
}

// Cambia el tamaño de la ventana
void Screen::setWindowSize(int size)
{
    options->windowSize = size;
    setVideoMode(0);
}

// Cambia el color del borde
void Screen::setBorderColor(color_t color)
{
    borderColor = color;
}

// Cambia el tipo de mezcla
void Screen::setBlendMode(SDL_BlendMode blendMode)
{
    SDL_SetRenderDrawBlendMode(renderer, blendMode);
}