main.c

/*
 * this is free and unencumbered software released into the
 * public domain.
 *
 * refer to the attached UNLICENSE or http://unlicense.org/
 * ----------------------------------------------------------------
 * command line interface for oppai
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#undef OPPAI_EXPORT
#undef OPPAI_IMPLEMENTATION
#include "oppai.c"

char* me = "oppai";

#define al_round(x) (float)floor((x) + 0.5f)
#define al_min(a, b) ((a) < (b) ? (a) : (b))
#define al_max(a, b) ((a) > (b) ? (a) : (b))
#define twodec(x) (al_round((x) * 100.0f) / 100.0f)
#define array_len(x) (sizeof(x) / sizeof((x)[0]))

static
float get_inf() {
  static unsigned raw = 0x7F800000;
  float* p = (float*)&raw;
  return *p;
}

static
int is_nan(float b) {
  int* p = (int*)&b;
  return (
    (*p > 0x7F800000 && *p < 0x80000000) ||
    (*p > 0x7FBFFFFF && *p <= 0xFFFFFFFF)
  );
}

static
int info(char* fmt, ...) {
  int res;
  va_list va;
  va_start(va, fmt);
  res = vfprintf(stderr, fmt, va);
  va_end(va);
  return res;
}

void usage() {
  /* logo by flesnuk https://github.com/Francesco149/oppai-ng/issues/10 */

  info(
    "     /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb"
    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ /\xe2\x8e\xbb\xe2"
    "\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb"
    "\xe2\x8e\xbb/ /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2"
    "\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ /\xe2\x8e"
    "\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2"
    "\x8e\xbb\xe2\x8e\xbb/ /\xe2\x8e\xbb/      /\xe2\x8e\xbb"
    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\\    /\xe2\x8e\xbb"
    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e"
    "\xbb\xe2\x8e\xbb/\n    / /\xe2\x8e\xbb\xe2\x8e\xbb\xe2"
    "\x8e\xbb/ / / /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ / "
  );

  info(
    "/ /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ /  \xe2\x8e\xbb"
    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ / / / "
    "___  / /\xe2\x8e\xbb\xe2\x8e\xbb\\ \\  / /\xe2\x8e\xbb"
    "\xe2\x8e\xbb\xe2\x8e\xbb/ /\n   / /   / / / /   / / / /"
    "   / / /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb"
    "\xe2\x8e\xbb/ / / / /__/ / /   / / / /   / /\n  / /___/ "
    "/ / /___/ / / /___/ / / /___/ / / /      / /   / / / /__"
    "_/ /\n /_______/ / ______/ / ______/ /_______/ /_/      "
    "/_/   /_/ /_____  /\n          / /       / /            "
    "                              / / \n         / /       /"
    " /                                    /\xe2\x8e\xbb/___/"
    " / \n        /_/       /_/                              "
    "      /_______/"
  );

  info("\n\n");
  info("usage: %s /path/to/file.osu parameters\n\n", me);

  info(
    "set filename to '-' to read from standard input\n"
    "all parameters are case insensitive\n"
    "\n"
    "-o[output_module]\n"
    "  output module. pass ? to list modules (oppai - -o?)\n"
    "  default: text\n"
    "  example: -ojson\n"
    "\n"
    "[accuracy]%%\n"
    "  accuracy percentage\n"
    "  default: 100%%\n"
    "  example: 95%%\n"
    "\n"
    "[n]x100\n"
    "  amount of 100s\n"
    "  default: 0\n"
    "  example: 2x100\n"
    "\n"
  );

  info(
    "[n]x50\n"
    "  amount of 50s\n"
    "  default: 0\n"
    "  example: 2x50\n"
    "\n"
    "[n]xm\n"
    "[n]xmiss\n"
    "[n]m\n"
    "  amount of misses\n"
    "  default: 0\n"
    "  example: 1m\n"
    "\n"
    "[combo]x\n"
    "  highest combo achieved\n"
    "  default: full combo (calculated from map data)\n"
    "  example: 500x\n"
    "\n"
    "scorev[n]\n"
    "  scoring system\n"
    "  default: 1\n"
    "  example: scorev2\n"
    "\n"
    "-relax\n"
    "  calculate relax pp\n"
    "\n"
    "-autopilot\n"
    "  calculate autopilot pp\n"
    "\n"
    "-rv0\n"
    "  use relax pp v0\n"
    "\n"
    "-rv1\n"
    "  use relax pp v1 (default)\n"
    "\n"
  );

  info(
    "ar[n]\n"
    "  base approach rate override\n"
    "  default: map's base approach rate\n"
    "  example: AR5\n"
    "\n"
    "od[n]\n"
    "  base overall difficulty override\n"
    "  default: map's base overall difficulty\n"
    "  example: OD10\n"
    "\n"
    "cs[n]\n"
    "  base circle size override\n"
    "  default: map's base circle size\n"
    "  example: CS6.5\n"
    "\n"
  );

  info(
    "-m[n]\n"
    "  gamemode id override for converted maps\n"
    "  default: uses the map's gamemode\n"
    "  example: -m1\n"
    "\n"
    "-taiko\n"
    "  forces gamemode to taiko for converted maps\n"
    "  default: disabled\n"
    "\n"
    "-touch\n"
    "  calculates pp for touchscreen / touch devices. can \n"
    "  also be specified as mod TD\n"
    "\n"
    "[n]speed\n"
    "  override speed stars. "
    "useful for maps with incorrect star rating\n"
    "  default: uses computed speed stars\n"
    "  example: 3.5speed\n"
    "\n"
  );

  info(
    "[n]aim\n"
    "  override aim stars. "
    "useful for maps with incorrect star rating\n"
    "  default: uses computed aim stars\n"
    "  example: 2.4aim\n"
    "\n"
    "-end[n]\n"
    "  cuts map to a certain number of objects\n"
  );
}

