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

#include "libharkio3.h"

START_TEST(test_new)
{
    harkio_Config *cfg = harkio_Config_new();
    ck_assert_int_eq(cfg->synchronousAverage, 0);
    ck_assert_int_eq(cfg->TSPoffset, 0);
    ck_assert_int_eq(cfg->peakSearchFrom, 0);
    ck_assert_int_eq(cfg->peakSearchTo, 0);
    ck_assert_int_eq(cfg->nfft, 0);
    ck_assert(cfg->TSPpath == NULL);
    harkio_Config_print(cfg);

    harkio_Config_delete(&cfg);

    harkio_Config_print(cfg);
}
END_TEST

START_TEST(test_delete)
{
    harkio_Config *cfg = harkio_Config_new();
    ck_assert(cfg != NULL);

    harkio_Config_delete(&cfg);
    ck_assert(cfg == NULL);

    harkio_Config_delete(&cfg);
    ck_assert(cfg == NULL);

    harkio_Config_delete(NULL);

}
END_TEST

START_TEST(test_setgetValues)
{
    int ret;
    int value;
    char *cvalue;
    harkio_Config *cfg = harkio_Config_new();

    ret = harkio_Config_setSynchronousAverage(cfg, 16);
    ck_assert_int_eq(ret, EXIT_SUCCESS);
    value = harkio_Config_getSynchronousAverage(cfg);
    ck_assert_int_eq(value, 16);


//	cfg->TSPpath ="";
    ret = harkio_Config_setTSPpath(cfg , "");
//    ck_assert_int_eq(ret, EXIT_SUCCESS);
    cvalue = harkio_Config_getTSPpath(cfg);
    ck_assert(strcmp(cvalue, "") == 0);


    ret = harkio_Config_setTSPpath(cfg, "/home/mizumoto/tsp.wav");
    ck_assert_int_eq(ret, EXIT_SUCCESS);
    cvalue = harkio_Config_getTSPpath(cfg);
    ck_assert(strcmp(cvalue, "/home/mizumoto/tsp.wav") == 0);




    ret = harkio_Config_setTSPoffset(cfg, 100);
    ck_assert_int_eq(ret, EXIT_SUCCESS);
    value = harkio_Config_getTSPoffset(cfg);
    ck_assert_int_eq(value, 100);

    ret = harkio_Config_setPeakSearchFrom(cfg, 1);
    ck_assert_int_eq(ret, EXIT_SUCCESS);
    value = harkio_Config_getPeakSearchFrom(cfg);
    ck_assert_int_eq(value, 1);

    ret = harkio_Config_setPeakSearchTo(cfg, 50);
    ck_assert_int_eq(ret, EXIT_SUCCESS);
    value = harkio_Config_getPeakSearchTo(cfg);
    ck_assert_int_eq(value, 50);

    ret = harkio_Config_setNfft(cfg, 2048);
    ck_assert_int_eq(ret, EXIT_SUCCESS);
    value = harkio_Config_getNfft(cfg);
    ck_assert_int_eq(value, 2048);





    // wrong values
    ret = harkio_Config_setSynchronousAverage(cfg, -10);
    ck_assert_int_eq(ret, EXIT_FAILURE);
    ret = harkio_Config_setPeakSearchTo(cfg, 0);
    ck_assert_int_eq(ret, EXIT_FAILURE);
    ret = harkio_Config_setNfft(cfg, -10);
    ck_assert_int_eq(ret, EXIT_FAILURE);
    ret = harkio_Config_setComment(cfg, NULL);
    ck_assert_int_eq(ret, EXIT_FAILURE);

    harkio_Config_delete(&cfg);
}
END_TEST

START_TEST(test_isEqual)
{
    harkio_Config *cfg1 = harkio_Config_new();
    harkio_Config *cfg2 = harkio_Config_new();
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 1);
    harkio_Config_delete(&cfg2);

    cfg2 = harkio_Config_new();
    harkio_Config_setSynchronousAverage(cfg2, 1);
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 0);
    ck_assert_int_eq(harkio_Config_isEqual(cfg2, cfg1), 0);
    harkio_Config_delete(&cfg2);

    cfg2 = harkio_Config_new();
    harkio_Config_setPeakSearchTo(cfg2, 1);
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 0);
    ck_assert_int_eq(harkio_Config_isEqual(cfg2, cfg1), 0);
    harkio_Config_delete(&cfg2);

    cfg2 = harkio_Config_new();
    harkio_Config_setPeakSearchFrom(cfg2, 1);
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 0);
    ck_assert_int_eq(harkio_Config_isEqual(cfg2, cfg1), 0);
    harkio_Config_delete(&cfg2);

    cfg2 = harkio_Config_new();
    harkio_Config_setTSPoffset(cfg2, 1);
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 0);
    ck_assert_int_eq(harkio_Config_isEqual(cfg2, cfg1), 0);
    harkio_Config_delete(&cfg2);

    cfg2 = harkio_Config_new();
    harkio_Config_setTSPpath(cfg2, "/home");
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 0);
    ck_assert_int_eq(harkio_Config_isEqual(cfg2, cfg1), 0);
    harkio_Config_delete(&cfg2);

    cfg2 = harkio_Config_new();
    harkio_Config_setNfft(cfg2, 1);
    ck_assert_int_eq(harkio_Config_isEqual(cfg1, cfg2), 0);
    ck_assert_int_eq(harkio_Config_isEqual(cfg2, cfg1), 0);
    harkio_Config_delete(&cfg2);

    ck_assert_int_eq(harkio_Config_isEqual(cfg1, NULL), 0);
    ck_assert_int_eq(harkio_Config_isEqual(NULL, cfg2), 0);

    harkio_Config_delete(&cfg1);
}
END_TEST

Suite* str_suite(void)
{
    Suite *suite = suite_create("libharkio3_config");

    TCase *tcase1 = tcase_create("new/delete");
    tcase_add_test(tcase1, test_new);
    tcase_add_test(tcase1, test_delete);
    suite_add_tcase(suite, tcase1);

    TCase *tcase2 = tcase_create("setter / getter");
    tcase_add_test(tcase2, test_setgetValues);
    // tcase_add_test(tcase2, test_setgetNeighbors);
    // tcase_add_test(tcase2, test_setgetData);
    suite_add_tcase(suite, tcase2);

    TCase *tcase3 = tcase_create("util");
    tcase_add_test(tcase3, test_isEqual);
    suite_add_tcase(suite, tcase3);

    return suite;
}

int main(int argc, char *argv[])
{
    int number_failed;
    Suite *suite = str_suite();
    SRunner *runner = srunner_create(suite);
    srunner_run_all(runner, CK_NORMAL);
    number_failed = srunner_ntests_failed(runner);
    srunner_free(runner);
    return number_failed;
}
