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 for start...")

    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:
        if self.white_clock.is_running() :
            self.__update_screen(f"W {formatted_time} \n B {self.black_clock.clock_to_str()}")
        elif self.black_clock.is_running() :
            self.__update_screen(f"W {self.white_clock.clock_to_str()} \n B {formatted_time}")

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

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