#define output_sig(name) void name(int result, ezpp_t ez, char* mods_str)

typedef output_sig(fnoutput);

/* null output --------------------------------------------------------- */

/* stdout must be left alone, outputting to stderr is fine tho */
output_sig(output_null) { (void)result; (void)ez; (void)mods_str; }

/* text output --------------------------------------------------------- */

#define ASCIIPLT_W 51

void asciiplt(float (* getvalue)(void* data, int i), int n, void* data) {
  static char* charset[] = {
#ifdef OPPAI_UTF8GRAPH
    "\xe2\x96\x81",
    "\xe2\x96\x82",
    "\xe2\x96\x83",
    "\xe2\x96\x84",
    "\xe2\x96\x85",
    "\xe2\x96\x86",
    "\xe2\x96\x87",
    "\xe2\x96\x88"
#else
    " ", "_", ".", "-", "^"
#endif
  };

  static int charsetsize = array_len(charset);

  float values[ASCIIPLT_W];
  float minval = (float)get_inf();
  float maxval = (float)-get_inf();
  float range;
  int i;
  int chunksize;
  int w = al_min(ASCIIPLT_W, n);

  memset(values, 0, sizeof(values));
  chunksize = (int)ceil((float)n / w);

  for (i = 0; i < n; ++i) {
    int chunki = i / chunksize;
    values[chunki] = al_max(values[chunki], getvalue(data, i));
  }

  for (i = 0; i < n; ++i) {
    int chunki = i / chunksize;
    maxval = al_max(maxval, values[chunki]);
    minval = al_min(minval, values[chunki]);
  }

  range = al_max(0.00001f, maxval - minval);

  for (i = 0; i < w; ++i) {
    int chari = (int)(((values[i] - minval) / range) * charsetsize);
    chari = al_max(0, al_min(chari, charsetsize - 1));
    printf("%s", charset[chari]);
  }

  puts("");
}

