#include <math.h>

#include "unit/TestRunner.h"
#include "time/TaskTimer.h"

#define SLEEP_DURATION_MS 10.0
// Timer testing is a bit unreliable, so we just check to see that each sleep
// call (see below) is recorded off no more than this amount of milliseconds.
#define MAX_TIMER_TOLERANCE_MS 1.5f
#define TEST_COMPONENT_NAME "component"
#define TEST_SUBCOMPONENT_NAME "subcomponent"

// Keep a static task timer which can easily be destroyed in the teardown. The
// reason for this is that when running the test suite in valgrind, the timing
// tests often fail, which will cuase the suite to leak. Having failed timing
// tests is probably ok when running in valgrind, but leaking memory isn't, as
// that's the entire point of running it there. :)
static TaskTimer _testTaskTimer;

static void _testTaskTimerSetup(void)
{
    _testTaskTimer = newTaskTimerWithCString(TEST_COMPONENT_NAME, TEST_SUBCOMPONENT_NAME);
}

static void _testTaskTimerTeardown(void)
{
    freeTaskTimer(_testTaskTimer);
}

static int _testNewTaskTimer(void)
{
    CharString c = newCharStringWithCString(TEST_COMPONENT_NAME);
    TaskTimer t = newTaskTimer(c, TEST_SUBCOMPONENT_NAME);

    assert(t->enabled);
    assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
    assertCharStringEquals(TEST_SUBCOMPONENT_NAME, t->subcomponent);
    assertDoubleEquals(0.0, t->totalTaskTime, TEST_DEFAULT_TOLERANCE);

    freeCharString(c);
    freeTaskTimer(t);
    return 0;
}

static int _testNewObjectWithEmptyComponent(void)
{
    CharString c = newCharStringWithCString(EMPTY_STRING);
    TaskTimer t = newTaskTimer(c, TEST_SUBCOMPONENT_NAME);

    assertNotNull(t);
    assertCharStringEquals(EMPTY_STRING, t->component);
    assertCharStringEquals(TEST_SUBCOMPONENT_NAME, t->subcomponent);

    freeCharString(c);
    freeTaskTimer(t);
    return 0;
}

static int _testNewObjectWithEmptySubcomponent(void)
{
    CharString c = newCharStringWithCString(TEST_COMPONENT_NAME);
    TaskTimer t = newTaskTimer(c, EMPTY_STRING);

    assertNotNull(t);
    assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
    assertCharStringEquals(EMPTY_STRING, t->subcomponent);

    freeCharString(c);
    freeTaskTimer(t);
    return 0;
}

static int _testNewObjectWithNullComponent(void)
{
    TaskTimer t = newTaskTimer(NULL, NULL);

    assertNotNull(t);
    assertCharStringEquals(EMPTY_STRING, t->component);
    assertCharStringEquals(EMPTY_STRING, t->subcomponent);

    freeTaskTimer(t);
    return 0;
}

static int _testNewObjectWithNullComponentCString(void)
{
    TaskTimer t = newTaskTimerWithCString(NULL, NULL);

    assertNotNull(t);
    assertCharStringEquals(EMPTY_STRING, t->component);
    assertCharStringEquals(EMPTY_STRING, t->subcomponent);

    freeTaskTimer(t);
    return 0;
}

static int _testNewObjectWithNullSubcomponent(void)
{
    CharString c = newCharStringWithCString(TEST_COMPONENT_NAME);
    TaskTimer t = newTaskTimer(c, NULL);

    assertNotNull(t);
    assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
    assertCharStringEquals(EMPTY_STRING, t->subcomponent);

    freeCharString(c);
    freeTaskTimer(t);
    return 0;
}

static int _testNewObjectWithCStrings(void)
{
    TaskTimer t = newTaskTimerWithCString(TEST_COMPONENT_NAME, TEST_SUBCOMPONENT_NAME);

    assert(t->enabled);
    assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
    assertCharStringEquals(TEST_SUBCOMPONENT_NAME, t->subcomponent);
    assertDoubleEquals(0.0, t->totalTaskTime, TEST_DEFAULT_TOLERANCE);

    freeTaskTimer(t);
    return 0;
}

static void _testSleep(void)
{
    taskTimerSleep(SLEEP_DURATION_MS);
}

static int _testTaskTimerDuration(void)
{
    double elapsedTime = 0.0;
    taskTimerStart(_testTaskTimer);
    _testSleep();
    elapsedTime = taskTimerStop(_testTaskTimer);
    assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
    assertTimeEquals(SLEEP_DURATION_MS, elapsedTime, MAX_TIMER_TOLERANCE_MS);
    return 0;
}

static int _testTaskTimerDurationMultipleTimes(void)
{
    double elapsedTime = 0.0;
    int i;

    for (i = 0; i < 5; i++) {
        taskTimerStart(_testTaskTimer);
        _testSleep();
        elapsedTime = taskTimerStop(_testTaskTimer);
        assertTimeEquals(SLEEP_DURATION_MS, elapsedTime, MAX_TIMER_TOLERANCE_MS);
        elapsedTime = 0.0;
    }

    assertTimeEquals(5.0 * SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS * 5.0);

    return 0;
}

