"""Tests for Samsung EHS (Eco Heating System) heat pump support
(TP1X_DA_AC_EHS_01001_0000).

HA-free like the rest of the suite: exercises the registry, discovery/
flatten, and the zone/dhw mode and temperature write contracts.
"""
from custom_components.localthings.registry.adapter import flatten
from custom_components.localthings.registry.by_type import for_device_by_model
from custom_components.localthings.registry.discovery import discover
from custom_components.localthings.registry.entities import NumberDesc, SelectDesc, WaterHeaterDesc

from tests.conftest import _load_device


def _ehs():
    resources = _load_device('ehs')
    info = resources['/information/vs/0']
    reg = for_device_by_model(
        info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'],
    )
    return reg, resources


def _bound():
    reg, resources = _ehs()
    return discover(resources, reg.capabilities, reg.pattern_capabilities), resources


def _state():
    bound, resources = _bound()
    return flatten(bound, resources)


def _desc(key):
    bound, _ = _bound()
    return next(b.desc for b in bound if b.desc.key == key)


def test_model_resolves_to_ehs_registry():
    reg, _ = _ehs()
    assert reg is not None and reg.name == 'ehs'


def test_no_unbound_hrefs():
    """Every resource in the real TP1X_DA_AC_EHS_01001_0000 dump binds or is
    covered -- clears the coverage-gap repair a device_type='unknown' entry
    raises."""
    reg, resources = _ehs()
    unbound = []
    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
    assert unbound == []


def test_expected_state_keys_present():
    state = _state()
    for key in ('zone_power', 'zone_mode', 'zone_temperature', 'zone_target_temperature',
                'water_heater', 'away_mode', 'mute_once', 'alarm_code', 'energy_kwh'):
        assert key in state, key


def test_zone_temperature_reads_current_value():
    state = _state()
    assert state['zone_temperature'] == 30.0


def test_zone_target_temperature_reads_desired_value():
    state = _state()
    assert state['zone_target_temperature'] == 5.0


def test_zone_mode_reads_first_mode():
    state = _state()
    assert state['zone_mode'] == 'Cool'


def test_zone_mode_select_options_come_from_live_supported_modes():
    """Options are read live from x.com.samsung.da.supportedModes, not a
    hardcoded tuple -- so a future firmware with a different mode set is
    handled automatically."""
    desc = _desc('zone_mode')
    assert isinstance(desc, SelectDesc)
    assert desc.options_field == 'x.com.samsung.da.supportedModes'
    assert desc.options == ()


def test_zone_mode_write_contract():
    desc = _desc('zone_mode')
    path, body = desc.write_fn('Heat', {})
    assert path == ['mode', 'vs', '0']
    assert body == {'x.com.samsung.da.modes': ['Heat']}


def test_zone_power_reads_off():
    state = _state()
    assert state['zone_power'] is False


def test_zone_power_write_contract():
    desc = _desc('zone_power')
    path, body = desc.write_fn('On', {})
    assert path == ['power', 'vs', '0']
    assert body == {'x.com.samsung.da.power': 'On'}


def test_zone_target_temperature_write_contract():
    desc = _desc('zone_target_temperature')
    assert isinstance(desc, NumberDesc)
    path, body = desc.write_fn('21.5', {})
    assert path == ['temperatures', 'indoor', 'vs', '0']
    assert body == {'x.com.samsung.da.desired': '21.5'}


def test_zone_target_temperature_bounds_read_live():
    """min/max/step come from the device's own resource fields rather than
    a hardcoded constant -- see the adding-device-support skill's 'never
    hard-code the one dump's values' section."""
    desc = _desc('zone_target_temperature')
    rep = {'x.com.samsung.da.minimum': '5.0', 'x.com.samsung.da.maximum': '25.0'}
    assert desc.native_min_fn(rep) == 5.0
    assert desc.native_max_fn(rep) == 25.0
    assert desc.step_fn({'x.com.samsung.da.increment': '0.5'}) == 0.5
    # No live field: falls back to a sane default rather than raising.
    assert desc.native_min_fn({}) == 5.0
    assert desc.native_max_fn({}) == 30.0
    assert desc.step_fn({}) == 0.5


def test_zone_target_temperature_bounds_fall_back_together():
    """One end without the other is not a usable range: pairing a real
    device minimum with an invented default maximum looks plausible and is
    silently wrong, so a half-reported range falls back whole."""
    desc = _desc('zone_target_temperature')
    half = {'x.com.samsung.da.minimum': '10.0'}
    assert desc.native_min_fn(half) == 5.0
    assert desc.native_max_fn(half) == 30.0


def test_zone_target_temperature_zero_increment_is_not_collapsed():
    """`or` would turn a genuine 0 into the 0.5 default (issue #160)."""
    desc = _desc('zone_target_temperature')
    assert desc.step_fn({'x.com.samsung.da.increment': '0'}) == 0.0


def test_water_heater_entity_is_bound():
    """The composite water_heater entity binds the primary /mode/dhw/vs/0
    resource -- same primary-plus-siblings shape as the AC's ClimateDesc
    (see test_airconditioner_capabilities.py's test_climate_entity_is_bound)."""
    bound, _ = _bound()
    water_heaters = [b for b in bound if isinstance(b.desc, WaterHeaterDesc)]
    assert len(water_heaters) == 1
    assert water_heaters[0].href == '/mode/dhw/vs/0'


def test_water_heater_reads_first_mode():
    """The flattened/golden state exposes the same representative scalar
    the entity's current_operation is derived from -- see climate.py's
    _first_mode for the identical pattern on the AC side."""
    state = _state()
    assert state['water_heater'] == 'Eco'


def test_water_heater_write_targets():
    """DHW.entities[0].write_fn maps each (kind, value) command to the right
    vendor POST target and body -- power, mode and temperature only, no fan/
    swing/preset (the AC's climate.py has those; the DHW loop doesn't)."""
    write = _desc('water_heater').write_fn
    assert write(('power', True), {}) == (
        ['power', 'dhw', 'vs', '0'], {'x.com.samsung.da.power': 'On'})
    assert write(('power', False), {}) == (
        ['power', 'dhw', 'vs', '0'], {'x.com.samsung.da.power': 'Off'})
    assert write(('mode', 'Force'), {}) == (
        ['mode', 'dhw', 'vs', '0'], {'x.com.samsung.da.modes': ['Force']})
    assert write(('temperature', 45.0), {}) == (
        ['temperatures', 'dhw', 'vs', '0'], {'x.com.samsung.da.desired': '45.0'})
    assert write(('bogus', 1), {}) is None


def test_dhw_power_and_temperature_declared_as_coverage():
    """/power/dhw/vs/0 and /temperatures/dhw/vs/0 are read by the composite
    water_heater entity (via water_heater.py's sibling reads), not given
    their own entities -- declared as no-entity coverage caps so discover()
    reports no gap, same pattern as the AC's CLIMATE_CONSUMED_HREFS."""
    reg, _ = _ehs()
    for href in ('/power/dhw/vs/0', '/temperatures/dhw/vs/0'):
        caps = reg.capabilities.get(href)
        assert caps, href
        assert all(c.entities == () for c in caps), href


def test_away_mode_reads_off():
    state = _state()
    assert state['away_mode'] is False


def test_away_mode_write_contract():
    desc = _desc('away_mode')
    path, body = desc.write_fn('On', {})
    assert path == ['option', 'outgoing', 'vs', '0']
    assert body == {'x.com.samsung.da.away': 'On'}