import asyncio
from threading import Thread
import logging
import time


class SessionPlaybackStatus:

    Changing: 2 # Das Medium ändert sich.
    Closed:	0	# Das Medium ist geschlossen.
    Opened:	1   # Das Medium wird geöffnet.
    Paused:	5   # Das Medium wird angehalten.
    Playing: 4	# Die Medien werden abspielt.
    Stopped: 3  # Das Medium wird beendet.



class MediaControl(Thread):

    __init_handler = []
    __session_changed_handler = []
    __running = True

            
    def run(self) -> None:
        from  winrt.windows.media.control import GlobalSystemMediaTransportControlsSessionManager as MediaManager, CurrentSessionChangedEventArgs
       
        self.MediaManager = MediaManager
        # MediaManager.add_current_session_changed(Event)
        for handler in self.__init_handler:
            handler()
        while self.__running:
            time.sleep(1)
        return super().run()

    def __init__(self) -> None:
        super().__init__()

    def __current_session_changed(self, **kwargs):
        print(kwargs)
        for handler in self.__session_changed_handler:
            handler()

    def add_init_handler(self, handler):
        self.__init_handler.append(handler)
    
    # def add_session_changed_handler(self, handler):
    #     self.__session_changed_handler.append(handler)

    def play(self):
        asyncio.run(self.__try_play())

    def pause(self):
        asyncio.run(self.__try_pause())

    def get_media_info(self):
        return asyncio.run(self.__get_media_info())

    def get_playback_info(self):
        return asyncio.run(self.__get_playback_info())
    
    def stop(self):
        self.__running = False

    async def __try_play(self):
        logging.debug("__try_play")
        sessions = await self.MediaManager.request_async()
        current_session = sessions.get_current_session()
        if current_session:
            print("try_play!!!!!!!")
            await current_session.try_play_async()

    async def __try_pause(self):
        logging.debug("__try_pause")
        sessions = await self.MediaManager.request_async()
        current_session = sessions.get_current_session()
        if current_session:
            await current_session.try_pause_async()

    async def __get_media_info(self):
        sessions = await self.MediaManager.request_async()

        current_session = sessions.get_current_session()
        if current_session:  # there needs to be a media session running
            info = await current_session.try_get_media_properties_async()

            # song_attr[0] != '_' ignores system attributes
            info_dict = {song_attr: info.__getattribute__(song_attr) for song_attr in dir(info) if song_attr[0] != '_'}

            # converts winrt vector to list
            info_dict['genres'] = list(info_dict['genres'])

            return info_dict

    async def __get_playback_info(self):
        sessions = await self.MediaManager.request_async()

        current_session = sessions.get_current_session()
        if current_session:  # there needs to be a media session running
            info = current_session.get_playback_info()

            # song_attr[0] != '_' ignores system attributes
            info_dict = {playback_attr: info.__getattribute__(playback_attr) for playback_attr in dir(info) if playback_attr[0] != '_'}

            # converts winrt vector to list
            info_dict['controls'] = {control_attr: info.controls.__getattribute__(control_attr) for control_attr in dir(info.controls) if control_attr[0] != '_'}

            return info_dict

if __name__ == "__main__":
    def handle_init():
        print(mc.get_media_info())
        print(mc.get_playback_info())
        pass

    logging.getLogger().setLevel(logging.DEBUG)
    mc = MediaControl()
    mc.start()
    mc.add_init_handler(handle_init)