gpymusic2/tuijam

#!/usr/bin/env python3
import urwid
import gmusicapi


class MusicObject:
    @staticmethod
    def to_ui(*txts):
        first, *rest = [str(txt) for txt in txts]
        items = [urwid.SelectableIcon(first, 0)]
        for line in rest:
            items.append(urwid.Text(line))
        line = urwid.Columns(items)
        line = urwid.AttrMap(line, 'search normal', 'search select')
        return line

    @staticmethod
    def header_ui(*txts):
        header = urwid.Columns([('weight', 1, urwid.Text(('header', txt)))
                                for txt in txts])
        return urwid.AttrMap(header, 'header_bg')


class Song(MusicObject):
    def __init__(self, title, album, albumId, artist, id_):
        self.title = title
        self.album = album
        self.albumId = albumId
        self.artist = artist
        self.id = id_

    def __repr__(self):
        return f'<Song title:{self.title}, album:{self.album}, artist:{self.artist}>'

    def __str__(self):
        return f'{self.title} by {self.artist}'

    def ui(self):
        return self.to_ui(self.title, self.album, self.artist)

    @staticmethod
    def header():
        return MusicObject.header_ui('Title', 'Album', 'Artist')

    @staticmethod
    def from_dict(d):
        title = d['title']
        album = d['album']
        albumId = d['albumId']
        artist = d['artist']
        try:
            id_ = d['id']
        except KeyError:
            id_ = d['storeId']
        return Song(title, album, albumId, artist, id_)


class Album(MusicObject):
    def __init__(self, title, artist, year, id_):
        self.title = title
        self.artist = artist
        self.year = year
        self.id = id_

    def __repr__(self):
        return f'<Album title:{self.title}, artist:{self.artist}, year:{self.year}>'

    def ui(self):
        return self.to_ui(self.title, self.artist, self.year)

    @staticmethod
    def header():
        return MusicObject.header_ui('Album', 'Artist', 'Year')

    @staticmethod
    def from_dict(d):
        title = d['name']
        artist = d['albumArtist']
        year = d['year']
        id_ = d['albumId']
        return Album(title, artist, year, id_)


class Artist(MusicObject):
    def __init__(self, name, id_):
        self.name = name
        self.id = id_

    def __repr__(self):
        return f'<Artist name:{self.name}>'

    def ui(self):
        return self.to_ui(self.name)

    @staticmethod
    def header():
        return MusicObject.header_ui('Artist')

    @staticmethod
    def from_dict(d):
        name = d['name']
        id_ = d['artistId']
        return Artist(name, id_)


class CommandInput(urwid.Edit):
    def __init__(self, app):
        self.app = app
        super().__init__('search > ', multiline=False, allow_tab=False)

    def keypress(self, size, key):
        if key == 'enter':
            txt = self.edit_text
            if txt:
                self.set_edit_text('')
                self.app.search(txt)
            return None
        else:
            size = (size[0],)
            return super().keypress(size, key)


class SearchPanel(urwid.ListBox):
    def __init__(self, app):
        self.app = app
        self.walker = urwid.SimpleFocusListWalker([])
        super().__init__(self.walker)

    def keypress(self, size, key):
        if key == 'q':
            selected = self.selected_search_obj()
            if selected and type(selected) in (Song, Album):
                self.app.queue_panel.add_to_queue(selected)
        elif key == 'e':
            self.app.expand(self.selected_search_obj())
        elif key == 'j':
            super().keypress(size, 'down')
        elif key == 'k':
            super().keypress(size, 'up')
        else:
            super().keypress(size, key)

    def set_search_results(self, search_results):
        self.search_results = search_results
        songs, albums, artists = search_results

        self.walker.clear()

        if songs:
            self.walker.append(Song.header())
        for song in songs:
            self.walker.append(song.ui())

        if albums:
            self.walker.append(Album.header())
        for album in albums:
            self.walker.append(album.ui())

        if artists:
            self.walker.append(Artist.header())
        for artist in artists:
            self.walker.append(artist.ui())

        if self.walker:
            self.walker.set_focus(1)

    def selected_search_obj(self):
        focus_id = self.walker.get_focus()[1]
        songs, albums, artists = self.search_results

        try:
            focus_id -= 1
            if focus_id < len(songs):
                return songs[focus_id]
            focus_id -= (1 + len(songs))
            if focus_id < len(albums):
                return albums[focus_id]
            focus_id -= (1 + len(albums))
            return artists[focus_id]
        except IndexError:
            return None