float getaim(void* data, int i) {
  ezpp_t ez = data;
  return ezpp_strain_at(ez, i, DIFF_AIM);
}

float getspeed(void* data, int i) {
  ezpp_t ez = data;
  return ezpp_strain_at(ez, i, DIFF_SPEED);
}

output_sig(output_text) {
  float ar, od, cs, hp, stars, aim_stars, speed_stars, accuracy_percent;
  float pp, aim_pp, speed_pp, acc_pp;

  if (result < 0) {
    puts(errstr(result));
    return;
  }

  printf("%s - %s ", ezpp_artist(ez), ezpp_title(ez));

  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez)) ||
    strcmp(ezpp_title(ez), ezpp_title_unicode(ez)))
  {
    printf("(%s - %s) ", ezpp_artist_unicode(ez), ezpp_title_unicode(ez));
  }

  printf("[%s] mapped by %s ", ezpp_version(ez), ezpp_creator(ez));
  puts("\n");

  ar = twodec(ezpp_ar(ez));
  od = twodec(ezpp_od(ez));
  cs = twodec(ezpp_cs(ez));
  hp = twodec(ezpp_hp(ez));
  stars = twodec(ezpp_stars(ez));
  aim_stars = twodec(ezpp_aim_stars(ez));
  speed_stars = twodec(ezpp_speed_stars(ez));
  accuracy_percent = twodec(ezpp_accuracy_percent(ez));
  pp = twodec(ezpp_pp(ez));
  aim_pp = twodec(ezpp_aim_pp(ez));
  speed_pp = twodec(ezpp_speed_pp(ez));
  acc_pp = twodec(ezpp_acc_pp(ez));

  printf("AR%g OD%g ", ar, od);

  if (ezpp_mode(ez) == MODE_STD) {
    printf("CS%g ", cs);
  }

  printf("HP%g\n", hp);
  printf("300 hitwindow: %g ms\n", ezpp_odms(ez));

  printf("%d circles, %d sliders, %d spinners\n",
    ezpp_ncircles(ez), ezpp_nsliders(ez), ezpp_nspinners(ez));

  if (ezpp_mode(ez) == MODE_STD) {
    printf("%g stars (%g aim, %g speed)\n", stars, aim_stars, speed_stars);
    printf("\nspeed strain: ");
    asciiplt(getspeed, ezpp_nobjects(ez), ez);
    printf("  aim strain: ");
    asciiplt(getaim, ezpp_nobjects(ez), ez);
  } else {
    printf("%g stars\n", ezpp_stars(ez));
  }

  printf("\n");

  if (mods_str) {
    printf("+%s ", mods_str);
  }

  printf("%d/%dx ", ezpp_combo(ez), ezpp_max_combo(ez));
  printf("%g%%\n", accuracy_percent);
  printf("%g pp (", pp);

  if (ezpp_mode(ez) == MODE_STD) {
    printf("%g aim, ", aim_pp);
  }

  printf("%g speed, ", speed_pp);
  printf("%g acc)\n\n", acc_pp);
}

/* json output --------------------------------------------------------- */

void print_escaped_json_string_ex(char* str, int quotes) {
  char* chars_to_escape = "\\\"";
  char* p;
  if (quotes) {
    putchar('"');
  }
  for (; *str; ++str) {
    /* escape all characters in chars_to_escape */
    for (p = chars_to_escape; *p; ++p) {
      if (*p == *str) {
        putchar('\\');
      }
    }
    putchar(*str);
  }
  if (quotes) {
    putchar('"');
  }
}

#define print_escaped_json_string(x) \
  print_escaped_json_string_ex(x, 1)

/* https://www.doc.ic.ac.uk/%7Eeedwards/compsys/float/nan.html */

static int is_inf(float b) {
  int* p = (int*)&b;
  return *p == 0x7F800000 || *p == 0xFF800000;
}

