"""Tests for peer score calculators."""

import os

import pytest


class TestCapacityCalculator:
    def test_capacity_all_success(self):
        from i2p_peer.calculator import CapacityCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(20):
            p.record_tunnel_build_success()
            p.record_send_success()
            p.record_db_store_success()
        p.heard_from()
        score = CapacityCalculator.calc(p)
        # All success should yield high capacity
        assert score >= 0.8
        assert score <= 1.0

    def test_capacity_all_failure(self):
        from i2p_peer.calculator import CapacityCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(20):
            p.record_tunnel_build_failure()
            p.record_send_failure()
            p.record_db_store_failure()
        score = CapacityCalculator.calc(p)
        # All failure should yield low capacity
        assert score <= 0.15

    def test_capacity_mixed(self):
        from i2p_peer.calculator import CapacityCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(7):
            p.record_tunnel_build_success()
        for _ in range(3):
            p.record_tunnel_build_failure()
        for _ in range(8):
            p.record_send_success()
        for _ in range(2):
            p.record_send_failure()
        for _ in range(6):
            p.record_db_store_success()
        for _ in range(4):
            p.record_db_store_failure()
        p.heard_from()
        score = CapacityCalculator.calc(p)
        # Mixed should be moderate
        assert 0.3 < score < 0.9

    def test_capacity_no_history(self):
        from i2p_peer.calculator import CapacityCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        score = CapacityCalculator.calc(p)
        assert score == 0.0

    def test_capacity_range(self):
        from i2p_peer.calculator import CapacityCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(5):
            p.record_tunnel_build_success()
        score = CapacityCalculator.calc(p)
        assert 0.0 <= score <= 1.0


class TestSpeedCalculator:
    def test_speed_low_latency(self):
        from i2p_peer.calculator import SpeedCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(10):
            p.record_latency(50.0)  # 50ms is fast
        score = SpeedCalculator.calc(p)
        assert score >= 0.7
        assert score <= 1.0

    def test_speed_high_latency(self):
        from i2p_peer.calculator import SpeedCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(10):
            p.record_latency(5000.0)  # 5 seconds is slow
        score = SpeedCalculator.calc(p)
        assert score <= 0.3

    def test_speed_no_latency(self):
        from i2p_peer.calculator import SpeedCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        score = SpeedCalculator.calc(p)
        assert score == 0.0

    def test_speed_range(self):
        from i2p_peer.calculator import SpeedCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        p.record_latency(500.0)
        score = SpeedCalculator.calc(p)
        assert 0.0 <= score <= 1.0


class TestIntegrationCalculator:
    def test_integration_from_db_ops(self):
        from i2p_peer.calculator import IntegrationCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(10):
            p.record_db_store_success()
            p.record_db_lookup_success()
        score = IntegrationCalculator.calc(p)
        assert score >= 0.8
        assert score <= 1.0

    def test_integration_no_ops(self):
        from i2p_peer.calculator import IntegrationCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        score = IntegrationCalculator.calc(p)
        assert score == 0.0

    def test_integration_mixed(self):
        from i2p_peer.calculator import IntegrationCalculator
        from i2p_peer.profile import PeerProfile

        p = PeerProfile(os.urandom(32))
        for _ in range(5):
            p.record_db_store_success()
        for _ in range(5):
            p.record_db_store_failure()
        score = IntegrationCalculator.calc(p)
        assert 0.3 < score < 0.7