#include "hitomezashi_cli.h"
#include "SDL.h"
#include "getopt/xgetopt.h"
#include "hitomezashi.h"
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
  if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Failed to initialise SDL: %s",
                    SDL_GetError());
    return Hitomezashi_Cli_Exit_Code_Err_Sdl_Init;
  }

  char *out_file_path;
  int x_pattern_len;
  int y_pattern_len;
  char *x_pattern;
  char *y_pattern;
  int gap;
  int thickness;
  hitomezashi_cli_handle_args(&out_file_path, &x_pattern_len, &y_pattern_len,
                              &x_pattern, &y_pattern, &gap, &thickness, argc,
                              argv);

  struct Hitomezashi_State state;
  if (hitomezashi_state_init(&state, x_pattern_len, y_pattern_len, x_pattern,
                             y_pattern, gap, thickness) != 0) {
    return Hitomezashi_Cli_Exit_Code_Err_State_Init;
  }

  hitomezashi_draw(&state);

  if (SDL_SaveBMP(state.surface, out_file_path) != 0) {
    SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Failed to save image");
    return Hitomezashi_Cli_Exit_Code_Err_Save_Image;
  }

  SDL_FreeSurface(state.surface);
  free(state.x_pattern);
  free(state.y_pattern);

  SDL_Quit();
}

// Attempts to prints help. Exits 0 on success, 2 on failure.
void hitomezashi_cli_help(void) {
  if (puts("hitomezashi_cli - generate hitomezashi patterns\n"
           "Options:\n"
           "-o - specify the output image (BMP) path\n"
           "-x - specify the x pattern as a string of zeroes and ones (eg. "
           "0101)\n"
           "-y - specify the y pattern, as with -x\n"
           "-g - specify the gap between lines as an integer\n"
           "-t - specify the line thickness as an integer\n"
           "-h - print this help and exit") < 0) {
    exit(Hitomezashi_Cli_Exit_Code_Err_Print_Help);
  }
  exit(Hitomezashi_Cli_Exit_Code_Success);
}

char *hitomezashi_cli_ascii_binary_str_to_ints(char *ascii_str, size_t n) {
  char *res = malloc(n);
  for (int i = 0; i < n; ++i) {
    switch (ascii_str[i]) {
    case '0':;
      res[i] = 0;
      break;
    case '1':;
      res[i] = 1;
      break;
    default:;
      free(res);
      printf("%d\n", ascii_str[i]);
      return NULL;
    }
  }
  return res;
}

// Parses arguments with xgetopt, ensures they are valid, initialises various
// variables based on them. Prints and exits if it encounters an error.
void hitomezashi_cli_handle_args(char **out_file_path, int *x_pattern_len,
                                 int *y_pattern_len, char **x_pattern,
                                 char **y_pattern, int *gap, int *thickness,
                                 int argc, char **argv) {
  bool out_file_path_specified = false;
  bool x_pattern_specified = false;
  bool y_pattern_specified = false;
  bool gap_specified = false;
  bool thickness_specified = false;

  struct xgetopt xgetopt_state = XGETOPT_INIT;
  int option;
  while ((option = xgetopt(&xgetopt_state, argc, argv, "o:x:y:g:t:h") != -1)) {
    switch (xgetopt_state.optopt) {
    case 'o':;
      *out_file_path = xgetopt_state.optarg;
      out_file_path_specified = true;
      break;
    case 'x':;
      size_t x_pattern_len_l = strlen(xgetopt_state.optarg);
      if (x_pattern_len_l >= INT_MAX) {
        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
                        "X pattern length must be shorter than %d", INT_MAX);
        exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
      }
      *x_pattern_len = x_pattern_len_l;
      *x_pattern = hitomezashi_cli_ascii_binary_str_to_ints(
          xgetopt_state.optarg, *x_pattern_len);
      if (!*x_pattern) {
        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Invalid x pattern; see -h");
        exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
      }
      x_pattern_specified = true;
      break;
    case 'y':;
      size_t y_pattern_len_l = strlen(xgetopt_state.optarg);
      if (y_pattern_len_l >= INT_MAX) {
        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
                        "Y pattern length must be shorter than %d", INT_MAX);
        exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
      }
      *y_pattern_len = y_pattern_len_l;
      *y_pattern = hitomezashi_cli_ascii_binary_str_to_ints(
          xgetopt_state.optarg, *y_pattern_len);
      if (!*y_pattern) {
        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Invalid y pattern; see -h");
        exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
      }
      y_pattern_specified = true;
      break;
    case 'g':;
      long gap_l = strtol(xgetopt_state.optarg, NULL, 0);
      if (gap_l >= INT_MAX) {
        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
                        "Value for gap must be less than %d", INT_MAX);
        exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
      }
      *gap = gap_l;
      gap_specified = true;
      break;
    case 't':;
      long thickness_l = strtol(xgetopt_state.optarg, NULL, 0);
      if (thickness_l >= INT_MAX) {
        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
                        "Value for line thickness must be less than %d",
                        INT_MAX);
        exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
      }
      *thickness = thickness_l;
      thickness_specified = true;
      break;
    case 'h':;
      hitomezashi_cli_help();
      break;
    default:;
      SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
                      "Invalid argument: run with -h for help");
      exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
    }
  }
  if (!(out_file_path_specified && x_pattern_specified && y_pattern_specified &&
        gap_specified && thickness_specified)) {
    SDL_LogCritical(
        SDL_LOG_CATEGORY_ERROR,
        "-o, -x, -y, -g, -t *must* be specified; run with -h for help");
    exit(Hitomezashi_Cli_Exit_Code_Err_Handle_Args);
  }
}