/*
 * json is mentally challenged and can't handle inf and nan so
 * we're gonna be mathematically incorrect
 */
void fix_json_flt(float* v) {
  if (is_inf(*v)) {
    *v = -1;
  } else if (is_nan(*v)) {
    *v = 0;
  }
}

output_sig(output_json) {
  float pp, aim_pp, speed_pp, acc_pp, stars, aim_stars, speed_stars;
  printf("{\"oppai_version\":\"%s\",", oppai_version_str());

  if (result < 0) {
    printf("\"code\":%d,", result);
    printf("\"errstr\":");
    print_escaped_json_string(errstr(result));
    printf("}");
    return;
  }

  pp = ezpp_pp(ez);
  aim_pp = ezpp_aim_pp(ez);
  speed_pp = ezpp_speed_pp(ez);
  acc_pp = ezpp_acc_pp(ez);
  stars = ezpp_stars(ez);
  aim_stars = ezpp_aim_stars(ez);
  speed_stars = ezpp_speed_stars(ez);
  fix_json_flt(&pp);
  fix_json_flt(&aim_pp);
  fix_json_flt(&speed_pp);
  fix_json_flt(&acc_pp);
  fix_json_flt(&stars);
  fix_json_flt(&aim_stars);
  fix_json_flt(&speed_stars);

  printf("\"code\":200,\"errstr\":\"no error\",");

  printf("\"artist\":");
  print_escaped_json_string(ezpp_artist(ez));

  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez))) {
    printf(",\"artist_unicode\":");
    print_escaped_json_string(ezpp_artist_unicode(ez));
  }

  printf(",\"title\":");
  print_escaped_json_string(ezpp_title(ez));

  if (strcmp(ezpp_title(ez), ezpp_title_unicode(ez))) {
    printf(",\"title_unicode\":");
    print_escaped_json_string(ezpp_title_unicode(ez));
  }

  printf(",\"creator\":");
  print_escaped_json_string(ezpp_creator(ez));

  printf(",\"version\":");
  print_escaped_json_string(ezpp_version(ez));

  printf(",");

  if (!mods_str) {
    mods_str = "";
  }

  printf(
    "\"mods_str\":\"%s\",\"mods\":%d,"
    "\"od\":%g,\"ar\":%g,\"cs\":%g,\"hp\":%g,"
    "\"combo\":%d,\"max_combo\":%d,"
    "\"num_circles\":%d,\"num_sliders\":%d,"
    "\"num_spinners\":%d,\"misses\":%d,"
    "\"score_version\":%d,\"stars\":%.17g,"
    "\"speed_stars\":%.17g,\"aim_stars\":%.17g,"
    "\"aim_pp\":%.17g,\"speed_pp\":%.17g,\"acc_pp\":%.17g,"
    "\"pp\":%.17g}",
    mods_str, ezpp_mods(ez), ezpp_od(ez), ezpp_ar(ez),
    ezpp_cs(ez), ezpp_hp(ez), ezpp_combo(ez),
    ezpp_max_combo(ez), ezpp_ncircles(ez), ezpp_nsliders(ez),
    ezpp_nspinners(ez), ezpp_nmiss(ez), ezpp_score_version(ez),
    ezpp_stars(ez), ezpp_speed_stars(ez), ezpp_aim_stars(ez),
    ezpp_aim_pp(ez), ezpp_speed_pp(ez), ezpp_acc_pp(ez), ezpp_pp(ez)
  );
}

/* csv output ---------------------------------------------------------- */

void print_escaped_csv_string(char* str) {
  char* chars_to_escape = "\\;";
  char* p;
  for (; *str; ++str) {
    /* escape all characters in chars_to_escape */
    for (p = chars_to_escape; *p; ++p) {
      if (*p == *str) {
        putchar('\\');
      }
    }
    putchar(*str);
  }
}