class QueuePanel(urwid.ListBox):
    def __init__(self, app):
        self.app = app
        self.walker = urwid.SimpleFocusListWalker([])
        self.queue = []
        super().__init__(self.walker)

    def add_to_queue(self, music_obj):
        # assume Song for now
        self.queue.append(music_obj)
        self.walker.append(music_obj.ui())

    def drop(self, idx):
        if 0 <= idx < len(self.queue):
            self.queue.pop(idx)
            self.walker.pop(idx)

    def swap(self, idx1, idx2):
        if (0 <= idx1 < len(self.queue)) and (0 <= idx2 < len(self.queue)):
            obj1, obj2 = self.queue[idx1], self.queue[idx2]
            self.queue[idx1], self.queue[idx2] = obj2, obj1

            ui1, ui2 = self.walker[idx1], self.walker[idx2]
            self.walker[idx1], self.walker[idx2] = ui2, ui1

    def play_next(self):
        if self.walker:
            self.walker.pop(0)
            self.app.play(self.queue.pop(0))

    def keypress(self, size, key):
        focus_id = self.walker.get_focus()[1]
        if focus_id is None:
            return super().keypress(size, key)

        if key == 'u':
            self.swap(focus_id, focus_id-1)
            self.keypress(size, 'up')
        elif key == 'd':
            self.swap(focus_id, focus_id+1)
            self.keypress(size, 'down')
        elif key == 'delete':
            self.drop(focus_id)
        elif key == 'j':
            super().keypress(size, 'down')
        elif key == 'k':
            super().keypress(size, 'up')
        elif key == ' ':
            if self.app.play_state == 'stop':
                self.play_next()
            else:
                self.app.toggle_play()
        else:
            return super().keypress(size, key)


