"""Tests for i2p_stat — RateStat, FrequencyStat, StatManager."""

import time
from i2p_stat.rate_stat import RateStat
from i2p_stat.frequency import Frequency
from i2p_stat.frequency_stat import FrequencyStat
from i2p_stat.stat_manager import StatManager
from i2p_stat.rate_averages import RateAverages


class TestRateStat:
    def test_create(self):
        rs = RateStat("test", "desc", "group", [60000, 3600000])
        assert rs.name == "test"
        assert rs.group_name == "group"
        assert rs.get_periods() == [60000, 3600000]

    def test_add_data_to_all_rates(self):
        rs = RateStat("test", "desc", "group", [60000, 3600000])
        rs.add_data(100)
        r1 = rs.get_rate(60000)
        r2 = rs.get_rate(3600000)
        assert r1.get_current_event_count() == 1
        assert r2.get_current_event_count() == 1

    def test_contains_rate(self):
        rs = RateStat("test", "desc", "group", [60000])
        assert rs.contains_rate(60000)
        assert not rs.contains_rate(1000)

    def test_get_rate_nonexistent(self):
        rs = RateStat("test", "desc", "group", [60000])
        assert rs.get_rate(999) is None

    def test_lifetime(self):
        rs = RateStat("test", "desc", "group", [60000])
        rs.add_data(10)
        rs.add_data(30)
        assert rs.get_lifetime_event_count() == 2
        assert rs.get_lifetime_average_value() == 20.0


class TestFrequency:
    def test_create(self):
        f = Frequency(60000)
        assert f.period == 60000
        assert f.get_event_count() == 0

    def test_event_occurred(self):
        f = Frequency(60000)
        f.event_occurred()
        assert f.get_event_count() == 1

    def test_average_interval_decreases_with_events(self):
        f = Frequency(10000)
        initial = f.get_average_interval()
        time.sleep(0.01)
        f.event_occurred()
        time.sleep(0.01)
        f.event_occurred()
        after = f.get_average_interval()
        # After events, interval should be less than initial (period+1)
        assert after < initial

    def test_events_per_period(self):
        f = Frequency(1000)  # 1s period
        # Rapid events should show high events per period
        for _ in range(10):
            f.event_occurred()
            time.sleep(0.005)
        eps = f.get_average_events_per_period()
        assert eps > 0


class TestFrequencyStat:
    def test_create(self):
        fs = FrequencyStat("test", "desc", "group", [60000, 3600000])
        assert fs.name == "test"
        assert len(fs.get_periods()) == 2

    def test_event_propagates(self):
        fs = FrequencyStat("test", "desc", "group", [60000])
        fs.event_occurred()
        assert fs.get_event_count() == 1


class TestStatManager:
    def test_create_required_rate(self):
        sm = StatManager()
        sm.create_required_rate_stat("bw.send", "bytes sent", "bandwidth", [60000])
        assert sm.is_rate("bw.send")
        assert not sm.is_rate("nonexistent")

    def test_create_rate_ignored_without_stat_full(self):
        sm = StatManager(stat_full=False)
        sm.create_rate_stat("optional", "desc", "group", [60000])
        assert not sm.is_rate("optional")

    def test_create_rate_with_stat_full(self):
        sm = StatManager(stat_full=True)
        sm.create_rate_stat("optional", "desc", "group", [60000])
        assert sm.is_rate("optional")

    def test_add_rate_data(self):
        sm = StatManager()
        sm.create_required_rate_stat("test", "desc", "group", [60000])
        sm.add_rate_data("test", 100)
        r = sm.get_rate("test")
        assert r.get_rate(60000).get_current_event_count() == 1

    def test_add_rate_data_nonexistent_is_noop(self):
        sm = StatManager()
        sm.add_rate_data("nonexistent", 100)  # Should not raise

    def test_frequency_stat(self):
        sm = StatManager()
        sm.create_required_frequency_stat("test.freq", "desc", "group", [60000])
        assert sm.is_frequency("test.freq")
        sm.update_frequency("test.freq")
        assert sm.get_frequency("test.freq").get_event_count() == 1

    def test_get_names(self):
        sm = StatManager()
        sm.create_required_rate_stat("r1", "d", "g", [60000])
        sm.create_required_rate_stat("r2", "d", "g", [60000])
        assert sm.get_rate_names() == {"r1", "r2"}

    def test_remove_rate(self):
        sm = StatManager()
        sm.create_required_rate_stat("test", "d", "g", [60000])
        sm.remove_rate_stat("test")
        assert not sm.is_rate("test")

    def test_shutdown(self):
        sm = StatManager()
        sm.create_required_rate_stat("test", "d", "g", [60000])
        sm.shutdown()
        assert len(sm.get_rate_names()) == 0

    def test_stats_by_group(self):
        sm = StatManager()
        sm.create_required_rate_stat("r1", "d", "bandwidth", [60000])
        sm.create_required_rate_stat("r2", "d", "bandwidth", [60000])
        sm.create_required_rate_stat("r3", "d", "tunnel", [60000])
        groups = sm.get_stats_by_group()
        assert "bandwidth" in groups
        assert len(groups["bandwidth"]) == 2
        assert "tunnel" in groups

    def test_coalesce_stats(self):
        sm = StatManager()
        sm.create_required_rate_stat("test", "d", "g", [100])
        sm.add_rate_data("test", 50)
        time.sleep(0.15)
        sm.coalesce_stats()
        r = sm.get_rate("test").get_rate(100)
        assert r.get_last_event_count() > 0


class TestRateAverages:
    def test_get_temp_returns_same_instance(self):
        a = RateAverages.get_temp()
        b = RateAverages.get_temp()
        assert a is b

    def test_fields_default_zero(self):
        ra = RateAverages()
        assert ra.average == 0.0
        assert ra.total_event_count == 0