output_sig(output_csv) {
  printf("oppai_version;%s\n", oppai_version_str());

  if (result < 0) {
    printf("code;%d\nerrstr;", result);
    print_escaped_csv_string(errstr(result));
    return;
  }

  printf("code;200\nerrstr;no error\n");

  printf("artist;");
  print_escaped_csv_string(ezpp_artist(ez));
  puts("");

  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez))) {
    printf("artist_unicode;");
    print_escaped_csv_string(ezpp_artist_unicode(ez));
    puts("");
  }

  printf("title;");
  print_escaped_csv_string(ezpp_title(ez));
  puts("");

  if (strcmp(ezpp_title(ez), ezpp_title_unicode(ez))) {
    printf("title_unicode;");
    print_escaped_csv_string(ezpp_title_unicode(ez));
    puts("");
  }

  printf("version;");
  print_escaped_csv_string(ezpp_version(ez));
  puts("");

  printf("creator;");
  print_escaped_csv_string(ezpp_creator(ez));
  puts("");

  if (!mods_str) {
    mods_str = "";
  }

  printf(
    "mods_str;%s\nmods;%d\nod;%g\nar;%g\ncs;%g\nhp;%g\n"
    "combo;%d\nmax_combo;%d\nnum_circles;%d\n"
    "num_sliders;%d\nnum_spinners;%d\nmisses;%d\n"
    "score_version;%d\nstars;%.17g\nspeed_stars;%.17g\n"
    "aim_stars;%.17g\naim_pp;%.17g\nspeed_pp;%.17g\nacc_pp;%.17g\npp;%.17g",
    mods_str, ezpp_mods(ez), ezpp_od(ez), ezpp_ar(ez),
    ezpp_cs(ez), ezpp_hp(ez), ezpp_combo(ez),
    ezpp_max_combo(ez), ezpp_ncircles(ez), ezpp_nsliders(ez),
    ezpp_nspinners(ez), ezpp_nmiss(ez), ezpp_score_version(ez),
    ezpp_stars(ez), ezpp_speed_stars(ez), ezpp_aim_stars(ez),
    ezpp_aim_pp(ez), ezpp_speed_pp(ez), ezpp_acc_pp(ez), ezpp_pp(ez)
  );
}

/* binary output ------------------------------------------------------- */

void write1(int v) {
  char buf = (char)(v & 0xFF);
  fwrite(&buf, 1, 1, stdout);
}

void write2(int v) {
  char buf[2];
  buf[0] = (char)(v & 0xFF);
  buf[1] = (char)(v >> 8);
  fwrite(buf, 1, 2, stdout);
}

void write4(int v) {
  char buf[4];
  buf[0] = (char)(v & 0xFF);
  buf[1] = (char)((v >> 8) & 0xFF);
  buf[2] = (char)((v >> 16) & 0xFF);
  buf[3] = (char)((v >> 24) & 0xFF);
  fwrite(buf, 1, 4, stdout);
}

void write_flt(float f) {
  int* p = (int*)&f;
  write4(*p);
}

void write_str(char* str) {
  int len = al_min(0xFFFF, (int)strlen(str));
  write2(len);
  printf("%s", str);
  write1(0);
}

