#!/usr/bin/env python3
"""Die Kilometer, die der Dongle am Anfang einer Fahrt verschlaeft.

Der FMM003 kommt aus dem Deep Sleep nur ueber seinen Beschleunigungssensor
hoch: die eingestellte Zuendungsquelle ist die Motordrehzahl, die liegt am CAN,
und CAN ist im Schlaf abgeschaltet. Gemessene Weckzeiten am 31.08. bis
05.09.2026: 28 s, 144 s, 182 s, 484 s, 543 s, 632 s, 1131 s, 1170 s.

Die Zahlen hier sind gemessen, nicht erfunden - Rueckfahrt Eichstaett -
Adelschlag am 05.09.2026: Motorstart 23:04:16 (aus der Motorlaufzeit 543 s im
ersten Datensatz), erster Datensatz aber erst 23:13:19. Der Tacho stand vorher
auf 21347 und im ersten Datensatz danach bereits auf 21353.

Aufruf: python3 tests/verlauf/test_aufzeichnungsluecke.py
"""

import os
import sys
import unittest

_HIER = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.dirname(os.path.dirname(_HIER)))

from custom_components.audi_dashboard import verlauf as v  # noqa: E402


class Luecke(unittest.TestCase):
    def test_echter_fall_vom_05_09(self):
        """21347 am Ende der Hinfahrt, 21353 im ersten Datensatz der Rueckfahrt."""
        self.assertEqual(v.aufzeichnungsluecke_km(21347.0, 21353.0), 6.0)

    def test_keine_luecke_ist_none(self):
        """Der Normalfall: die Rueckfahrt beginnt, wo die Hinfahrt endete."""
        self.assertIsNone(v.aufzeichnungsluecke_km(21347.0, 21347.0))

    def test_rueckwaerts_ist_keine_luecke(self):
        """Ein niedrigerer Start ist ein Fahrzeugwechsel des Geraets oder ein
        Ausreisser - jedenfalls keine verschlafene Strecke. _vollstaendig()
        faengt den Fall an anderer Stelle ab; hier darf er nur nicht als
        Luecke durchgehen."""
        self.assertIsNone(v.aufzeichnungsluecke_km(21353.0, 21347.0))

    def test_unbekannte_werte(self):
        self.assertIsNone(v.aufzeichnungsluecke_km(None, 21353.0))
        self.assertIsNone(v.aufzeichnungsluecke_km(21347.0, None))
        self.assertIsNone(v.aufzeichnungsluecke_km(None, None))


class Zerlegung(unittest.TestCase):
    """Verschlafener Anfang in ganzen Kilometern, aufgezeichneter Rest
    metergenau - und die Summe muss den Tacho-Anker weiterhin bestehen.

    Ohne die Zerlegung waere die feine Zahl allein systematisch zu klein, und
    bei einer kleinen Luecke laege sie sogar noch innerhalb der Toleranz und
    kassierte die gerade erst geholte Strecke wieder ein. Genau das soll hier
    nicht passieren."""

    def test_summe_wird_genommen(self):
        """6 km verschlafen, 1,428 km aufgezeichnet, Tacho sagt 7 km."""
        fein = round(1.428 + 6.0, 3)
        gewaehlt, genommen = v.strecke_waehlen(7.0, fein)
        self.assertTrue(genommen)
        self.assertEqual(gewaehlt, 7.428)

    def test_ohne_zerlegung_wuerde_der_tacho_gewinnen(self):
        """Zur Abgrenzung: die feine Zahl allein liegt 5,57 km daneben und
        wird verworfen - die Fahrt bekaeme 7 statt 7,428 km."""
        gewaehlt, genommen = v.strecke_waehlen(7.0, 1.428)
        self.assertFalse(genommen)
        self.assertEqual(gewaehlt, 7.0)

    def test_kleine_luecke_ist_der_gefaehrliche_fall(self):
        """Eine Luecke von 1 km: die feine Zahl allein (5,1 gegen 6) laege
        INNERHALB der Toleranz und wuerde stillschweigend gewinnen - 0,9 km
        weniger, ohne dass es jemand merkt. Mit Zerlegung stimmt es."""
        ohne, genommen_ohne = v.strecke_waehlen(6.0, 5.1)
        self.assertTrue(genommen_ohne, "ohne Zerlegung schluepft der Fehler durch")
        self.assertEqual(ohne, 5.1)

        mit, genommen_mit = v.strecke_waehlen(6.0, round(5.1 + 1.0, 3))
        self.assertTrue(genommen_mit)
        self.assertEqual(mit, 6.1)


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