#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <check.h>

#include "string-util.h"
#include "esp32-uart-cmdr.h"

START_TEST(leading)
{
  char str[] = " I had a leading space";
  trim_leading(str);

  ck_assert_str_eq(str, "I had a leading space");
}
END_TEST

START_TEST(multi)
{
  char str[] = " I had a   leading     space  ";
  trim_multi(str);

  ck_assert_str_eq(str, " I had a leading space ");
}
END_TEST

uint8_t cb_count = 0;
static int8_t count = 0;
void inc(void *p) {
  ++count;
  ++cb_count;
}

void set(void *p) {
  count = (int8_t)p;
}

void down(void *p) {
  --count;
  ++cb_count;
}

START_TEST(install) {
  uint8_t cnt = ucmdr_install("inc", inc);

  ck_assert_uint_eq(cnt, 1);

  cnt = ucmdr_install("down", down);

  ck_assert_uint_eq(cnt, 2);
}
END_TEST

START_TEST(match) {
  struct Cmd *handler;
  
  bool matched = ucmdr_match("inc", &handler);
  ck_assert_uint_eq(matched, 1);

  printf("caling callback\n");
  handler->callback((void*)1);

  return;
  ck_assert_uint_eq(cb_count, 1);
  ck_assert_uint_eq(count, 1);

  ucmdr_match("down", &handler);

  handler->callback((void*)1);

  ck_assert_uint_eq(cb_count, 2);
  ck_assert_uint_eq(count, 0);
}
END_TEST

START_TEST(args) {
  uint8_t cnt = ucmdr_install("set", set);

  ck_assert_uint_eq(cnt, 3);

  struct Cmd *handler;
  
  ucmdr_match("set", &handler);

  handler->callback((void*)42);

  ck_assert_uint_eq(count, 42);
}
END_TEST

START_TEST(nomatch) {
  struct Cmd *handler;
  
  uint8_t match = ucmdr_match("nomatch", &handler);

  ck_assert_uint_eq(match, 0);
}
END_TEST

Suite* suite_string(void)
{
  Suite* s;
  TCase* tc_str;
  TCase* tc_cmdr;
  s = suite_create("CMDR Test Suite");

  tc_str = tcase_create("String utils");
  tcase_add_test(tc_str, leading);
  tcase_add_test(tc_str, multi);

  tc_cmdr = tcase_create("CMDR");
  tcase_add_test(tc_cmdr, install);
  tcase_add_test(tc_cmdr, nomatch);
  tcase_add_test(tc_cmdr, match);
  tcase_add_test(tc_cmdr, args);

  suite_add_tcase(s, tc_str);
  suite_add_tcase(s, tc_cmdr);

  return s;
}

int main(void)
{
  int number_failed;
  SRunner* sr;

  ucmdr_init();

  Suite* s_string = suite_string();

  sr = srunner_create(s_string);

  srunner_set_fork_status(sr, CK_NOFORK);
  srunner_run_all(sr, CK_VERBOSE);

  number_failed = srunner_ntests_failed(sr);
  srunner_free(sr);
  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}