"""Deterministic supervisory-request model. No HVAC, MQTT or HA integration.

All times share one synthetic monotonic clock. source_age is trusted adapter
input, not a value this model can infer from MQTT receipt time. The local
receiver models a lease feature that real products must explicitly support.
"""
from dataclasses import dataclass
import json
import math


@dataclass
class Supervisor:
    ttl: float = 180
    target: float = 22
    half_band: float = 0.3
    last_seq: int = -1
    valid_until: float = -1
    temperature: float | None = None
    demand: bool = False
    enabled: bool = True

    def observe(self, seq, value, received_at, source_age=0, cached=False):
        if cached or seq <= self.last_seq:
            return False
        self.last_seq = seq
        if (not math.isfinite(value) or not math.isfinite(source_age)
                or source_age < 0 or source_age >= self.ttl):
            self.temperature = None
            self.valid_until = -1
            return False
        self.temperature = value
        self.valid_until = received_at + self.ttl - source_age
        return True

    def decide(self, now):
        if not self.enabled or self.temperature is None or now >= self.valid_until:
            self.demand = False
        elif self.temperature <= self.target - self.half_band:
            self.demand = True
        elif self.temperature >= self.target + self.half_band:
            self.demand = False
        return self.demand

    def lease_deadline(self, now, lease_seconds=90):
        if lease_seconds <= 0:
            raise ValueError('Lease must be positive')
        return min(now + lease_seconds, self.valid_until) if self.decide(now) else now


@dataclass
class LocalReceiver:
    deadline: float = -1

    def receive(self, deadline):
        self.deadline = deadline

    def boosted(self, now):
        return now < self.deadline


def run_checks():
    results = {}
    s = Supervisor()
    for seq, now in enumerate((0, 60, 120)):
        assert s.observe(seq, 20, now)
    assert s.decide(250)
    assert not s.decide(300)
    results['same_value_fresh_reports'] = {'demand_at_250': True, 'demand_at_300': False}

    s = Supervisor()
    s.observe(1, 20, 0)
    assert not s.observe(1, 20, 170, cached=True)
    assert not s.decide(180)
    results['cached_rewrite_does_not_extend'] = True

    s = Supervisor()
    s.observe(2, 23, 10)
    assert not s.observe(1, 20, 20)
    assert not s.decide(20)
    results['old_sequence_rejected'] = True

    s = Supervisor()
    assert s.observe(1, 20, 100, source_age=120)
    assert s.valid_until == 160 and not s.decide(160)
    results['delayed_sample_deadline'] = 160

    for value, age in [(float('nan'), 0), (float('inf'), 0), (20, -1), (20, 180)]:
        s = Supervisor()
        assert not s.observe(1, value, 0, age)
        assert not s.decide(0)
    results['invalid_or_expired_samples_blocked'] = True

    s = Supervisor()
    decisions = []
    temperatures = [21.6, 21.9, 22.1, 21.9, 22.3, 22.1]
    for seq, value in enumerate(temperatures):
        s.observe(seq, value, seq * 10)
        decisions.append(s.decide(seq * 10))
    assert decisions == [True, True, True, True, False, False]
    results['hysteresis_decisions'] = decisions

    s = Supervisor()
    s.observe(1, 20, 0)
    assert s.decide(0)
    s.enabled = False
    assert not s.decide(1)
    s.observe(2, 20, 2)
    assert not s.decide(2)
    results['manual_disable_survives_new_report'] = True

    restarted = Supervisor()
    assert not restarted.decide(0)
    assert not restarted.observe(1, 20, 0, cached=True)
    assert not restarted.decide(1)
    results['restart_requires_new_observation'] = True

    s = Supervisor()
    s.observe(1, 20, 0)
    sink = LocalReceiver()
    sink.receive(s.lease_deadline(0))
    assert sink.boosted(89) and not sink.boosted(90)
    results['host_stops_after_issue_local_expiry'] = 90

    sink.receive(s.lease_deadline(170))
    assert sink.deadline == 180 and not sink.boosted(180)
    results['renewal_capped_by_sample_expiry'] = 180

    return {'evidence_type': 'Synthetic software state-machine checks; no hardware or thermal simulation',
            'scenario_groups': len(results), 'results': results,
            'not_tested': ['packet delivery or reordering at actuator', 'actual device lease support',
                           'thermal inertia', 'energy use', 'electrical or frost protection']}


if __name__ == '__main__':
    print(json.dumps(run_checks(), indent=2))
