import pyogg
import pygame

from gui import Dialogue, Menu
from openal import *
from speech import speak


class SoundManager:
    def __init__(self, sounds_directory="sounds", max_players=10):
        self.sounds_directory = sounds_directory
        self.sounds = {}
        self.listener = Listener()
        self.player_pool = [Player() for _ in range(max_players)]
        self.active_players = []
        print(f"Initialized SoundManager with {max_players} players.")

    def load_sound(self, sound_name, file_name):
        try:
            file_path = f"{self.sounds_directory}/{file_name}"
            vorbis_file = pyogg.VorbisFile(file_path)
            sound_buffer = BufferSound()
            sound_buffer.channels = vorbis_file.channels
            sound_buffer.bitrate = 16
            sound_buffer.samplerate = vorbis_file.frequency
            sound_buffer.load(vorbis_file.buffer)
            self.sounds[sound_name] = sound_buffer
            print(f"Loaded sound: {sound_name} from {file_path}")

        except Exception as e:
            print(f"Error loading sound {sound_name}: {e}")

    def play_sound(self, sound_name):
        if sound_name not in self.sounds:
            print(f"Sound '{sound_name}' not found.")
            return

        if self.player_pool:
            player = self.player_pool.pop(0)
            player.add(self.sounds[sound_name])
            player.play()
            self.active_players.append(player)
            print(f"Playing sound: {sound_name} with player {player}.")
            self.recycle_players()
        else:
            print("No available players in the pool.")

    def recycle_players(self):
        for player in self.active_players[:]:
            if not player.playing():
                player.remove()
                self.player_pool.append(player)
                self.active_players.remove(player)
                print(f"Recycled player {player}.")
            else:
                print(f"Player {player} still playing, not recycled.")

        print(f"Active players: {len(self.active_players)}, Player pool size: {len(self.player_pool)}")

    def cleanup(self):
        for player in self.active_players + self.player_pool:
            player.delete()
            print(f"Deleted player {player}.")
        for sound_name, sound_buffer in self.sounds.items():
            sound_buffer.delete()
            print(f"Deleted sound buffer for sound {sound_name}.")
        self.listener.delete()
        print("Cleaned up SoundManager resources.")

    def load_game_sounds(self):
        for file_name in os.listdir(self.sounds_directory):
            if file_name.endswith(".ogg"):
                sound_name = os.path.splitext(file_name)[0]
                self.load_sound(sound_name, file_name)


class GameState:
    INITIAL_STATE = "MainMenu"

    def __init__(self):
        self.current_state = self.INITIAL_STATE


class GameManager:
    def __init__(self):
        self.game_state = GameState()
        self.dialogue_instance = Dialogue()
        self.menu_instance = None
        self.sound_manager = SoundManager()
        self.sound_manager.load_game_sounds()


    def main_menu(self):
        text = "Choose an option: "
        items = ["Learn game sounds", "Exit"]
        self.menu_instance = Menu(text, items, False)
        result = self.menu_instance.display()

        if result is False:  # Check if the menu returned False (game exit requested)
            return False
        if result == 0:
            self.game_state.current_state = "LearningSounds"
        elif result == 1:
            self.dialogue_instance.dlg("goodbye! Thanks for trying the game. Play again next time")
            return False

        return True

    def learning_sounds(self):
        speak("Press the arrow keys to find out which key generates which tone.")
        speak("Press escape to stop practicing.")
        running = True

        while running:
            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        running = False
                    else:
                        tone_id = self.get_tone_id_from_key(event.key)
                        if tone_id is not None:
                            self.play_tone("tone", tone_id)

        self.game_state.current_state = "MainMenu"

    def get_tone_id_from_key(self, key):
        key_map = {pygame.K_LEFT: 0, pygame.K_DOWN: 1, pygame.K_RIGHT: 2, pygame.K_UP: 3}
        return key_map.get(key)

    def play_tone(self, sound_type, tone_id=None):
        if sound_type == "tone" and tone_id is not None:
            self.sound_manager.play_sound(f"tone{tone_id}")
        elif sound_type == "error":
            self.sound_manager.play_sound("error")
        elif sound_type == "winner":
            self.sound_manager.play_sound("winner")


    def check_state(self):
        if self.game_state.current_state == "MainMenu":
            if not self.main_menu():
                return False  # Exit game loop
        elif self.game_state.current_state == "LearningSounds":
            self.learning_sounds()

        return True  # Continue the game loop


class Game:
    def __init__(self):
        pygame.init()
        self.window_size = (800, 600)
        self.screen = pygame.display.set_mode(self.window_size)
        pygame.display.set_caption("This is a test")
        self.clock = pygame.time.Clock()
        self.fps = 60
        self.manager = GameManager()

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return False  # Indicate to stop the game

        return True

    def game_loop(self):
        continue_game = True
        while continue_game:
            if not pygame.event.peek():  # Check if there are no new events
                pygame.time.delay(10)  # Wait for 10 milliseconds

            continue_game = self.handle_events() and self.manager.check_state()
            if continue_game:
                pygame.display.flip()

            self.clock.tick(self.fps)  # Control the frame rate

        self.manager.sound_manager.cleanup()
        pygame.quit()


if __name__ == "__main__":
    game = Game()
    game.game_loop()