class MockSharedPreferences:
    """Mock SharedPreferences for testing."""

    _all_data = {}  # Class-level storage

    def __init__(self, app_id, filename=None):
        self.app_id = app_id
        self.filename = filename
        if app_id not in MockSharedPreferences._all_data:
            MockSharedPreferences._all_data[app_id] = {}

    def _get_value(self, key, default):
        return MockSharedPreferences._all_data.get(self.app_id, {}).get(key, default)

    def get_dict(self, key):
        return self._get_value(key, {})

    def get_list(self, key, default=None):
        return self._get_value(key, default)

    def get_bool(self, key, default=False):
        value = self._get_value(key, default)
        return bool(value)

    def get_string(self, key, default=""):
        value = self._get_value(key, default)
        return value if value is not None else default

    def get_int(self, key, default=0):
        value = self._get_value(key, default)
        try:
            return int(value)
        except (TypeError, ValueError):
            return default

    def edit(self):
        return MockEditor(self)

    @classmethod
    def reset_all(cls):
        cls._all_data = {}


class MockEditor:
    """Mock editor for SharedPreferences."""

    def __init__(self, prefs):
        self.prefs = prefs
        self.pending = {}

    def put_dict(self, key, value):
        self.pending[key] = value

    def put_list(self, key, value):
        self.pending[key] = value

    def put_bool(self, key, value):
        self.pending[key] = bool(value)

    def put_string(self, key, value):
        self.pending[key] = value

    def put_int(self, key, value):
        self.pending[key] = int(value)

    def commit(self):
        if self.prefs.app_id not in MockSharedPreferences._all_data:
            MockSharedPreferences._all_data[self.prefs.app_id] = {}
        MockSharedPreferences._all_data[self.prefs.app_id].update(self.pending)


class MockMpos:
    """Mock mpos module with config and time."""

    class config:
        @staticmethod
        def SharedPreferences(app_id):
            return MockSharedPreferences(app_id)

    class time:
        @staticmethod
        def sync_time():
            pass  # No-op for testing


class HotspotMockNetwork:
    """Mock network module with AP/STA support for hotspot tests."""

    STA_IF = 0
    AP_IF = 1

    AUTH_OPEN = 0
    AUTH_WPA_PSK = 1
    AUTH_WPA2_PSK = 2
    AUTH_WPA_WPA2_PSK = 3

    class MockWLAN:
        def __init__(self, interface):
            self.interface = interface
            self._active = False
            self._connected = False
            self._config = {}
            self._scan_results = []
            self._ifconfig = ("0.0.0.0", "0.0.0.0", "0.0.0.0", "0.0.0.0")

        def active(self, is_active=None):
            if is_active is None:
                return self._active
            self._active = is_active
            return None

        def isconnected(self):
            return self._connected

        def connect(self, ssid, password):
            self._connected = True
            self._config["essid"] = ssid

        def disconnect(self):
            self._connected = False

        def config(self, *args, **kwargs):
            if kwargs:
                self._config.update(kwargs)
                return None
            if args:
                return self._config.get(args[0])
            return self._config

        def ifconfig(self, cfg=None):
            if cfg is None:
                return self._ifconfig
            self._ifconfig = cfg
            return None

        def ipconfig(self, key=None):
            config = self.ifconfig()
            mapping = {
                "addr4": config[0],
                "netmask4": config[1],
                "gw4": config[2],
                "dns4": config[3],
            }
            if key is None:
                return mapping
            return mapping.get(key)

        def scan(self):
            return self._scan_results

    def __init__(self):
        self._wlan_instances = {}

    def WLAN(self, interface):
        if interface not in self._wlan_instances:
            self._wlan_instances[interface] = self.MockWLAN(interface)
        return self._wlan_instances[interface]


class MockADC:
    """Mock ADC for testing."""

    ATTN_11DB = 3

    def __init__(self, pin):
        self.pin = pin
        self._atten = None
        self._read_value = 2048

    def atten(self, value):
        self._atten = value

    def read(self):
        return self._read_value

    def set_read_value(self, value):
        """Test helper to set ADC reading."""
        self._read_value = value


class MockPin:
    """Mock Pin for testing."""

    def __init__(self, pin_num):
        self.pin_num = pin_num


class MockMachineADC:
    """Mock machine module with ADC/Pin."""

    ADC = MockADC
    Pin = MockPin


