import unittest
from unittest.mock import MagicMock, patch

from app.services.hardware import HX711UnavailableError, HX711Wrapper


class HX711WrapperTests(unittest.TestCase):
    def test_simulation_mode_returns_non_negative_samples(self) -> None:
        wrapper = HX711Wrapper(simulation_mode=True)
        values = [wrapper.read_weight_sample() for _ in range(20)]
        self.assertEqual(len(values), 20)
        for value in values:
            self.assertIsInstance(value, float)
            self.assertGreaterEqual(value, 0.0)

    def test_apply_simulation_mode_initializes_device_when_disabled(self) -> None:
        wrapper = HX711Wrapper(simulation_mode=True)
        self.assertIsNone(wrapper._device)

        device = MagicMock()
        with unittest.mock.patch.dict(
            "sys.modules",
            {"hx711": MagicMock(HX711=MagicMock(return_value=device))},
        ):
            wrapper.apply_simulation_mode(False)

        self.assertFalse(wrapper.simulation_mode)
        self.assertIs(wrapper._device, device)

    def test_apply_simulation_mode_clears_device_when_enabled(self) -> None:
        wrapper = HX711Wrapper.__new__(HX711Wrapper)
        wrapper._sim_weight = 0.0
        wrapper._dout_pin = 2
        wrapper._pd_sck_pin = 3
        wrapper._device = MagicMock()
        wrapper.simulation_mode = False

        wrapper.apply_simulation_mode(True)

        self.assertTrue(wrapper.simulation_mode)
        self.assertIsNone(wrapper._device)

    def test_non_simulation_raises_when_no_device(self) -> None:
        wrapper = HX711Wrapper.__new__(HX711Wrapper)
        wrapper.simulation_mode = False
        wrapper._device = None
        wrapper._dout_pin = 2
        wrapper._pd_sck_pin = 3
        wrapper._sim_weight = 0.0
        with self.assertRaises(HX711UnavailableError):
            wrapper.read_weight_sample()

    def test_read_raw_mean_via_get_raw_data_list(self) -> None:
        wrapper = HX711Wrapper.__new__(HX711Wrapper)
        wrapper.simulation_mode = False
        wrapper._sim_weight = 0.0
        wrapper._dout_pin = 2
        wrapper._pd_sck_pin = 3
        device = MagicMock(spec=["get_raw_data"])
        device.get_raw_data.return_value = [-28000, -28020, -28010]
        wrapper._device = device
        value = wrapper.read_weight_sample()
        self.assertAlmostEqual(value, -28010.0, places=1)
        device.get_raw_data.assert_called_once_with(times=3)

    def test_read_raw_mean_via_get_raw_data_mean(self) -> None:
        wrapper = HX711Wrapper.__new__(HX711Wrapper)
        wrapper.simulation_mode = False
        wrapper._sim_weight = 0.0
        wrapper._dout_pin = 2
        wrapper._pd_sck_pin = 3
        device = MagicMock(spec=["get_raw_data_mean"])
        device.get_raw_data_mean.return_value = 12345.0
        wrapper._device = device
        self.assertEqual(wrapper.read_weight_sample(), 12345.0)
        device.get_raw_data_mean.assert_called_once_with(3)


if __name__ == "__main__":
    unittest.main()