# -*- coding: utf-8 -*-
"""
Corrigé Python - Bac NSI 2026 - Épreuve pratique - Sujet 23
Thème : transmission de données environnementales, décodage binaire et robustesse
"""

from __future__ import annotations


class Transmission:
    def __init__(self, trame: str) -> None:
        self._id = None
        self._temperature = None
        self._humidite = None
        self._trame = trame
        self.decoder()

    def __repr__(self) -> str:
        return f"ID : {self._id} / Temp. : {self._temperature}°C / Hum. : {self._humidite}%"

    def _bloc_valide(self, debut: int, fin: int) -> bool:
        bloc = self._trame[debut:fin]
        return len(bloc) == fin - debut and all(bit in "01" for bit in bloc)

    def decoder(self) -> None:
        self.decoder_id()
        self.decoder_temperature()
        self.decoder_humidite()

    def decoder_id(self) -> None:
        if self._bloc_valide(0, 8):
            self._id = int(self._trame[0:8], 2)

    def decoder_temperature(self) -> None:
        """Décode la température : (valeur_binaire - 900) / 10."""
        if not self._bloc_valide(16, 28):
            self._temperature = None
            return
        valeur = int(self._trame[16:28], 2)
        temperature = (valeur - 900) / 10
        if temperature < -10:
            self._temperature = None
        else:
            self._temperature = temperature

    def decoder_humidite(self) -> None:
        """Décode l'humidité codée en BCD, avec le cas particulier 100 %."""
        if not self._bloc_valide(28, 36):
            self._humidite = None
            return
        bloc = self._trame[28:36]
        if bloc == "10100000":
            self._humidite = 100
            return
        dizaine = int(bloc[:4], 2)
        unite = int(bloc[4:], 2)
        if dizaine > 9 or unite > 9:
            self._humidite = None
        else:
            self._humidite = 10 * dizaine + unite

    def get_id(self) -> int | None:
        return self._id

    def get_temperature(self) -> float | None:
        return self._temperature

    def get_humidite(self) -> int | None:
        return self._humidite

    def est_valide(self) -> bool:
        """Vérifie la longueur, les bits, les parités et les valeurs décodées."""
        if len(self._trame) != 40 or any(bit not in "01" for bit in self._trame):
            return False
        if self._temperature is None or self._humidite is None:
            return False

        blocs = [self._trame[0:8], self._trame[8:16], self._trame[16:28], self._trame[28:36]]
        controles = self._trame[36:40]
        for i in range(4):
            parite = sum(int(bit) for bit in blocs[i]) % 2
            if str(parite) != controles[i]:
                return False
        return True


def tests() -> None:
    trame = "0010101011001000010010001100011000101101"
    t = Transmission(trame)
    assert t.get_id() == 42
    assert t.get_temperature() == 26.4
    assert t.get_humidite() == 62
    assert t.est_valide() is True

    trame_fausse = trame[:-1] + ("0" if trame[-1] == "1" else "1")
    assert Transmission(trame_fausse).est_valide() is False
    assert Transmission("101").est_valide() is False
    print("Tous les tests du sujet 23 sont passés.")


if __name__ == "__main__":
    tests()