import json
from typing import Callable

from hardware.buzzer.buzzer import Buzzer
from hardware.led.led import Led
from models.exceptions.ServiceException import ServiceException
from models.game import Game
from services.clock_service import ClockService
from services.detection_service import DetectionService


class GameService:

    _game : Game
    _detection_service : DetectionService
    _clock_service : ClockService
    _has_started : bool
    _led : Led
    _buzzer : Buzzer
    _on_terminated : Callable[[str], None]

    def __init__(self):
        self._detection_service = DetectionService()
        self._clock_service = ClockService()
        self._has_started = False
        self._led = Led(7)
        self._buzzer = Buzzer(8)

    def start(self, white_name, back_name, time_control : int, increment : int, timestamp : int) -> None:
        if self._has_started :
            raise ServiceException("Game has already started.")
        try :
            self._game = Game(white_name, back_name, time_control, increment, timestamp)
            self._clock_service.start(time_control, increment)
            self._clock_service.set_on_terminated(self.stop)
            self._led.on()
            self._has_started = True
        except Exception as e:
            print(e)
            raise ServiceException(e)

    def stop(self):
        self._clock_service.stop()
        self._detection_service.stop()
        self._led.off()
        self._notify()
        self._has_started = False

    def make_move(self) -> tuple[bytes, str] | None:
        try :
            if not self._has_started :
                raise Exception("Game hasn't started yet.")
            self._clock_service.switch()
            img, fen = self._detection_service.analyze_single_frame()
            self._game.add_move(fen)
            return img, fen
        except Exception as e:
            print(e)
            raise ServiceException(e)

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

    def _notify(self):
        game_data = json.dumps(self._game.to_dict())
        self._on_terminated(game_data)