# retoor <retoor@molodetz.nl>

import math
import unittest

from src.calculator import clamp, percentage, variance


class TestClampFunction(unittest.TestCase):

    def test_value_below_low_returns_low(self) -> None:
        self.assertEqual(clamp(-5, 0, 10), 0)

    def test_value_above_high_returns_high(self) -> None:
        self.assertEqual(clamp(15, 0, 10), 10)

    def test_value_in_range_returns_value(self) -> None:
        self.assertEqual(clamp(5, 0, 10), 5)

    def test_value_equals_low_returns_low(self) -> None:
        self.assertEqual(clamp(0, 0, 10), 0)

    def test_value_equals_high_returns_high(self) -> None:
        self.assertEqual(clamp(10, 0, 10), 10)

    def test_low_greater_than_high_raises_value_error(self) -> None:
        with self.assertRaises(ValueError):
            clamp(5, 10, 0)

    def test_all_negative_values(self) -> None:
        self.assertEqual(clamp(-10, -5, -1), -5)

    def test_float_value_below_low_returns_low_as_int(self) -> None:
        self.assertEqual(clamp(-1.0, 0, 10), 0)

    def test_float_value_above_high_returns_high_as_int(self) -> None:
        self.assertEqual(clamp(15.0, 0, 10), 10)

    def test_float_value_in_range_returns_float(self) -> None:
        result = clamp(5.0, 0, 10)
        self.assertIsInstance(result, float)
        self.assertEqual(result, 5.0)

    def test_float_value_equals_boundary_returns_boundary(self) -> None:
        self.assertEqual(clamp(0.0, 0, 10), 0)
        self.assertEqual(clamp(10.0, 0, 10), 10)

    def test_float_low_greater_than_float_high_raises_value_error(self) -> None:
        with self.assertRaises(ValueError):
            clamp(5.0, 10.0, 0.0)

    def test_large_values(self) -> None:
        self.assertEqual(clamp(10**9, 0, 10**6), 10**6)

    def test_negative_infinity_not_clamped_by_default(self) -> None:
        self.assertEqual(clamp(-math.inf, 0, 10), 0)

    def test_positive_infinity_not_clamped_by_default(self) -> None:
        self.assertEqual(clamp(math.inf, 0, 10), 10)

    def test_nan_returns_nan(self) -> None:
        result = clamp(math.nan, 0, 10)
        self.assertTrue(math.isnan(result))


class TestPercentageFunction(unittest.TestCase):

    def test_valid_percentage(self) -> None:
        self.assertEqual(percentage(50, 200), 25.0)

    def test_zero_value(self) -> None:
        self.assertEqual(percentage(0, 100), 0.0)

    def test_full_value(self) -> None:
        self.assertEqual(percentage(200, 100), 200.0)

    def test_fractional(self) -> None:
        self.assertAlmostEqual(percentage(1, 3), 33.333333333333336)

    def test_total_zero(self) -> None:
        with self.assertRaises(ValueError):
            percentage(50, 0)

    def test_float_arguments(self) -> None:
        self.assertEqual(percentage(25.5, 100.0), 25.5)

    def test_negative_value(self) -> None:
        self.assertEqual(percentage(-50, 200), -25.0)


class TestVarianceFunction(unittest.TestCase):

    def test_empty_list_raises_value_error(self) -> None:
        with self.assertRaises(ValueError):
            variance([])

    def test_empty_tuple_raises_value_error(self) -> None:
        with self.assertRaises(ValueError):
            variance(())

    def test_single_element_returns_zero(self) -> None:
        self.assertEqual(variance([42.0]), 0.0)

    def test_constant_values_return_zero_variance(self) -> None:
        self.assertEqual(variance([1.0, 1.0, 1.0]), 0.0)

    def test_population_variance_of_known_set(self) -> None:
        self.assertEqual(variance([1, 2, 3, 4, 5]), 2.0)

    def test_two_element_variance(self) -> None:
        self.assertEqual(variance([0, 2]), 1.0)

    def test_integer_inputs_return_float(self) -> None:
        result = variance([10, 20, 30])
        self.assertIsInstance(result, float)
        self.assertEqual(result, 200.0 / 3.0)

    def test_tuple_input_returns_variance(self) -> None:
        self.assertEqual(variance((1, 2, 3, 4, 5)), 2.0)