output_sig(output_binary) {
  int major, minor, patch;
  (void)mods_str;

  if (!freopen(0, "wb", stdout)) {
    perror("freopen");
    exit(1);
  }

  printf("binoppai");
  oppai_version(&major, &minor, &patch);
  write1(major);
  write1(minor);
  write1(patch);
  write4(result);

  if (result < 0) {
    return;
  }

  /* TODO: use varargs to group calls of the same func */
  write_str(ezpp_artist(ez));
  write_str(ezpp_artist_unicode(ez));
  write_str(ezpp_title(ez));
  write_str(ezpp_title_unicode(ez));
  write_str(ezpp_version(ez));
  write_str(ezpp_creator(ez));
  write4(ezpp_mods(ez));
  write_flt(ezpp_od(ez));
  write_flt(ezpp_ar(ez));
  write_flt(ezpp_cs(ez));
  write_flt(ezpp_hp(ez));
  write4(ezpp_combo(ez));
  write4(ezpp_max_combo(ez));
  write2(ezpp_ncircles(ez));
  write2(ezpp_nsliders(ez));
  write2(ezpp_nspinners(ez));
  write4(ezpp_score_version(ez));
  write_flt(ezpp_stars(ez));
  write_flt(ezpp_speed_stars(ez));
  write_flt(ezpp_aim_stars(ez));
  write2(0); /* legacy (nsingles) */
  write2(0); /* legacy (nsigles_threshold) */
  write_flt(ezpp_aim_pp(ez));
  write_flt(ezpp_speed_pp(ez));
  write_flt(ezpp_acc_pp(ez));
  write_flt(ezpp_pp(ez));
}

/* gnuplot output ------------------------------------------------------ */

#define gnuplot_string(x) print_escaped_json_string_ex(x, 0)

void gnuplot_strains(ezpp_t ez, int type) {
  int i;
  for (i = 0; i < ezpp_nobjects(ez); ++i) {
    printf("%.17g %.17g\n", ezpp_time_at(ez, i),
      ezpp_strain_at(ez, i, type));
  }
}

output_sig(output_gnuplot) {
  if (result < 0 || ezpp_mode(ez) != MODE_STD) {
    return;
  }

  puts("set encoding utf8;");

  printf("set title \"");
  gnuplot_string(ezpp_artist(ez));
  printf(" - ");
  gnuplot_string(ezpp_title(ez));

  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez)) ||
    strcmp(ezpp_title(ez), ezpp_title_unicode(ez)))
  {
    printf("(");
    gnuplot_string(ezpp_artist_unicode(ez));
    printf(" - ");
    gnuplot_string(ezpp_title_unicode(ez));
    printf(")");
  }

  printf(" [");
  gnuplot_string(ezpp_version(ez));
  printf("] mapped by ");
  gnuplot_string(ezpp_creator(ez));
  if (mods_str) printf(" +%s", mods_str);
  puts("\";");

  puts(
    "set xlabel 'time (ms)';"
    "set ylabel 'strain';"
    "set multiplot layout 2,1 rowsfirst;"
    "plot '-' with lines lc 1 title 'speed'"
  );
  gnuplot_strains(ez, DIFF_SPEED);
  puts("e");
  puts("unset title;");
  puts("plot '-' with lines lc 2 title 'aim'");
  gnuplot_strains(ez, DIFF_AIM);
}

/* ------------------------------------------------------------- */

#define CODE_DESC "the code and errstr fields " \
  "should be checked for errors. a negative value for code " \
  "indicates an error"

typedef struct output_module {
  char* name;
  fnoutput* func;
  char* description[4];
  /* null terminated array of strings because of c90 literal limits */
} output_module_t;

output_module_t modules[] = {
  { "null", output_null, { "no output", 0 } },
  { "text", output_text, { "plain text", 0 } },
  {
    "json", output_json,
    { "a single utf-8 json object.\n" CODE_DESC, 0 }
  },
  {
    "csv", output_csv,
    { "fieldname;value\n"
    "one value per line. ';' characters in strings will be " 
    "escaped to \"\\;\". utf-8.\n" CODE_DESC, 0 }
  },
  {
    "binary",
    output_binary,
    { "binary stream of values, encoded in little endian.\n"
    "negative code values indicate an error, which matches "
    "the error codes defined in oppai.c\n"
    "for an example on how to read this in C, check out "
    "examples/binary.c in oppai-ng's source\n"
    "\n"
    "floats and floats are represented using whatever "
    "convention the host machine and compiler use. unless you "
    "are on a really exotic machine it shouldn't matter\n"
    "\n"
    "strings (str) are encoded as a 2-byte integer indicating "
    "the length in bytes, followed by the string bytes and ",
    "a null (zero) terminating byte\n"
    "\n"
    "binoppai (8-byte magic), "
    "int8 oppai_ver_major, int8 oppai_ver_minor, "
    "int8 oppai_ver_patch, int error_code, "
    "str artist, str artist_utf8, str title, str title_utf8, "
    "str version, str creator, "
    "int mods_bitmask, float od, float ar, float cs, "
    "float hp, int combo, int max_combo, "
    "int16 ncircles, int16 nsliders, int16 nspinner, "
    "int score_version, float total_stars, ",
    "float speed_stars, float aim_stars, int16 nsingles, "
    "int16 nsingles_threshold, float aim_pp, "
    "float speed_pp, float acc_pp, float pp",
    0 }
  },
  { "gnuplot", output_gnuplot, { "gnuplot .gp script", 0 } },
};

