#include <time.h>

#include "app.h"
#include "enginePostfx.h"
#include "game.h"
#include "raylib.h"

const ShaderAsset shaderAssets[SHADER_COUNT] = {{"shaders/postfx.fs"}};
const SoundtrackAsset soundtrackAssets[SOUNDTRACK_COUNT] = {{"assets/gameplay_theme.mp3"},
                                                            {"assets/sea.wav"}};

void InitGame(App *app) {
  SetRandomSeed(GetRandomValue(0, 10000000));
  GameState *g = &app->game;
  g->assets = (Assets){.shaderAssets = shaderAssets, .soundtrackAssets = soundtrackAssets};

  for (int i = 0; i < SHADER_COUNT; i++) {
    g->postFX[i] = CreatePostFX(g->assets.shaderAssets[i].path);
  }

  for (int i = 0; i < SOUNDTRACK_COUNT; i++) {
    g->soundtracks[i] = LoadSoundtrack(g->assets.soundtrackAssets[i].path);
  }

  g->target = LoadRenderTexture(app->window.width, app->window.height);
  g->postFXTarget = LoadRenderTexture(app->window.width, app->window.height);

  g->camera = CreateCamera((Vector2){0.0f, 0.0f}, 10.0f);
  g->terrain = CreateTerrain(&g->camera);
  g->player = CreatePlayer(&g->terrain);
  g->camera.target = g->player.physics.position;
  g->birds = CreateBirds(&g->camera);
  g->enemies = CreateEnemies(&g->camera, &g->terrain);
  g->floor = CreateFloor();
  g->clouds = CreateClouds();
  g->wake = CreateWake();
  g->projectiles = CreateProjectiles();
  g->overlay = CreateOverlay();

  Texture2D mouseTexture = LoadTextureCached("assets/mouse.png");
  g->mouse = CreateMouse(0.10f, 5.0f, 10.0f, &mouseTexture);
}

static void StartGame(App *app) {
  app->state.gameStarted = true;
}

void UpdateGame(App *app) {
  GameState *g = &app->game;
  SetTargetFPS(app->flags.limitFPS ? 60 : 0);

  StartGame(app);

  OnEscapeChangeView(app, MENU);
  OnWindowClosedStoppApp(app);
  OnBoolChangeView(g->player.health <= 0, app, GAMEOVER);

  UpdateShaders(g->postFX, SHADER_COUNT);
  UpdateMouse(&g->mouse, &g->camera);
  UpdateCamera2D(&g->camera, &g->player.physics.position, &g->mouse);
  UpdateFloor(&g->floor, &g->camera);
  UpdateClouds(&g->clouds, GetFrameTime());
  UpdateWake(&g->wake, GetFrameTime());
  UpdatePlayer(&g->player);
  UpdateBirds(&g->birds, &g->camera);
  UpdateTerrain(&g->terrain, &g->camera);
  UpdateEnemies(&g->enemies, &g->camera, &g->projectiles, &g->player, &g->terrain);
  UpdateSoundtrack(&g->soundtracks[AMBIENT], app->flags.soundtrackOn);
  UpdateProjectiles(&g->projectiles, &g->player);

  UpdateOverlay(&g->overlay, &g->player);

  CheckPlayerCollisions(&g->player, &g->enemies);
  CheckEnemyCollisions(&g->enemies);
  CheckProjectileCollisions(&g->projectiles, &g->enemies, &g->player);
  CheckTerrainCollisions(&g->player, &g->enemies, &g->terrain);
}

void ResetGame(App *app) {
  GameState *g = &app->game;
  SetRandomSeed(GetRandomValue(0, 10000000));
  ResetPlayer(&g->player, &g->terrain);
  g->camera = CreateCamera(g->player.physics.position, 10.0f);
  g->enemies = CreateEnemies(&g->camera, &g->terrain);
  ResetProjectiles(&g->projectiles);
}

static void RenderShipWakes(App *app) {
  GameState *g = &app->game;
  RenderShipWake(&g->wake, &g->player.wakeTrail, GetActualSpeed(&g->player.physics));
  for (int i = 0; i < g->enemies.count; i++) {
    if (!g->enemies.alive[i])
      continue;
    RenderShipWake(&g->wake, &g->enemies.wakeTrail[i], GetActualSpeed(&g->enemies.physics[i]));
  }
}

void RenderComponents(App *app) {
  GameState *g = &app->game;
  RenderFloor(&g->floor);
  RenderTerrain(&g->terrain);
  RenderCloudShadows(&g->clouds, &g->camera);
  RenderShipWakes(app);
  RenderPlayer(&g->player);
  RenderEnemies(&g->enemies);
  RenderBirds(&g->birds);
  RenderProjectiles(&g->projectiles);
  RenderClouds(&g->clouds, &g->camera);
}

static void RenderPostFXChain(App *app, RenderTexture2D *sceneTarget) {
  GameState *g = &app->game;
  RenderTexture2D *buffers[2] = {sceneTarget, &g->postFXTarget};
  int srcIndex = 0;

  for (int i = 0; i < SHADER_COUNT; i++) {
    bool isLast = (i == SHADER_COUNT - 1);
    RenderTexture2D *source = buffers[srcIndex];
    int dstIndex = 1 - srcIndex;

    if (isLast) {
      BeginDrawing();
      ClearBackground(BLACK);
      RenderPostFX(&g->postFX[i], source);
      if (app->flags.showFPS) {
        DrawFPS(10, 10);
      }
      EndDrawing();
    } else {
      BeginTextureMode(*buffers[dstIndex]);
      RenderPostFX(&g->postFX[i], source);
      EndTextureMode();
      srcIndex = dstIndex;
    }
  }
}

void RenderGame(App *app) {
  GameState *g = &app->game;

  BeginTextureMode(g->target);
  ClearBackground(BLACK);
  BeginMode2D(g->camera);
  RenderComponents(app);
  EndMode2D();
  RenderOverlay(&g->mouse, &g->player, &g->overlay.rose);
  EndTextureMode();

  RenderPostFXChain(app, &g->target);
}

void CleanupGame(App *app) {
  GameState *g = &app->game;
  for (int i = 0; i < SHADER_COUNT; i++) {
    UnloadPostFX(&g->postFX[i]);
  }
  for (int i = 0; i < SOUNDTRACK_COUNT; i++) {
    UnloadMusicStream(g->soundtracks[i].music);
  }
  UnloadTerrain(&g->terrain);
  UnloadClouds(&g->clouds);
  UnloadWake(&g->wake);
  UnloadRenderTexture(g->target);
  UnloadRenderTexture(g->postFXTarget);
}