#include <stdbool.h> // bool
#include <stdlib.h> // EXIT_{FAILURE,SUCCESS}
#include <string.h> // strerror
#include <errno.h> // errno
#include <SDL.h>
#include "../levels/levels.h"
#include "../core/sok.h"
#include "util.h"
#include "action.h"
#include "warp-buf.h"
#include "sprites.h"
#include "draw.h"
#include "log-renderer-info.h"
#include "assets.h"

static void
log_moves(
  const sok_ctx_t * const ctx,
  const size_t skip_moves
) {
  char buf[1024] = { 0 };
  size_t ofs = 0;

  for (size_t i = skip_moves; i < ctx->num_moves; i++) {
    if (ctx->moves[i].dir >= SOK_DIR_LAST) {
      die("invalid move: %u", ctx->moves[i].dir);
    }

    buf[ofs++] = SOK_DIR_TO_CHAR(ctx->moves[i].dir);
  }

  SDL_Log("Solution (%d moves): %s", (int) (ctx->num_moves - skip_moves), buf);
}

static TTF_Font *
load_font(
  const asset_id_t id
) {
  // get asset
  const asset_t * const asset = asset_get(ASSET_ROBOTO_TTF);
  if (!asset) {
    die("asset_get()");
  }

  // create io
  SDL_RWops *rw = SDL_RWFromConstMem(asset->buf, asset->len);
  if (!rw) {
    die("SDL_RWFromConstMem(): %s", SDL_GetError());
  }

  // load font
  TTF_Font *font = TTF_OpenFontIndexRW(rw, 1, 16, 0);
  if (!font) {
    die("TTF_OpenFontIndex(): %s", TTF_GetError());
  }

  // return font
  return font;
}

static void
solve_on_error(
  const char * const err
) {
  die("Error solving level: %s", err);
}

static void
set_level(
  SDL_Window * const win,
  draw_ctx_t * const draw_ctx,
  sok_ctx_t * const ctx,
  const size_t level_num
) {
  // get level data
  draw_ctx->level = levels_get_level(level_num);

  // load level
  if (!sok_ctx_set_level(ctx, draw_ctx->level->data)) {
    die("Couldn't load level %d", (int) level_num);
  }

  // log level title
  SDL_Log(
    "Loaded level \"%s: %s\" (#%d)",
    draw_ctx->level->pack,
    draw_ctx->level->name,
    (int) level_num
  );
}

int main(int argc, char *argv[]) {
  size_t level_num = (argc > 1) ? atoi(argv[1]) : 0,
         zoom = 0;

  // init warp buffer
  warp_buf_t warp_buf;
  warp_buf_clear(&warp_buf);

  // init sok context
  sok_ctx_t ctx;
  sok_ctx_init(&ctx, NULL);

  // init sdl
  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
    die("SDL_Init(): %s", SDL_GetError());
  }

  // register SDL exit handler
  if (atexit(SDL_Quit)) {
    die("atexit(SDL_Init): %s", strerror(errno));
    exit(EXIT_FAILURE);
  }

  // init TTF
  if (TTF_Init()) {
    die("TTF_Init(): %s", TTF_GetError());
  }

  // register TTF exit handler
  if (atexit(TTF_Quit)) {
    die("atexit(TTF_Quit): %s", strerror(errno));
    exit(EXIT_FAILURE);
  }

  // create window
  SDL_Window *win = SDL_CreateWindow(
    "Sokoban",
    SDL_WINDOWPOS_UNDEFINED,
    SDL_WINDOWPOS_UNDEFINED,
    800,
    600,
    SDL_WINDOW_RESIZABLE
  );

  // check for error
  if (!win) {
    die("SDL_CreateWindow(): %s", SDL_GetError());
  }

  // create renderer
  SDL_Renderer *renderer = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  if (!renderer) {
    die("SDL_CreateRenderer(): %s", SDL_GetError());
  }

  log_renderer_info(renderer);

  // init draw context
  draw_ctx_t draw_ctx = {
    .level_num  = &level_num,
    .ctx        = &ctx,
    .renderer   = renderer,
    .zoom       = &zoom,
    .theme      = theme_get_default(),
  };

  // set level
  set_level(win, &draw_ctx, &ctx, level_num);

  // init sprites, load font
  sprites_init(renderer, draw_ctx.sprites);
  draw_ctx.font = load_font(ASSET_ROBOTO_TTF);

  bool is_fullscreen = false;
  bool done = false;
  SDL_Event ev;
  while (!done) {
    // read events
    while (SDL_PollEvent(&ev)) {
      // get action
      const action_t action = get_action(&ev);

      // handle action
      switch (action.type) {
      case ACTION_NONE:
        // do nothing
        break;
      case ACTION_QUIT:
        done = true;
        break;
      case ACTION_MOVE:
        if (!sok_ctx_move(&ctx, (sok_dir_t) action.data)) {
          warn("move %s failed", SOK_DIR_TO_STR((sok_dir_t) action.data));
        }

        break;
      case ACTION_UNDO:
        if (!sok_ctx_undo(&ctx)) {
          warn("undo failed");
        }

        break;
      case ACTION_NEXT:
        if (sok_ctx_is_done(&ctx)) {
          // advance level
          level_num++;

          // set level
          set_level(win, &draw_ctx, &ctx, level_num);
        } else {
          warn("cannot advance to next level");
        }

        break;
      case ACTION_RESET:
        // reset level
        if (!sok_ctx_set_level(&ctx, draw_ctx.level->data)) {
          die("Couldn't load level %d", (int) level_num);
        }

        break;
      case ACTION_WARP:
        if (warp_buf_get(&warp_buf, &level_num)) {
          // load level
          set_level(win, &draw_ctx, &ctx, level_num);

          // clear warp buf
          warp_buf_clear(&warp_buf);
        }

        break;
      case ACTION_WARP_BUF_PUSH:
        warp_buf_push_num(&warp_buf, action.data);

        break;
      case ACTION_WARP_BUF_POP:
        warp_buf_pop_num(&warp_buf);

        break;
      case ACTION_SOLVE:
        {
          // get current number of moves
          const size_t old_num_moves = ctx.num_moves;

          if (sok_solve(&ctx, solve_on_error)) {
            // found solution, print it
            log_moves(&ctx, old_num_moves);
          } else {
            warn("Couldn't solve level");
          }
        }

        break;
      case ACTION_ZOOM_IN:
        if (zoom < 30) {
          zoom++;
        }

        break;
      case ACTION_ZOOM_OUT:
        if (zoom > 0) {
          zoom--;
        }

        break;
      case ACTION_FULLSCREEN:
        if (SDL_SetWindowFullscreen(win, is_fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP)) {
          die("SDL_SetWindowFullscreen(): %s", SDL_GetError());
        }

        // toggle flag
        is_fullscreen = !is_fullscreen;

        break;
      default:
        // ignore
        break;
      }
    }

    // draw
    draw(&draw_ctx);
  }

  // fini renderer, window
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(win);

  // return success
  return EXIT_SUCCESS;
}