#include "game.h"
#include "utils.h"

void resetScreenScale(Game* game)
{
  Texture texture = game->screen.render.texture;

  // Get screen size on window.
  float renderWidth = GetRenderWidth();
  float renderHeight = GetRenderHeight();
  float scale;

  if (renderWidth > renderHeight)
  {
    scale = (float)renderHeight / texture.height;
  }
  else
  {
    scale = (float)renderWidth / texture.width;
  }

  game->screen.scale = scale;

  float width = texture.width * scale;
  float height = texture.height * scale;

  game->screen.destination = (Rectangle){
    renderWidth / 2.0 - width / 2.0,
    renderHeight / 2.0 - height / 2.0,
    width,
    height
  };

  // Fuck ultra-wide.
  game->screen.ultraWideMode = renderWidth / renderHeight >= MAX_ASPECT;

  if (game->screen.ultraWideMode)
  {
    game->screen.destination = (Rectangle){
      renderWidth / 2.0,
      renderHeight / 2.0,
      renderWidth,
      renderHeight
    };
  }
}

void initGame(Game* game)
{
  game->sceneId = GAME_SCENE;
  
  // Settings.
  game->settings = defaultSettings();
  game->isCrossHairEnabled = game->settings.isCrossHairEnabledDefault;

  // Window.
  InitWindow(game->settings.windowWidth, game->settings.windowHeight,
             "Find Things");
  SetWindowState(FLAG_WINDOW_RESIZABLE);

  // Screen.
  game->screen.render = LoadRenderTexture(game->settings.screenWidth,
                                          game->settings.screenHeight);
  resetScreenScale(game);
  game->screen.postprocesserShader = POSTPROCESSING_SHADER;

  // Assets.
  initAssets(&game->assets, &game->settings);

  // Skybox.
  game->skybox = LoadModelFromMesh(GenMeshCube(1.0, 1.0, 1.0));
  game->skybox.materials[0].shader = game->assets.shaders[SKYBOX_SHADER];
  game->skybox.materials[0].maps[MATERIAL_MAP_CUBEMAP].texture =
    LoadTextureCubemap(game->assets.images[SKYBOX_IMAGE],
                       CUBEMAP_LAYOUT_AUTO_DETECT);

  // World.
  game->world = createWorld(345893, &game->assets);

  // Player.
  game->player = createPlayer();
  game->player.camera.fovy = game->settings.fov;
  game->player.position = Vector3Scale(game->world.size, 0.5);

  // Map.
  initMap(&game->map, &game->settings);

  disableGameCursor(game);
}

void updateMainMenuScene(Game* game)
{
  ClearBackground(BLACK);
}

void drawGameScreen(Game* game)
{
  Texture texture = game->screen.render.texture;

  if (game->screen.ultraWideMode)
  {
    BeginShaderMode(game->assets.shaders[FUCK_SHADER]);
    DrawTexturePro(
      texture,
      (Rectangle){0.0, 0.0, texture.width, -texture.height},
      game->screen.destination,
      (Vector2){GetRenderWidth() / 2.0, GetRenderHeight() / 2.0},
      (int)(GetTime() * ULTRA_WIDE_SPIN_SPEED) % 360,
      WHITE);
    EndShaderMode();

    DrawText("FUCK ULTRA WIDE FUCK ULTRA WIDE FUCK ULTRA WIDE FUCK ULTRA WIDE FUCK ULTRA WIDE FUCK ULTRA WIDE FUCK ULTRA WIDE FUCK ULTRA WIDE",
             0.0, 0.0, 50, RED);
  }
  else
  {
    BeginShaderMode(game->assets.shaders[game->screen.postprocesserShader]);
    DrawTexturePro(
      texture,
      (Rectangle){0.0, 0.0, texture.width, -texture.height},
      game->screen.destination,
      (Vector2){0.0, 0.0},
      0.0,
      WHITE);
    EndShaderMode();
  }
}

void drawCrosshair(float crossHairSize, float crossHairThickness, Color color)
{
  float screenHalfWidth = GetRenderWidth() / 2.0;
  float screenHalfHeight = GetRenderHeight() / 2.0;
  float halfThickness = crossHairThickness / 2.0;

  // Vertical.
  DrawLineEx(
    (Vector2){screenHalfWidth - crossHairSize,
              screenHalfHeight},
    (Vector2){screenHalfWidth + crossHairSize,
              screenHalfHeight},
    crossHairThickness, color);

  // Horizontal.
  DrawLineEx(
    (Vector2){screenHalfWidth,
              screenHalfHeight - crossHairSize},
    (Vector2){screenHalfWidth,
              screenHalfHeight + crossHairSize},
    crossHairThickness, color);
}

void updateGameScene(Game* game)
{
  // Handle toggle cursor.
  if (IsKeyPressed(game->settings.toggleCursorKey))
  {
    if (game->isCursorEnabled)
    {
      disableGameCursor(game);
    }
    else
    {
      enableGameCursor(game);
    }
  }
  
  BeginTextureMode(game->screen.render);
  ClearBackground(BLACK);
  BeginMode3D(game->player.camera);

  // Render skybox.
  rlDisableBackfaceCulling();
  rlDisableDepthMask();
  DrawModel(game->skybox, Vector3Zero(), 1.0, WHITE);
  rlEnableBackfaceCulling();
  rlEnableDepthMask();

  updatePlayer(&game->player, game);
  updateWorld(&game->world, game);

  EndMode3D();
  EndTextureMode();

  ClearBackground(BLACK);

  drawGameScreen(game);

  updateMap(&game->map, game);

  // Cross hair.
  if (IsKeyPressed(game->settings.toggleCrossHairKey))
  {
    game->isCrossHairEnabled = !game->isCrossHairEnabled;
  }

  if (game->isCrossHairEnabled)
  {
    drawCrosshair(game->settings.crossHairSize,
                  game->settings.crossHairThickness,
                  game->settings.crossHairColor);
  }
}

void handleGameResize(Game* game)
{
  resetScreenScale(game);
}

void updateGame(Game* game)
{
  BeginDrawing();

  if (IsWindowResized())
  {
    handleGameResize(game);
  }

  switch (game->sceneId)
  {
  case MAIN_MENU_SCENE:
    updateMainMenuScene(game);
    break;
  case GAME_SCENE:
    updateGameScene(game);
    break;
  default:
    break;
  }

  DrawFPS(0, 0);
  
  EndDrawing();
}

void closeGame(Game* game)
{
  closeAssets(&game->assets);
  UnloadRenderTexture(game->screen.render);
  UnloadTexture(game->skybox.materials[0].maps[MATERIAL_MAP_CUBEMAP].texture);
  UnloadModel(game->skybox);
  freeWorld(game->world);
  CloseWindow();
}

void enableGameCursor(Game* game)
{
  game->isCursorEnabled = true;
  EnableCursor();
}

void disableGameCursor(Game* game)
{
  game->isCursorEnabled = false;
  DisableCursor();
}