From de095adbad13cdcd5fc0c50a1492e613b39bb7c3 Mon Sep 17 00:00:00 2001
From: Laurent <laurent0206.cr@gmail.com>
Date: Tue, 30 Dec 2025 19:48:19 +0100
Subject: [PATCH] Fix clock

---
 rpi/models/clock.py | 59 ++++++++++++++++++---------------------------
 1 file changed, 24 insertions(+), 35 deletions(-)

diff --git a/rpi/models/clock.py b/rpi/models/clock.py
index 63fef385..da0b5977 100644
--- a/rpi/models/clock.py
+++ b/rpi/models/clock.py
@@ -1,17 +1,9 @@
 import threading
 import time
-from datetime import datetime
 from typing import Callable
 
 
 class Clock:
-
-    millis : int
-    increment : int
-
-    on_update : Callable[[str], None]
-    on_terminated : Callable[[], None]
-
     def __init__(self, value: int, increment: int) -> None:
         self.millis = value * 1000
         self.increment = increment * 1000
@@ -20,7 +12,13 @@ class Clock:
         self._terminate_event = threading.Event()
         self._lock = threading.Lock()
 
-        self.thread = threading.Thread(target=self._update_clock, daemon=True)
+        self.on_update: Callable[[str], None] = lambda _: None
+        self.on_terminated: Callable[[], None] = lambda: None
+
+        self.thread = threading.Thread(
+            target=self._update_clock,
+            daemon=True
+        )
 
     def _compute_seconds(self) -> int:
         return (self.millis // 1000) % 60
@@ -32,43 +30,36 @@ class Clock:
         self.millis += self.increment
 
     def _update_clock(self):
-        while not self._terminate_event.is_set():
+        while not self._terminate_event.is_set() and self.millis > 0:
             self._run_event.wait()
-
+            time.sleep(1)
             with self._lock:
-                if self.millis <= 0:
+                self.millis -= 1000
+                if self.millis < 0:
                     self.millis = 0
-                    self._run_event.clear()
-                    self.__notify_update()
-                    break
+            self._notify_update()
 
-                self.millis -= 1
-                if self.millis % 1000 == 0:
-                    self.__notify_update()
+        self._notify_terminated()
 
-            time.sleep(0.001)
-
-    def __notify_update(self):
-        print(self.clock_to_str())
+    def _notify_update(self) -> None:
         self.on_update(self.clock_to_str())
 
-    def __notify_terminated(self):
+    def _notify_terminated(self) -> None:
         self.on_terminated()
 
-    def set_on_update(self, callback : Callable[[str], None]):
+    def set_on_update(self, callback: Callable[[str], None]) -> None:
         self.on_update = callback
 
-    def set_on_terminated(self, callback: Callable[[], None]):
+    def set_on_terminated(self, callback: Callable[[], None]) -> None:
         self.on_terminated = callback
 
     def is_running(self) -> bool:
         return self._run_event.is_set()
 
     def start(self) -> None:
-        self._run_event.set()
         if not self.thread.is_alive():
-            self.thread = threading.Thread(target=self._update_clock, daemon=True)
             self.thread.start()
+        self._run_event.set()
 
     def stop(self) -> None:
         if self._run_event.is_set():
@@ -76,21 +67,19 @@ class Clock:
                 self._add_increment()
             self._run_event.clear()
 
-    def terminate(self) -> None:
-        self._terminate_event.set()
-        self._run_event.set()
-        self.thread.join()
-
     def clock_to_str(self) -> str:
         with self._lock:
             minutes = self._compute_minutes()
             seconds = self._compute_seconds()
         return f"{minutes:02d}:{seconds:02d}"
 
-
 if __name__ == "__main__":
+    def display(content):
+        print(content)
+
     clock = Clock(600, 0)
     clock.start()
+    clock.set_on_update(display)
+
     while True:
-        time.sleep(1)
-        print(clock.clock_to_str())
\ No newline at end of file
+        pass