local/bin/music

#!/bin/bash

mocp_control(){ # {{{
    case $1 in
        play) mocp --play; sleep 0.2;;
        stop) mocp --stop;;
       pause) mocp --toggle-pause;;
        prev) mocp --previous; sleep 0.1;;
        next) mocp --next; sleep 0.1;;
        seek) mocp --seek $2; sleep 0.1;;
    esac 2>&-
} # }}}
mocp_status(){ # {{{
    mapfile -t array < <(mocp -Q '
%state
%ts
%cs
%file
%artist
%album
%song
' 2>&-)

    [[ ${array[1]} == STOP ]] && return 1
    [[ ${array[1]} == PLAY ]] && status=playing || status=paused

    tts=${array[2]}
    cts=${array[3]}

    file=${array[4]}
    artist=${array[5]}
    album=${array[6]}
    title=${array[7]}
} # }}}

audacious_control(){ # {{{
    case $1 in
        play) audtool playback-play;;
        stop) audtool playback-stop;;
       pause) audtool playback-playpause;;
        prev) audtool playlist-reverse;;
        next) audtool playlist-advance;;
        seek) audtool playback-seek-relative $2;;
    esac
} # }}}
audacious_status(){ # {{{
    mapfile -t array < <(audtool \
        playback-status \
        current-song-length-seconds \
        current-song-output-length-seconds \
        current-song-filename \
        current-song-tuple-data artist \
        current-song-tuple-data album \
        current-song-tuple-data title
    )

    [[ ${array[0]} == stopped ]] && return 1
    [[ ${array[0]} == playing ]] && status=playing || status=paused

    tts=${array[1]}
    cts=${array[2]}

    file=${array[3]}
    artist=${array[4]}
    album=${array[5]}
    title=${array[6]}
} # }}}

cmus_control(){ # {{{
    case $1 in
        play) cmus-remote --play; sleep 0.2;;
        stop) cmus-remote --stop;;
       pause) cmus-remote --pause;;
        prev) cmus-remote --prev;;
        next) cmus-remote --next;;
        seek) cmus-remote --seek $2;;
    esac
} # }}}
cmus_status(){ # {{{
    declare -A array
    while read k1 k2 v; do
        [[ $k1 == set || $k1 == tag ]] &&
        array[$k2]="$v" || array[$k1]="$k2 $v"
    done <<< "$(cmus-remote --query)"

    [[ ${array[status]} == stopped* ]] && return 1
    [[ ${array[status]} == playing* ]] && status=playing || status=paused

    tts=${array[duration]}
    cts=${array[position]}

    file=${array[file]}
    artist=${array[artist]}
    album=${array[album]}
    title=${array[title]}
} # }}}

mpd_control(){ # {{{
    case $1 in
        play) mpc play;;
        stop) mpc stop;;
       pause) mpc toggle;;
        prev) mpc prev;;
        next) mpc next;;
        seek) mpc seek $2;;
    esac >&-
} # }}}
mpd_status(){ # {{{
    mapfile -t array < <(mpc -f '
%file%
%artist%
%album%
%title%
')

    [[ ${array[6]} ]] || return 1
    [[ ${array[6]} == \[playing\]* ]] && status=playing || status=paused

    read _ _ time _ <<< "${array[6]}"
    tts=$(date -ud 00:${time#*/} +%s 2>&-)
    cts=$(date -ud 00:${time%/*} +%s 2>&-)

    file=${array[1]}
    artist=${array[2]}
    album=${array[3]}
    title=${array[4]}
} # }}}

dbus(){ # {{{
    qdbus org.mpris.MediaPlayer2.$1 \
    /org/mpris/MediaPlayer2 \
    org.mpris.MediaPlayer2.Player.$2 $3
} # }}}
dbus_control(){ # {{{
    case $2 in
        play) dbus $1 Play; sleep 0.2;;
        stop) dbus $1 Stop;;
       pause) dbus $1 PlayPause;;
        prev) dbus $1 Previous;;
        next) dbus $1 Next;;
        seek) dbus $1 Seek $(( $3 * 1000000 ));;
    esac
} # }}}
dbus_status(){ # {{{
    status=$(dbus $1 PlaybackStatus) || return 1

    [[ $status == Stopped ]] && return 1
    [[ $status == Playing ]] && status=playing || status=paused

    declare -A array
    while read k v; do
        array[$k]=$v
    done < <(dbus $1 Metadata)

    tts=$(( ${array[mpris:length:]} / 1000000 ))
    cts=$(( $(dbus $1 Position) / 1000000 ))

    file=${array[xesam:url:]#file://}
    file=$(echo -e "${file//%/\\x}")

    artist=${array[xesam:artist:]}
    album=${array[xesam:album:]}
    title=${array[xesam:title:]}
} # }}}

player_control(){ # {{{
    case $2 in
        play) playerctl -p $1 play; sleep 0.2;;
        stop) playerctl -p $1 stop;;
       pause) playerctl -p $1 play-pause;;
        prev) playerctl -p $1 previous;;
        next) playerctl -p $1 next;;
        seek) playerctl -p $1 position $3;;
    esac
} # }}}
player_status(){ # {{{
    mapfile -t array < <(playerctl -p $1 metadata -f '
{{status}}
{{mpris:length}}
{{position}}
{{xesam:url}}
{{artist}}
{{album}}
{{title}}
')

    [[ ${array[1]} == Stopped ]] && return 1
    [[ ${array[1]} == Playing ]] && status=playing || status=paused

    tts=$(( ${array[2]} / 1000000 ))
    cts=$(( ${array[3]} / 1000000 ))

    file=${array[4]#file://}
    file=$(echo -e "${file//%/\\x}")

    artist=${array[5]}
    album=${array[6]}
    title=${array[7]}
} # }}}

rhythmbox_control(){ # {{{
    command -v playerctl > /dev/null &&
    player_control rhythmbox "$@" ||
    dbus_control   rhythmbox "$@"
} # }}}
rhythmbox_status(){ # {{{
    command -v playerctl > /dev/null &&
    player_status rhythmbox ||
    dbus_status   rhythmbox
} # }}}

mpv_control(){ # {{{
    command -v playerctl > /dev/null &&
    player_control mpv "$@" ||
    dbus_control   mpv "$@"
} # }}}
mpv_status(){ # {{{
    command -v playerctl > /dev/null &&
    player_status mpv ||
    dbus_status   mpv
} # }}}

export player icon file artist album title tt ct tl
for player in mocp cmus mpd audacious rhythmbox mpv; do
    [[ $(pidof $player) ]] || continue
    ${player}_control "$@" && ${player}_status || continue

    tt=$(date -ud @$tts +%H:%M:%S)
    ct=$(date -ud @$cts +%H:%M:%S)
    tl=$(date -ud @$(( tts - cts )) +%H:%M:%S)

    tt=${tt#00:}
    ct=${ct#00:}
    tl=${tl#00:}

    [[ $title ]] || title=${file##*/}
    [[ $status == playing ]] && icon=${MUSIC_ICON_PLAYING:-'>'}
    [[ $status == paused  ]] && icon=${MUSIC_ICON_PAUSED:-'||'}

    [[ $MUSIC_PLAYER ]] && printf '[%9s] ' $player
    [[ $MUSIC_FORMAT ]] && printf "$MUSIC_FORMAT" | envsubst
    [[ $MUSIC_FORMAT ]] || echo "$icon $artist${artist:+ - }$title (-$tl)"
done

[[ $MUSIC_FORMAT ]] ||
echo "$icon $ct $tt $file" > ~/.cache/music

[[ $status ]]