class MockWifiService:
    """Mock WifiService for testing."""

    wifi_busy = False
    _connected = False
    _temporarily_disabled = False

    @classmethod
    def is_connected(cls):
        return cls._connected

    @classmethod
    def disconnect(cls):
        cls._connected = False

    @classmethod
    def temporarily_disable(cls):
        """Temporarily disable WiFi and return whether it was connected."""
        if cls.wifi_busy:
            raise RuntimeError("Cannot disable WiFi: WifiService is already busy")
        was_connected = cls._connected
        cls.wifi_busy = True
        cls._connected = False
        cls._temporarily_disabled = True
        return was_connected

    @classmethod
    def temporarily_enable(cls, was_connected):
        """Re-enable WiFi and reconnect if it was connected before."""
        cls.wifi_busy = False
        cls._temporarily_disabled = False
        if was_connected:
            cls._connected = True

    @classmethod
    def reset(cls):
        """Test helper to reset state."""
        cls.wifi_busy = False
        cls._connected = False
        cls._temporarily_disabled = False


class MockI2C:
    """Mock I2C bus for testing."""

    def __init__(self, bus_id, sda=None, scl=None):
        self.bus_id = bus_id
        self.sda = sda
        self.scl = scl
        self.memory = {}

    def readfrom_mem(self, addr, reg, nbytes):
        """Read from memory (simulates I2C read)."""
        if addr not in self.memory:
            raise OSError("I2C device not found")
        if reg not in self.memory[addr]:
            return bytes([0] * nbytes)
        return bytes(self.memory[addr][reg])

    def writeto_mem(self, addr, reg, data):
        """Write to memory (simulates I2C write)."""
        if addr not in self.memory:
            self.memory[addr] = {}
        self.memory[addr][reg] = list(data)


class MockQMI8658:
    """Mock QMI8658 IMU sensor."""

    def __init__(self, i2c_bus, address=0x6B, accel_scale=0b10, gyro_scale=0b100):
        self.i2c = i2c_bus
        self.address = address
        self.accel_scale = accel_scale
        self.gyro_scale = gyro_scale

    @property
    def temperature(self):
        """Return mock temperature."""
        return 25.5

    @property
    def acceleration(self):
        """Return mock acceleration (in G)."""
        return (0.0, 0.0, 1.0)

    @property
    def gyro(self):
        """Return mock gyroscope (in deg/s)."""
        return (0.0, 0.0, 0.0)


class MockWsenIsds:
    """Mock WSEN_ISDS IMU sensor."""

    def __init__(self, i2c, address=0x6B, acc_range="8g", acc_data_rate="104Hz",
                 gyro_range="500dps", gyro_data_rate="104Hz"):
        self.i2c = i2c
        self.address = address
        self.acc_range = acc_range
        self.gyro_range = gyro_range
        self.acc_sensitivity = 0.244
        self.gyro_sensitivity = 17.5
        self.acc_offset_x = 0
        self.acc_offset_y = 0
        self.acc_offset_z = 0
        self.gyro_offset_x = 0
        self.gyro_offset_y = 0
        self.gyro_offset_z = 0

    def get_chip_id(self):
        """Return WHO_AM_I value."""
        return 0x6A

    def _read_raw_accelerations(self):
        """Return mock acceleration (in mg)."""
        return (0.0, 0.0, 1000.0)

    def read_angular_velocities(self):
        """Return mock gyroscope (in mdps)."""
        return (0.0, 0.0, 0.0)

    def acc_calibrate(self, samples=None):
        """Mock calibration."""
        pass

    def gyro_calibrate(self, samples=None):
        """Mock calibration."""
        pass


def make_machine_i2c_module(i2c_cls, pin_cls=None):
    if pin_cls is None:
        pin_cls = type("Pin", (), {})
    return type("module", (), {"I2C": i2c_cls, "Pin": pin_cls})()


def make_machine_timer_module(timer_cls):
    return type("module", (), {"Timer": timer_cls})()


def make_usocket_module(socket_cls):
    class MockUsocket:
        """Mock usocket module."""

        AF_INET = socket_cls.AF_INET
        SOCK_STREAM = socket_cls.SOCK_STREAM

        @staticmethod
        def socket(af, sock_type):
            return socket_cls(af, sock_type)

    return MockUsocket


def make_config_module(shared_prefs_cls):
    return type("module", (), {"SharedPreferences": shared_prefs_cls})()