static int _testTaskTimerCallStartTwice(void)
{
    taskTimerStart(_testTaskTimer);
    taskTimerStart(_testTaskTimer);
    _testSleep();
    taskTimerStop(_testTaskTimer);
    assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
    return 0;
}

static int _testTaskTimerCallStopTwice(void)
{
    taskTimerStart(_testTaskTimer);
    _testSleep();
    taskTimerStop(_testTaskTimer);
    taskTimerStop(_testTaskTimer);
    assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
    return 0;
}

static int _testCallStopBeforeStart(void)
{
    taskTimerStop(_testTaskTimer);
    taskTimerStart(_testTaskTimer);
    _testSleep();
    taskTimerStop(_testTaskTimer);
    assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
    return 0;
}

static int _testHumanReadableTimeMs(void)
{
    CharString s;
    _testTaskTimer->totalTaskTime = 230;
    s = taskTimerHumanReadbleString(_testTaskTimer);
    assertCharStringEquals("230ms", s);
    freeCharString(s);
    return 0;
}

static int _testHumanReadableTimeSec(void)
{
    CharString s;
    // 23 seconds
    _testTaskTimer->totalTaskTime = 23000;
    s = taskTimerHumanReadbleString(_testTaskTimer);
    assertCharStringEquals("23sec", s);
    freeCharString(s);
    return 0;
}

static int _testHumanReadableTimeMinSec(void)
{
    CharString s;
    // 10 minutes, 23 seconds
    _testTaskTimer->totalTaskTime = 600000 + 23000;
    s = taskTimerHumanReadbleString(_testTaskTimer);
    assertCharStringEquals("10:23sec", s);
    freeCharString(s);
    return 0;
}

static int _testHumanReadableTimeHoursMinSec(void)
{
    CharString s;
    // 2 hours, 10 minutes, 23 seconds
    _testTaskTimer->totalTaskTime = (1000 * 60 * 60 * 2) + 600000 + 23000;
    s = taskTimerHumanReadbleString(_testTaskTimer);
    assertCharStringEquals("2:10:23sec", s);
    freeCharString(s);
    return 0;
}

static int _testHumanReadableTimeNotStarted(void)
{
    CharString s = taskTimerHumanReadbleString(_testTaskTimer);
    assertCharStringEquals("0ms", s);
    freeCharString(s);
    return 0;
}

static int _testSleepMilliseconds(void)
{
    double elapsedTime;
    TaskTimer t = newTaskTimerWithCString("test", "test");
    taskTimerStart(t);
    taskTimerSleep(12);
    elapsedTime = taskTimerStop(t);
    assertTimeEquals(12, elapsedTime, 0.1);
    freeTaskTimer(t);
    return 0;
}

TestSuite addTaskTimerTests(void);
TestSuite addTaskTimerTests(void)
{
    TestSuite testSuite = newTestSuite("TaskTimer", _testTaskTimerSetup, _testTaskTimerTeardown);
    addTest(testSuite, "NewObject", _testNewTaskTimer);
    addTest(testSuite, "NewObjectWithEmptyComponent", _testNewObjectWithEmptyComponent);
    addTest(testSuite, "NewObjectWithEmptySubcomponent", _testNewObjectWithEmptySubcomponent);
    addTest(testSuite, "NewObjectWithNullComponent", _testNewObjectWithNullComponent);
    addTest(testSuite, "NewObjectWithNullComponentCString", _testNewObjectWithNullComponentCString);
    addTest(testSuite, "NewObjectWithNullSubcomponent", _testNewObjectWithNullSubcomponent);
    addTest(testSuite, "NewObjectWithCStrings", _testNewObjectWithCStrings);

    addTest(testSuite, "TaskDuration", _testTaskTimerDuration);
    addTest(testSuite, "TaskDurationMultipleTimes", _testTaskTimerDurationMultipleTimes);

    addTest(testSuite, "CallStartTwice", _testTaskTimerCallStartTwice);
    addTest(testSuite, "CallStopTwice", _testTaskTimerCallStopTwice);
    addTest(testSuite, "CallStartTwice", _testTaskTimerCallStartTwice);
    addTest(testSuite, "CallStopBeforeStart", _testCallStopBeforeStart);

    addTest(testSuite, "HumanReadableTimeMs", _testHumanReadableTimeMs);
    addTest(testSuite, "HumanReadableTimeSec", _testHumanReadableTimeSec);
    addTest(testSuite, "HumanReadableTimeMinSec", _testHumanReadableTimeMinSec);
    addTest(testSuite, "HumanReadableTimeHoursMinSec", _testHumanReadableTimeHoursMinSec);
    addTest(testSuite, "HumanReadableTimeNotStarted", _testHumanReadableTimeNotStarted);

    addTest(testSuite, "SleepMilliseconds", _testSleepMilliseconds);
    return testSuite;
}