output_module_t* output_by_name(char* name) {
  int i;
  for (i = 0; i < array_len(modules); ++i) {
    if (!strcmp(modules[i].name, name)) {
      return &modules[i];
    }
  }
  return 0;
}

int cmpsuffix(char* str, char* suffix) {
  int sufflen = (int)al_min(strlen(str), strlen(suffix));
  return strcmp(str + strlen(str) - sufflen, suffix);
}

char lowercase(char c) {
  if (c >= 'A' && c <= 'Z') {
    return c + ('a' - 'A');
  }
  return c;
}

char uppercase(char c) {
  if (c >= 'a' && c <= 'z') {
    return c - ('a' - 'A');
  }
  return c;
}

int strcmp_nc(char* a, char* b) {
  for (;; ++a, ++b) {
    char la = lowercase(*a);
    char lb = lowercase(*b);
    if (la > lb) {
      return 1;
    }
    else if (la < lb) {
      return -1;
    }
    if (!*a || *b) {
      break;
    }
  }
  return 0;
}

/* TODO: split main into smaller funcs for readability? */
int main(int argc, char* argv[]) {
  int i;
  int result;
  ezpp_t ez = ezpp_new();
  output_module_t* m;
  char* output_name = "text";
  char* mods_str = 0;
  int mods = MODS_NOMOD;
  float tmpf, speed_stars = 0, aim_stars = 0, accuracy_percent = 0;
  int tmpi, n100 = 0, n50 = 0;
  int relax_version = 1;

  /* parse arguments ------------------------------------------------- */
  me = argv[0];

  if (argc < 2) {
    usage();
    return 1;
  }

  if (*argv[1] == '-' && strlen(argv[1]) > 1) {
    char* a = argv[1] + 1;
    if (!strcmp_nc(a, "version") || !strcmp_nc(a, "v")) {
      puts(oppai_version_str());
      return 0;
    }
  }

  for (i = 2; i < argc; ++i) {
    char* a = argv[i];
    char* p;
    int iswhite = 1;

    for (p = a; *p; ++p) {
      if (!isspace(*p)) {
        iswhite = 0;
        break;
      }
    }

    if (iswhite) {
      continue;
    }

    for (p = a; *p; ++p) {
      *p = lowercase(*p);
    }

    if (*a == '-' && a[1] == 'o') {
      output_name = a + 2;

      if (!strcmp(output_name, "?")) {
        int j;
        int nmodules = sizeof(modules) / sizeof(modules[0]);
        for (j = 0; j < nmodules; ++j) {
          char** d = modules[j].description;
          puts(modules[j].name);
          for (; *d; ++d) {
            printf("%s", *d);
          }
          puts("\n-");
        }
        return 0;
      }

      continue;
    }

    if (!cmpsuffix(a, "%") && sscanf(a, "%f", &accuracy_percent) == 1) {
      continue;
    }

    if (!cmpsuffix(a, "x100") && sscanf(a, "%d", &n100) == 1) {
      continue;
    }

    if (!cmpsuffix(a, "x50") && sscanf(a, "%d", &n50) == 1) {
      continue;
    }

    if (!cmpsuffix(a, "speed") && sscanf(a, "%f", &speed_stars) == 1) {
      continue;
    }

    if (!cmpsuffix(a, "aim") && sscanf(a, "%f", &aim_stars) == 1) {
      continue;
    }

    if (!cmpsuffix(a, "xm") || !cmpsuffix(a, "xmiss") ||
      !cmpsuffix(a, "m"))
    {
      if (sscanf(a, "%d", &tmpi) == 1) {
        ezpp_set_nmiss(ez, tmpi);
        continue;
      }
    }

    if (!cmpsuffix(a, "x") && sscanf(a, "%d", &tmpi) == 1) {
      ezpp_set_combo(ez, tmpi);
      continue;
    }

    if (sscanf(a, "scorev%d", &tmpi)) {
      ezpp_set_score_version(ez, tmpi);
      continue;
    }

    if (sscanf(a, "ar%f", &tmpf)) {
      ezpp_set_base_ar(ez, tmpf);
      continue;
    }

    if (sscanf(a, "od%f", &tmpf)) {
      ezpp_set_base_od(ez, tmpf);
      continue;
    }

    if (sscanf(a, "cs%f", &tmpf)) {
      ezpp_set_base_cs(ez, tmpf);
      continue;
    }

    if (sscanf(a, "-m%d", &tmpi) == 1) {
      ezpp_set_mode_override(ez, tmpi);
      continue;
    }

    if (sscanf(a, "-end%d", &tmpi) == 1) {
      ezpp_set_end(ez, tmpi);
      continue;
    }

    if (!strcmp(a, "-taiko")) {
      ezpp_set_mode_override(ez, MODE_TAIKO);
      continue;
    }

    if(!strcmp(a, "-rv0")) {
      relax_version = 0;
      continue;
    }

    if(!strcmp(a, "-rv1")) {
      relax_version = 1;
      continue;
    }

    if(!strcmp(a, "-relax")) {
      ezpp_set_relax(ez, 1);
      continue;
    }

    if(!strcmp(a, "-autopilot")) {
      ezpp_set_autopilot(ez, 1);
      continue;
    }

    if (!strcmp(a, "-touch")) {
      mods |= MODS_TOUCH_DEVICE;
      continue;
    }

    /* this should be last because it uppercase's the string */
    if (*a == '+') {
      mods_str = a + 1;
      for (p = mods_str; *p; ++p) {
        *p = uppercase(*p);
      }

      #define m(mod) \
        if (!strncmp(p, #mod, strlen(#mod))) { \
          mods |= MODS_##mod; \
          p += strlen(#mod); \
          continue; \
        }

      for (p = mods_str; *p;) {
        m(NF) m(EZ) m(TD) m(HD) m(HR) m(SD) m(DT) m(RX) m(HT) m(NC) m(FL)
        m(AT) m(SO) m(AP) m(PF) m(NOMOD)
        ++p;
      }

      #undef m
      continue;
    }

    info(">%s\n", a);
    result = ERR_SYNTAX;
    goto output;
  }

  if (accuracy_percent) {
    ezpp_set_accuracy_percent(ez, accuracy_percent);
  } else {
    ezpp_set_accuracy(ez, n100, n50);
  }
  ezpp_set_mods(ez, mods);
  ezpp_set_speed_stars(ez, speed_stars);
  ezpp_set_aim_stars(ez, aim_stars);
  ezpp_set_relax_version(ez, relax_version);
  result = ezpp(ez, argv[1]);

output:
  m = output_by_name(output_name);
  if (!m) {
    info("output module '%s' does not exist. check 'oppai - -o?'\n",
      output_name);
    return 1;
  }

  m->func(result, ez, mods_str);
  ezpp_free(ez); /* just so valgrind stops crying */
  return result < 0;
}