#include <stdbool.h> // bool
#include <stdlib.h> // EXIT_{FAILURE,SUCCESS}
#include <string.h> // strerror
#include <errno.h> // errno
#include <SDL.h>
#include <SDL_image.h>
#include "../text/levels.h"
#include "../libsok/sok.h"
#include "util.h"
#include "action.h"
#include "warp-buf.h"
#include "sprites.h"
#include "draw.h"

static void
draw_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 (%zu moves): %s", ctx->num_moves - skip_moves, buf);
}

static void
log_renderer_info(
  SDL_Renderer * const renderer
) {
  SDL_RendererInfo info;

  // get renderer info
  if (SDL_GetRendererInfo(renderer, &info)) {
    die("SDL_GetRendererInfo(): %s", SDL_GetError());
  }

  // log renderer info
  SDL_Log(
    "renderer:\n"
    "  name = \"%s\"\n"
    "  flags = %u%s%s%s%s\n"
    "  num_texture_formats = %u\n"
    "  max_texture_width = %d\n"
    "  max_texture_height = %d",
    info.name,
    info.flags,
    info.flags & SDL_RENDERER_SOFTWARE ? ", software" : "",
    info.flags & SDL_RENDERER_ACCELERATED ? ", accelerated" : "",
    info.flags & SDL_RENDERER_PRESENTVSYNC ? ", presentvsync" : "",
    info.flags & SDL_RENDERER_TARGETTEXTURE ? ", targettexture" : "",
    info.num_texture_formats,
    info.max_texture_width,
    info.max_texture_height
  );
}

static void
log_texture_info(
  SDL_Texture * const tex
) {
  Uint32 format;
  int access, w, h;

  // query texture
  if (SDL_QueryTexture(tex, &format, &access, &w, &h)) {
    die("SDL_QueryTexture(): %s", SDL_GetError());
  }

  // log information
  SDL_Log(
    "texture:\n"
    "  format = %u\n"
    "  access = %d\n"
    "  width = %d\n"
    "  height = %d",
    format, access, w, h
  );
}

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

int main(int argc, char *argv[]) {
  size_t level_num = (argc > 1) ? atoi(argv[1]) : 0,
         zoom = 0;
  const level_t *level = levels_get_level(level_num);
  const char *sprites_png_path = "../assets/sprites.png";

  // 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);

  if (!sok_ctx_set_level(&ctx, level->data)) {
    die("Couldn't load level %zu", level_num);
  }

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

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

  // create window and renderer
  SDL_Window *win;
  SDL_Renderer *renderer;
  if (SDL_CreateWindowAndRenderer(800, 600, SDL_WINDOW_RESIZABLE, &win, &renderer)) {
    die("SDL_CreateWindowAndRenderer(): %s", SDL_GetError());
  }

  log_renderer_info(renderer);

  // init draw context
  draw_ctx_t draw_ctx = {
    .level_num  = &level_num,
    .level      = level,
    .ctx        = &ctx,
    .renderer   = renderer,
    .zoom       = &zoom,
  };

  sprites_init(renderer, sprites_png_path, draw_ctx.sprites);

  log_texture_info(draw_ctx.sprites[0]);

  SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);

  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++;
          level = levels_get_level(level_num);
          draw_ctx.level = level;

          // load next level
          if (!sok_ctx_set_level(&ctx, level->data)) {
            die("Couldn't load level %zu", level_num);
          }
        } else {
          warn("cannot advance to next level");
        }

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

        break;
      case ACTION_WARP:
        if (warp_buf_get(&warp_buf, &level_num)) {
          level = levels_get_level(level_num);
          draw_ctx.level = level;

          // load level
          if (!sok_ctx_set_level(&ctx, level->data)) {
            die("Couldn't load level %zu", 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
            draw_moves(&ctx, old_num_moves);
          } else {
            warn("Couldn't solve level");
          }
        }

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

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

        break;
      default:
        // ignore
        break;
      }
    }

    // draw
    draw(&draw_ctx);
  }

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

  // return success
  return EXIT_SUCCESS;
}