#!/usr/bin/env python3

# A simple graphical menu to control MPRIS-compatible players through Playerctl.
# <https://wiki.archlinux.org/index.php/MPRIS>
# <https://lazka.github.io/pgi-docs/Playerctl-2.0/>
# <https://github.com/altdesktop/playerctl/blob/master/playerctl/playerctl-cli.c>
# TODO: Update the menu on player status changes.

import gi

gi.require_version("Playerctl", "2.0")
gi.require_version("Gtk", "3.0")
from gi.repository import Playerctl, Gtk, Gdk  # noqa: E402


# Larger priority values will make the player with this name appear higher in
# the menu. The default priority is 0.
PLAYER_NAME_PRIORITIES = {
    "audacious": 2,
    "mpv": 1,
    "vlc": 1,
    "firefox": -1,
    "chrome": -2,
    "chromium": -2,
}

PLAYER_ICON_NAME_FIXES = {
    "chrome": "google-chrome",
}


def iter_actions_for_player(player):
    if not player.props.can_control:
        yield ("This player can't be controlled!", None, False, None)
        return

    playback_status = player.props.playback_status
    if playback_status == Playerctl.PlaybackStatus.PLAYING:
        yield (
            "_Pause",
            "media-playback-pause",
            player.props.can_pause,
            player.pause,
        )
    elif playback_status == Playerctl.PlaybackStatus.PAUSED:
        yield (
            "Resume (_P)",
            "media-playback-start",
            player.props.can_play,
            player.play,
        )
    elif playback_status == Playerctl.PlaybackStatus.STOPPED:
        yield (
            "_Play",
            "media-playback-start",
            player.props.can_play,
            player.play,
        )

    # See <https://github.com/altdesktop/playerctl/blob/c83a12a97031f64b260ea7f1be03386c3886b2d4/playerctl/playerctl-cli.c#L231-L235>
    yield (
        "_Stop",
        "media-playback-stop",
        player.props.can_play and playback_status != Playerctl.PlaybackStatus.STOPPED,
        player.stop,
    )

    yield (
        "_Mute" if player.props.volume != 0.0 else "Nor_mal volume",
        "audio-volume-muted" if player.props.volume != 0.0 else "audio-volume-high",
        True,
        lambda volume: player.set_volume(volume),
        0.0 if player.props.volume != 0.0 else 1.0,
    )
    yield (
        "Volume +10%",
        "audio-volume-medium",
        True,
        lambda: player.set_volume(min(player.props.volume + 0.1, 1.0)),
    )
    yield (
        "Volume -10%",
        "audio-volume-low",
        True,
        lambda: player.set_volume(max(player.props.volume - 0.1, 0.0)),
    )

    yield (
        "_Next",
        "media-skip-forward",
        player.props.can_go_next,
        player.next,
    )
    yield (
        "Previous (_B)",
        "media-skip-backward",
        player.props.can_go_previous,
        player.previous,
    )

    shuffle = player.props.shuffle
    yield (
        "Don't shuffle (_R)" if shuffle else "Shuffle (_R)",
        "media-playlist-shuffle",
        True,
        lambda: player.set_shuffle(not shuffle),
    )

    loop_status = player.props.loop_status
    for loop_action_name, loop_action_status in [
        ("Don't _loop", Playerctl.LoopStatus.NONE),
        ("Loop _one", Playerctl.LoopStatus.TRACK),
        ("Loop _all", Playerctl.LoopStatus.PLAYLIST),
    ]:
        yield (
            loop_action_name,
            "media-playlist-repeat",
            loop_action_status != loop_status,
            lambda loop_action_status: player.set_loop_status(loop_action_status),
            loop_action_status,
        )

    yield (
        "Play a_gain",
        "go-first",
        player.props.can_seek,
        lambda: player.set_position(0),
    )


root_menu = Gtk.Menu()

player_names = sorted(
    Playerctl.list_players(),
    key=lambda player_name: (
        -PLAYER_NAME_PRIORITIES.get(player_name.name, 0),
        player_name.instance,
    ),
)

if len(player_names) > 0:
    for player_name in player_names:
        player = Playerctl.Player.new_from_name(player_name)

        player_menu_item = Gtk.ImageMenuItem.new_with_label(player_name.instance)

        player_icon_name = PLAYER_ICON_NAME_FIXES.get(
            player_name.name, player_name.name
        )
        player_icon = Gtk.Image.new_from_icon_name(player_icon_name, Gtk.IconSize.MENU)
        player_menu_item.set_image(player_icon)

        actions_menu = Gtk.Menu()

        for (
            action_name,
            action_icon_name,
            action_enabled,
            action_fn,
            *action_fn_args,
        ) in iter_actions_for_player(player):
            action_menu_item = Gtk.ImageMenuItem.new_with_mnemonic(action_name)

            if action_icon_name is not None:
                action_icon = Gtk.Image.new_from_icon_name(
                    action_icon_name, Gtk.IconSize.MENU
                )
                action_menu_item.set_image(action_icon)

            action_menu_item.set_sensitive(action_enabled)
            if action_fn is not None:
                action_menu_item.connect(
                    "activate",
                    lambda _menu_item, action_fn, action_fn_args: action_fn(
                        *action_fn_args
                    ),
                    action_fn,
                    action_fn_args,
                )

            actions_menu.append(action_menu_item)

        player_menu_item.set_submenu(actions_menu)
        root_menu.append(player_menu_item)
else:
    menu_item = Gtk.MenuItem.new_with_label("No players were detected!")
    menu_item.set_sensitive(False)
    root_menu.append(menu_item)


root_menu.connect("selection-done", Gtk.main_quit)
root_menu.connect("deactivate", Gtk.main_quit)
root_menu.connect("destroy", Gtk.main_quit)

root_menu.show_all()
root_menu.popup(None, None, None, None, 0, Gdk.CURRENT_TIME)

Gtk.main()