#include <limits.h>
#include <stdint.h>
#define LS_TEST_IMPLEMENTATION
#include "ls_test.h"

int fail_alloc = 0;

void* test_realloc(void* p, size_t size) {
    if (fail_alloc) {
        return NULL;
    }
    return realloc(p, size);
}

/* this is also set in the Makefile because of the way this is built for tests.
 * It requires a bit of magic because of the way we do things.
 */
#define LS_REALLOC test_realloc

#include "ls_args.h"

TEST_CASE(basic_args) {
    int help = 0;
    int test = 0;
    int no = 0;
    ls_args args;
    char* argv[] = { "./hello", "-h", "--test", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_bool(&args, &test, "t", "test", "A test argument", 0);
    ls_args_bool(&args, &no, "n", "nope", "An argument that isn't present", 0);
    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_with_unused_positionals) {
    int help = 0;
    int test = 0;
    int no = 0;
    const char* unused = NULL;
    ls_args args;
    char* argv[] = { "./hello", "-h", "--test", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_pos_string(&args, &unused, "Not used", 0);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_pos_string(&args, &unused, "Not used", 0);
    ls_args_bool(&args, &test, "t", "test", "A test argument", 0);
    ls_args_pos_string(&args, &unused, "Not used", 0);
    ls_args_bool(&args, &no, "n", "nope", "An argument that isn't present", 0);
    ls_args_pos_string(&args, &unused, "Not used", 0);
    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(help_alloc_fail) {
    int help = 0;
    ls_args args;
    char* help_str;
    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    fail_alloc = 1;
    help_str = ls_args_help(&args);
    fail_alloc = 0;
    ASSERT_STR_EQ(args.last_error, "Allocation failure");
    ASSERT_STR_EQ(help_str, "Not enough memory available to generate help text.");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_required) {
    int help = 0;
    int test = 0;
    ls_args args;
    char* argv[] = { "./hello", "-h", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_bool(
        &args, &test, "t", "test", "A test argument", LS_ARGS_REQUIRED);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Required argument '--test' not found");

    char* argv2[] = { "./hello", "-h", "-t", NULL };
    int argc2 = sizeof(argv2) / sizeof(*argv2) - 1;
    int ret = ls_args_parse(&args, argc2, argv2);
    ASSERT_STR_EQ(args.last_error, "Success");

    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_positional) {
    int help = 0;
    int test = 0;
    int no = 0;
    const char* input;
    const char* output;
    ls_args args;
    char* argv[] = { "./hello", "-h", "hi", "--test", "world", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_pos_string(&args, &input, "Input file", 0);
    ls_args_bool(&args, &test, "t", "test", "A test argument", 0);
    ls_args_bool(&args, &no, "n", "nope", "An argument that isn't present", 0);

    ls_args_pos_string(&args, &output, "Output file", 0);

    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ASSERT_STR_EQ(input, "hi");
    ASSERT_STR_EQ(output, "world");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(too_many_positional_after_double_dash) {
    const char* first = NULL;
    const char* second = NULL;
    ls_args args;
    char* argv[] = { "./hello", "--", "one", "two", "three", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_pos_string(&args, &first, "First positional argument", 0);
    ls_args_pos_string(&args, &second, "Second positional argument", 0);

    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Unexpected argument 'three'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_positional_required_error) {
    const char* first;
    ls_args args;
    char* argv[] = { "./hello", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_pos_string(&args, &first, "first file", LS_ARGS_REQUIRED);

    ASSERT(!ls_args_parse(&args, argc, argv));

    ASSERT_STR_EQ(args.last_error, "Required argument 'first file' not provided");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(positional_value_same_as_flag) {
    int help = 0;
    const char* outfile = "out.txt";
    const char* infile = NULL;
    const char* testfile = NULL;
    ls_args args;
    char* argv[] = { "./basic_example", "hello.txt", "-o", "bruh", "h", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Prints help", 0);
    ls_args_string(&args, &outfile, "o", "out",
        "Specify the outfile, default 'out.txt'", 0);
    ls_args_pos_string(&args, &infile, "Input file", LS_ARGS_REQUIRED);
    ls_args_pos_string(&args, &testfile, "Test file", 0);

    ASSERT(ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(infile, "hello.txt");
    ASSERT_STR_EQ(outfile, "bruh");
    ASSERT_STR_EQ(testfile, "h");

    ls_args_free(&args);
    return 0;
}

TEST_CASE(two_positional_second_required) {
    const char* first = NULL;
    const char* second = NULL;
    ls_args args;
    char* argv[] = { "./hello", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_pos_string(&args, &first, "first", 0);
    ls_args_pos_string(&args, &second, "second", LS_ARGS_REQUIRED);

    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Required argument 'second' not provided");

    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_positional_required) {
    const char* first;
    ls_args args;
    char* argv[] = { "./hello", "world", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_pos_string(&args, &first, "first file", LS_ARGS_REQUIRED);

    ASSERT(ls_args_parse(&args, argc, argv));

    ASSERT_STR_EQ(first, "world");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_positional_only_error) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "world", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);

    ASSERT(!ls_args_parse(&args, argc, argv));

    ASSERT_STR_EQ(args.last_error, "Unexpected argument 'world'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_only_short) {
    int help = 0;
    int test = 0;
    int no = 0;
    ls_args args;
    char* argv[] = { "./hello", "-h", "-t", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", NULL, "Provides help", 0);
    ls_args_bool(&args, &test, "t", NULL, "A test argument", 0);
    ls_args_bool(&args, &no, "n", NULL, "An argument that isn't present", 0);
    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_only_long) {
    int help = 0;
    int test = 0;
    int no = 0;
    ls_args args;
    char* argv[] = { "./hello", "--help", "--test", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, NULL, "help", "Provides help", 0);
    ls_args_bool(&args, &test, NULL, "test", "A test argument", 0);
    ls_args_bool(&args, &no, NULL, "nope", "An argument that isn't present", 0);
    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(basic_args_short_combined) {
    int help = 0;
    int test = 0;
    int no = 0;
    ls_args args;
    char* argv[] = { "./hello", "-ht", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_bool(&args, &test, "t", "test", "A test argument", 0);
    ls_args_bool(&args, &no, "n", "nope", "An argument that isn't present", 0);
    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_invalid_argument) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "-h", "--test", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Invalid argument '--test'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_expected_argument) {
    const char* file = 0;
    ls_args args;
    int help;
    char* argv[] = { "./hello", "--file", "--help", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_string(&args, &file, "f", "file", "File to work on", 0);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Expected argument following '--file'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_expected_argument_last_arg) {
    const char* file = 0;
    ls_args args;
    char* argv[] = { "./hello", "--file", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_string(&args, &file, "f", "file", "File to work on", 0);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Expected argument following '--file'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_expected_argument_short_combined) {
    const char* file = 0;
    ls_args args;
    int help;
    char* argv[] = { "./hello", "-fh", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ls_args_string(&args, &file, "f", "file", "File to work on", 0);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error,
        "Expected argument following '-f', instead got another argument '-h'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_parse_fail) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "-", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Invalid argument '-'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(overflow_args_cap) {
    int help = 0;
    int dummy = 0;
    ls_args args;
    int ret;

    ls_args_init(&args);
    /* First allocate one arg so the structure is properly initialized */
    ret = ls_args_bool(&args, &dummy, "d", "dummy", "Dummy argument", 0);
    ASSERT(ret);
    /* can't have more elements, not even one, at this count */
    args.args_len = SIZE_MAX / sizeof(ls_args_arg);
    args.args_cap = SIZE_MAX / sizeof(ls_args_arg);
    /* Try to add an argument, which should fail due to overflow */
    ret = ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ASSERT(!ret);
    ls_args_free(&args);
    return 0;
}

TEST_CASE(strip_dashes) {
    int help = 0;
    int test = 0;
    int no = 0;
    ls_args args;
    char* argv[] = { "./hello", "-h", "--test", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    /* the dashes are optional */
    ls_args_bool(&args, &help, "-h", "--help", "Provides help", 0);
    /* you can mix them */
    ls_args_bool(&args, &test, "t", "--test", "A test argument", 0);
    /* have as many as you want */
    ls_args_bool(
        &args, &no, "-n", "----nope", "An argument that isn't present", 0);
    if (!ls_args_parse(&args, argc, argv)) {
        printf("Error: %s\n", args.last_error);
        ASSERT(!"ls_args_parse failed");
    }
    ASSERT_EQ(help, 1, "%d");
    ASSERT_EQ(test, 1, "%d");
    ASSERT_EQ(no, 0, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(alloc_fail) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "-", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;
    int ret;

    ls_args_init(&args);
    ASSERT_EQ(args.args_len, 0, "%uz");
    /* deliberately fail the allocation here */
    fail_alloc = 1;
    /* if the allocation fails, this fails */
    ret = ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    fail_alloc = 0;
    ASSERT(!ret);
    ASSERT_STR_EQ(args.last_error, "Allocation failure");
    /* there is no documented error state for this; we simply fail to add the
     * argument? */
    ASSERT_EQ(args.args_len, 0, "%uz");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(alloc_fail_pos_string) {
    const char* input = NULL;
    ls_args args;
    char* argv[] = { "./hello", "file.txt", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;
    int ret;

    ls_args_init(&args);
    ASSERT_EQ(args.args_len, 0, "%uz");
    /* deliberately fail the allocation here */
    fail_alloc = 1;
    /* if the allocation fails, this fails */
    ret = ls_args_pos_string(&args, &input, "Input file", 0);
    fail_alloc = 0;
    ASSERT(!ret);
    ASSERT_STR_EQ(args.last_error, "Allocation failure");
    ASSERT_EQ(args.args_len, 0, "%uz");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_parse_fail_empty) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Invalid argument ''");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_parse_ignore_double_dash) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "--", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ASSERT(ls_args_parse(&args, argc, argv));
    ls_args_free(&args);
    return 0;
}

TEST_CASE(parse_stop) {
    const char *first, *second;
    ls_args args;
    int help = 0;
    char* argv[] = { "./hello", "--help", "--", "-h", "--test", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_pos_string(&args, &first, "First positional argument", 0);
    ls_args_pos_string(&args, &second, "First positional argument", 0);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ASSERT(ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(first, "-h");
    ASSERT_STR_EQ(second, "--test");
    ASSERT_EQ(help, 1, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(error_invalid_argument_short) {
    int help = 0;
    ls_args args;
    char* argv[] = { "./hello", "-h", "-t", "-h", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_bool(&args, &help, "h", "help", "Provides help", 0);
    ASSERT(!ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(args.last_error, "Invalid argument '-t'");
    ls_args_free(&args);
    return 0;
}

TEST_CASE(string_args) {
    const char* input = NULL;
    const char* output = NULL;
    int verbose = 0;
    ls_args args;
    char* argv[] = { "./program", "--input", "file.txt", "-o", "output.txt",
        "-v", NULL };
    int argc = sizeof(argv) / sizeof(*argv) - 1;

    ls_args_init(&args);
    ls_args_string(&args, &input, "i", "input", "Input file path", 0);
    ls_args_string(&args, &output, "o", "output", "Output file path", 0);
    ls_args_bool(&args, &verbose, "v", "verbose", "Verbose output", 0);
    ASSERT(ls_args_parse(&args, argc, argv));
    ASSERT_STR_EQ(input, "file.txt");
    ASSERT_STR_EQ(output, "output.txt");
    ASSERT_EQ(verbose, 1, "%d");
    ls_args_free(&args);
    return 0;
}

TEST_MAIN