#include "main.h"

extern struct Resources g_resources = { 0 };

struct WindowTransform {
    Vector2 offset;
    float scale;
};

static void begin_window_scaling(struct WindowTransform *transform, Vector2 virtual_screen_size)
{
    Vector2 screen_size = {
        GetScreenWidth(),
        GetScreenHeight()
    };

    float scale = MIN(
        screen_size.x / virtual_screen_size.x,
        screen_size.y / virtual_screen_size.y
    );
    transform->scale = scale;

    Vector2 filler_size = Vector2Scale(Vector2Subtract(screen_size, Vector2Scale(virtual_screen_size, transform->scale)), 0.5);
    transform->offset = filler_size;

    rlPushMatrix();
    rlTranslatef(
        filler_size.x,
        filler_size.y,
        0
    );
    rlScalef(scale, scale, 1);
}

static void end_window_scaling(struct WindowTransform *transform, Color color)
{
    rlPopMatrix();

    Vector2 filler_size = transform->offset;

    DrawRectangleRec(
        (struct Rectangle){
            .x = 0,
            .y = 0,
            .width = GetScreenWidth(),
            .height = filler_size.y
        },
        color
    );

    DrawRectangleRec(
        (struct Rectangle){
            .x = 0,
            .y = GetScreenHeight() - filler_size.y,
            .width = GetScreenWidth(),
            .height = filler_size.y
        },
        color
    );

    DrawRectangleRec(
        (struct Rectangle){
            .x = 0,
            .y = 0,
            .width = filler_size.x,
            .height = GetScreenHeight()
        },
        color
    );

    DrawRectangleRec(
        (struct Rectangle){
            .x = GetScreenWidth() - filler_size.x,
            .y = 0,
            .width = filler_size.x,
            .height = GetScreenHeight()
        },
        color
    );
}

int main(void)
{
    InitWindow(800, 600, "gaem");
    InitAudioDevice();
    SetWindowState(FLAG_WINDOW_RESIZABLE);
    SetTargetFPS(60);

    resources_init(&g_resources);

    struct Game game = { 0 };
    game_init(&game);

    game_debug_init();

    while (!WindowShouldClose())
    {
        TracyCFrameMark;

        // TODO: Can this be called every frame? Will it impact performance? Needs research.
        SetWindowMinSize(game.canvas_size.x, game.canvas_size.y);

        float dt = GetFrameTime();
        BeginDrawing();
        ClearBackground(RAYWHITE);

        struct WindowTransform transform = { 0 };
        begin_window_scaling(&transform, game.canvas_size);
        Vector2 mouse = GetMousePosition();
        mouse = Vector2Subtract(mouse, transform.offset);
        mouse = Vector2Scale(mouse, 1/transform.scale);

        game.input = (struct Input){
            .dt = dt,
            .mouse = mouse
        };
        game_tick(&game);
        end_window_scaling(&transform, BLACK);

        game_debug_show(&game);

        EndDrawing();
    }

    game_free(&game);
    game_debug_deinit();
    CloseWindow();

    return 0;
}