#include <criterion/criterion.h>
#include <stdint.h>
#include <math.h>
#include "internal/ping/stats.h"

Test(ping_stats, init_neutral)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	cr_assert_eq(s.count, (size_t)0);
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert_float_eq(min_ms, 0.0, 1e-9);
	cr_assert_float_eq(max_ms, 0.0, 1e-9);
	cr_assert_float_eq(avg_ms, 0.0, 1e-9);
	cr_assert_float_eq(mdev_ms, 0.0, 1e-9);
}

Test(ping_stats, single_update)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	ping_stats_update(&s, 10000000LL); /* 10 ms */
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert_float_eq(min_ms, 10.0, 1e-6);
	cr_assert_float_eq(max_ms, 10.0, 1e-6);
	cr_assert_float_eq(avg_ms, 10.0, 1e-6);
	cr_assert_float_eq(mdev_ms, 0.0, 1e-3);
}

Test(ping_stats, multiple_updates)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	ping_stats_update(&s, 10000000LL); /* 10 ms */
	ping_stats_update(&s, 20000000LL); /* 20 ms */
	ping_stats_update(&s, 30000000LL); /* 30 ms */
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert_float_eq(min_ms, 10.0, 1e-6);
	cr_assert_float_eq(max_ms, 30.0, 1e-6);
	cr_assert_float_eq(avg_ms, 20.0, 1e-6);
	cr_assert(mdev_ms > 0.0, "mdev should be > 0 for different values");
}

Test(ping_stats, identical_values_mdev_zero)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	ping_stats_update(&s, 15000000LL);
	ping_stats_update(&s, 15000000LL);
	ping_stats_update(&s, 15000000LL);
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert_float_eq(min_ms, 15.0, 1e-6);
	cr_assert_float_eq(max_ms, 15.0, 1e-6);
	cr_assert_float_eq(avg_ms, 15.0, 1e-6);
	cr_assert_float_eq(mdev_ms, 0.0, 1e-3);
}

Test(ping_stats, count_tracked)
{
	struct ping_stats s;

	ping_stats_init(&s);
	ping_stats_update(&s, 10000000LL);
	ping_stats_update(&s, 20000000LL);
	ping_stats_update(&s, 30000000LL);
	cr_assert_eq(s.count, (size_t)3);
}

Test(ping_stats, min_max_out_of_order)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	ping_stats_update(&s, 30000000LL); /* 30 ms */
	ping_stats_update(&s, 10000000LL); /* 10 ms */
	ping_stats_update(&s, 20000000LL); /* 20 ms */
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert_float_eq(min_ms, 10.0, 1e-6);
	cr_assert_float_eq(max_ms, 30.0, 1e-6);
}

Test(ping_stats, large_rtt_no_overflow)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	ping_stats_update(&s, 10000000000LL); /* 10 s = 10000 ms */
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert(min_ms > 0.0, "min_ms should be > 0");
	cr_assert(max_ms > 0.0, "max_ms should be > 0");
	cr_assert(avg_ms > 0.0, "avg_ms should be > 0");
	cr_assert_float_eq(avg_ms, 10000.0, 1e-3);
}

Test(ping_stats, two_values_avg)
{
	struct ping_stats s;
	double min_ms, max_ms, avg_ms, mdev_ms;

	ping_stats_init(&s);
	ping_stats_update(&s, 10000000LL); /* 10 ms */
	ping_stats_update(&s, 30000000LL); /* 30 ms */
	ping_stats_get(&s, &min_ms, &max_ms, &avg_ms, &mdev_ms);
	cr_assert_float_eq(avg_ms, 20.0, 1e-6);
}