from typing import Callable

from hardware.screen.screen import Screen
from models.clock import Clock

class ClockService:

    _screen : Screen
    _white_clock : Clock
    _black_clock : Clock

    on_terminated : Callable[[], None]

    def __init__(self):
        self._screen = Screen()
        self._screen.enableBackground()
        self._screen.displayMessage("Waiting...")

    def start(self, time_control : int, increment : int):
        self._white_clock = self.__init_clock(time_control, increment)
        self._black_clock = self.__init_clock(time_control, increment)

        self._white_clock.start()

    def stop(self):
        self._white_clock.stop()
        self._black_clock.stop()

    def switch(self):
        if self._white_clock.is_running():
            self._white_clock.stop()
            self._black_clock.start()

        elif self._black_clock.is_running():
            self._black_clock.stop()
            self._white_clock.start()

    def set_on_terminated(self, callback : Callable[[], None]):
        self.on_terminated = callback

    def __init_clock(self, time_control : int, increment : int) -> Clock:
        clock = Clock(time_control, increment)
        clock.set_on_update(self.__tick)
        clock.set_on_terminated(self.__terminate)
        return clock

    def __tick(self, formatted_time : str) -> None:
        self.__update_screen(f"W {self._white_clock.clock_to_str()} \n B {self._black_clock.clock_to_str()}")

    def __terminate(self) -> None:
        self.__update_screen("Time is over !")
        self.on_terminated()

    def __update_screen(self, message : str) -> None:
        self._screen.displayMessage(message)