class App(urwid.Pile):

    palette = [
        ('header', 'white,underline', 'black'),
        ('header_bg', 'white', 'black'),
        ('line', 'white', ''),
        ('search normal', 'white', ''),
        ('search select', 'white', 'dark red'),

        ('region_bg normal', '', ''),
        ('region_bg select', '', 'black'),
    ]

    def __init__(self):

        self.read_config()

        self.g_api = gmusicapi.Mobileclient()
        self.g_api.login(self.email, self.password, self.device_id)

        import mpv
        self.player = mpv.MPV()

        @self.player.event_callback('end_file')
        def callback(event):
            if event['event']['reason'] == 0:
                self.queue_panel.play_next()

        self.search_panel = SearchPanel(self)
        search_panel_wrapped = urwid.LineBox(self.search_panel, title='Search Results')
        search_panel_wrapped = urwid.AttrMap(search_panel_wrapped, 'region_bg normal', 'region_bg select')
        self.search_panel_wrapped = search_panel_wrapped

        self.now_playing = urwid.Text('')
        self.progress = urwid.Text('0:00/0:00', align='right')
        status_line = urwid.Columns([('weight', 3, self.now_playing),
                                     ('weight', 1, self.progress)])

        self.queue_panel = QueuePanel(self)
        queue_panel_wrapped = urwid.LineBox(self.queue_panel, title='Queue')
        queue_panel_wrapped = urwid.AttrMap(queue_panel_wrapped, 'region_bg normal', 'region_bg select')
        self.queue_panel_wrapped = queue_panel_wrapped

        self.command_input = urwid.Edit('> ', multiline=False)
        self.command_input = CommandInput(self)

        urwid.Pile.__init__(self, [('weight', 12, search_panel_wrapped),
                                   ('pack', status_line),
                                   ('weight', 7, queue_panel_wrapped),
                                   ('pack', self.command_input)
                                   ])
        self.set_focus(self.command_input)

        self.play_state = 'stop'
        self.current_song = None

    def read_config(self):
        from os.path import join, expanduser
        import yaml
        config_file = join(expanduser('~'), '.config', 'tuijam', 'config.yaml')
        with open(config_file) as f:
            config = yaml.load(f.read())
            self.email = config['email']
            self.password = config['password']
            self.device_id = config['device_id']

    @staticmethod
    def sec_to_min_sec(sec_tot):
        if sec_tot is None:
            return 0, 0
        else:
            min_ = int(sec_tot // 60)
            sec = int(sec_tot % 60)
            return min_, sec

    def update_progress(self):
        curr_time_s = self.player.time_pos
        rem_time_s = self.player.time_remaining
        if curr_time_s is not None and rem_time_s is not None:
            curr_time = self.sec_to_min_sec(curr_time_s)
            total_time = self.sec_to_min_sec(curr_time_s+rem_time_s)
        else:
            curr_time = (0, 0)
            total_time = (0, 0)
        self.progress.set_text(f'{curr_time[0]}:{curr_time[1]:02d}/{total_time[0]}:{total_time[1]:02d}')

    def update_now_playing(self):
        msg = str(self.player.playlist)
        msg = ''
        if self.play_state == 'play':
            self.update_progress()
            self.now_playing.set_text(f'Now Playing: {str(self.current_song)}, {msg}')
            self.schedule_refresh()
        elif self.play_state == 'pause':
            self.update_progress()
            self.now_playing.set_text(f'Paused: {str(self.current_song)}, {msg}')
        else:
            self.now_playing.set_text('')

    def refresh(self, *args, **kwargs):
        if self.play_state == 'play' and self.player.eof_reached:
            self.queue_panel.play_next()
        self.update_now_playing()

    def schedule_refresh(self, dt=0.2):
        self.loop.set_alarm_in(dt, self.refresh)

    def play(self, song):
        self.current_song = song
        url = self.g_api.get_stream_url(song.id)
        self.player.play(url)
        self.play_state = 'play'
        self.update_now_playing()
        self.schedule_refresh()

    def stop(self, song):
        self.current_song = None
        self.player.quit()
        self.play_state = 'stop'
        self.update_now_playing()

    def seek(self, dt):
        try:
            self.player.seek(dt)
        except SystemError:
            pass

    def toggle_play(self):
        if self.play_state == 'play':
            self.player.pause = True
            self.play_state = 'pause'
            self.update_now_playing()
        elif self.play_state == 'pause':
            self.player.pause = False
            self.play_state = 'play'
            self.update_now_playing()
            self.schedule_refresh()

    def keypress(self, size, key):
        if key == 'tab':
            current_focus = self.focus
            if current_focus == self.search_panel_wrapped:
                self.set_focus(self.queue_panel_wrapped)
            elif current_focus == self.queue_panel_wrapped:
                self.set_focus(self.command_input)
            else:
                self.set_focus(self.search_panel_wrapped)
        elif key == 'shift tab':
            current_focus = self.focus
            if current_focus == self.search_panel_wrapped:
                self.set_focus(self.command_input)
            elif current_focus == self.queue_panel_wrapped:
                self.set_focus(self.search_panel_wrapped)
            else:
                self.set_focus(self.queue_panel_wrapped)
        elif key == 'ctrl p':
            self.toggle_play()
        elif key == 'ctrl q':
            self.stop()
        elif key == '>':
            self.seek(10)
        elif key == '<':
            self.seek(-10)
        elif key == 'ctrl n':
            self.queue_panel.play_next()
        else:
            return self.focus.keypress(size, key)

    def expand(self, obj):
        if type(obj) == Song:
            # TODO: Expand Song (probably just album?)
            pass
        elif type(obj) == Album:
            album_info = self.g_api.get_album_info(obj.id)

            songs = []
            for track in album_info['tracks']:
                song = Song.from_dict(track)
                songs.append(song)
            self.search_panel.set_search_results((songs, [], []))
        else:  # Artist
            # TODO: Expand Artist (top songs/albums etc)
            pass

    def search(self, query):

        results = self.g_api.search(query)

        songs = []
        for hit in results['song_hits']:
            song = Song.from_dict(hit['track'])
            songs.append(song)

        albums = []
        for hit in results['album_hits']:
            album = Album.from_dict(hit['album'])
            albums.append(album)

        artists = []
        for hit in results['artist_hits']:
            artist = Artist.from_dict(hit['artist'])
            albums.append(artist)

        self.search_panel.set_search_results((songs, albums, artists))
        self.set_focus(self.search_panel_wrapped)

    def cleanup(self):
        self.player.quit()
        del self.player
        self.g_api.logout()


if __name__ == '__main__':
    app = App()

    import signal

    def handle_sigint(signum, frame):
        raise urwid.ExitMainLoop()
    signal.signal(signal.SIGINT, handle_sigint)

    loop = urwid.MainLoop(app, app.palette, pop_ups=True)
    app.loop = loop
    loop.run()
    app.cleanup()