#include <stdio.h>
#include <math.h>
#include "raylib.h"
#include "raymath.h"

#include "ninja.h"

#define SCREEN_MIDDLE ((Vector2) {window_size.x/2, window_size.y/2})

Vector2 window_size = { 800.0f, 600.0f };

typedef struct Map {
    const Texture texture;
    const Rectangle box;
} Map;

typedef enum KeyControl {
    KC_UP = 0,
    KC_DOWN,
    KC_LEFT,
    KC_RIGHT,
    KC_SHOOT,
    KC_FREECAM,
    KC_CROUCH,
    KC_COUNT,
} KeyControl;

void change_layout_azerty(int *keys)
{
    keys[KC_UP]    = KEY_S;
    keys[KC_DOWN]  = KEY_W;
    keys[KC_LEFT]  = KEY_A;
    keys[KC_RIGHT] = KEY_D;
}

void change_layout_qwerty(int *keys)
{
    keys[KC_UP]    = KEY_W;
    keys[KC_DOWN]  = KEY_S;
    keys[KC_LEFT]  = KEY_A;
    keys[KC_RIGHT] = KEY_D;
}

Vector2 shake(int force)
{
    Vector2 s;
    s.x = GetRandomValue(-force/2, force/2);
    s.y = GetRandomValue(-force/2, force/2);
    return s;
}

void camera_bound(Camera2D *cam, Rectangle bound, float player_radius)
{
    Vector2 coord = GetScreenToWorld2D(SCREEN_MIDDLE, *cam);

    if (coord.x - player_radius < bound.x)
        cam->target.x = bound.x + player_radius;
    else if (coord.x + player_radius > bound.x + bound.width)
        cam->target.x = bound.x + bound.width - player_radius;

    if (coord.y - player_radius < bound.y)
        cam->target.y = bound.y + player_radius;
    else if (coord.y + player_radius > bound.y + bound.height)
        cam->target.y = bound.y + bound.height - player_radius;
}

int main(void)
{
    Camera2D camera = {
        .target = {0},
        .offset = SCREEN_MIDDLE,
        .rotation = 0.0f,
        .zoom = 1.0f,
    };

#ifdef RELEASE
    SetTraceLogLevel(LOG_FATAL);
#endif

    InitWindow(window_size.x, window_size.y, "voleur");
    SetWindowState(FLAG_WINDOW_RESIZABLE);
    SetTargetFPS(60);

#ifdef RELEASE
    SetExitKey(KEY_NULL);
#endif

    Map map = {
        .texture = LoadTexture("data/map2.png"),
        .box = (Rectangle) {
            .x = -map.texture.width/2, .y = -map.texture.height/2,
            .width = map.texture.width, .height = map.texture.height,
        },
    };

    int keys[KC_COUNT] = {0};
    keys[KC_SHOOT]   = MOUSE_BUTTON_LEFT;
    keys[KC_CROUCH]  = KEY_LEFT_SHIFT;
    keys[KC_FREECAM] = KEY_F;
    change_layout_azerty(keys);

    load_ninja();

    while (!WindowShouldClose()) {
        float DT = GetFrameTime();
        if (IsWindowResized()) {
            window_size = (Vector2) {GetScreenWidth(), GetScreenHeight()};
            camera.offset = SCREEN_MIDDLE;
        }

        float movement_speed = 10.0f * DT * 50;
        if ((IsKeyDown(keys[KC_UP]) || IsKeyDown(keys[KC_DOWN])) && (IsKeyDown(keys[KC_LEFT]) || IsKeyDown(keys[KC_RIGHT])))
            movement_speed = sqrtf(movement_speed) * 2;
        if (IsKeyDown(keys[KC_CROUCH]))
            movement_speed /= 2.0f;

        if (IsKeyDown(keys[KC_LEFT]))
            camera.target.x -= movement_speed ;
        if (IsKeyDown(keys[KC_RIGHT]))
            camera.target.x += movement_speed ;
        if (IsKeyDown(keys[KC_DOWN]))
            camera.target.y -= movement_speed ;
        if (IsKeyDown(keys[KC_UP]))
            camera.target.y += movement_speed ;

        camera_bound(&camera, map.box, ninja_radius());

        Vector2 cam_shake = {0};
        if (IsMouseButtonDown(keys[KC_SHOOT]))
            cam_shake = shake(12);

        BeginDrawing();
        {
            ClearBackground(LIME);

            Camera2D effect_camera = camera;
            effect_camera.offset = Vector2Add(effect_camera.offset, cam_shake);
            BeginMode2D(effect_camera);
            {
                DrawTexture(map.texture, map.box.x, map.box.y, WHITE);
            }
            EndMode2D();
            draw_ninja(Vector2Add(SCREEN_MIDDLE, cam_shake));
        }
        EndDrawing();
    }

    CloseWindow();
    return 0;
}