frabjous/color.sh

## color.sh
#!/bin/bash

# Define colors
txtblk='\e[0;30m' # Black - Regular
txtred='\e[0;31m' # Red
txtgrn='\e[0;32m' # Green
txtylw='\e[0;33m' # Yellow
txtblu='\e[0;34m' # Blue
txtpur='\e[0;35m' # Purple
txtcyn='\e[0;36m' # Cyan
txtwht='\e[0;37m' # White
bldblk='\e[1;30m' # Black - Bold
bldred='\e[1;31m' # Red
bldgrn='\e[1;32m' # Green
bldylw='\e[1;33m' # Yellow
bldblu='\e[1;34m' # Blue
bldpur='\e[1;35m' # Purple
bldcyn='\e[1;36m' # Cyan
bldwht='\e[1;37m' # White
unkblk='\e[4;30m' # Black - Underline
undred='\e[4;31m' # Red
undgrn='\e[4;32m' # Green
undylw='\e[4;33m' # Yellow
undblu='\e[4;34m' # Blue
undpur='\e[4;35m' # Purple
undcyn='\e[4;36m' # Cyan
undwht='\e[4;37m' # White
bakblk='\e[40m'   # Black - Background
bakred='\e[41m'   # Red
bakgrn='\e[42m'   # Green
bakylw='\e[43m'   # Yellow
bakblu='\e[44m'   # Blue
bakpur='\e[45m'   # Purple
bakcyn='\e[46m'   # Cyan
bakwht='\e[47m'   # White
trublk='\e[38;2;0;0;0m' # TrueColor Black
txtrst='\e[0m'    # Text Reset

function echocolor {
    local COLOR="$1"
    local BG="$2"
    shift 2
    echo -e ${COLOR}${BG}"$@"${txtrst}
}

# echo with a color
function echopurple {
    echo -e ${bldpur}"$@"${txtrst}
}
function echored {
    echo -e ${bldred}"$@"${txtrst}
}
function echoblue {
    echo -e ${bldblu}"$@"${txtrst}
}
function echogreen {
    echo -e ${bldgrn}"$@"${txtrst}
}
function echocyan {
    echo -e ${bldcyn}"$@"${txtrst}
}
function echoyellow {
    echo -e ${bldylw}"$@"${txtrst}
}
function echowhite {
    echo -e ${bldwht}"$@"${txtrst}
}
function echoblack {
    echo -e ${bldblk}"$@"${txtrst}
}


# echo with color; no newline
function nechopurple {
    echo -n -e ${bldpur}"$@"${txtrst}
}
function nechored {
    echo -n -e ${bldred}"$@"${txtrst}
}
function nechoblue {
    echo -n -e ${bldblu}"$@"${txtrst}
}
function nechogreen {
    echo -n -e ${bldgrn}"$@"${txtrst}
}
function nechocyan {
    echo -n -e ${bldcyn}"$@"${txtrst}
}
function nechoyellow {
    echo -n -e ${bldylw}"$@"${txtrst}
}
function nechowhite {
    echo -n -e ${bldwht}"$@"${txtrst}
}
function nechoblack {
    echo -n -e ${bldblk}"$@"${txtrst}
}

# echodim with a color
function echodimpurple {
    echo -e ${txtpur}"$@"${txtrst}
}
function echodimred {
    echo -e ${txtred}"$@"${txtrst}
}
function echodimblue {
    echo -e ${txtblu}"$@"${txtrst}
}
function echodimgreen {
    echo -e ${txtgrn}"$@"${txtrst}
}
function echodimcyan {
    echo -e ${txtcyn}"$@"${txtrst}
}
function echodimyellow {
    echo -e ${txtylw}"$@"${txtrst}
}
function echodimwhite {
    echo -e ${txtwht}"$@"${txtrst}
}
function echodimblack {
    echo -e ${txtblk}"$@"${txtrst}
}

# echodim with color; no newline
function nechodimpurple {
    echo -n -e ${txtpur}"$@"${txtrst}
}
function nechodimred {
    echo -n -e ${txtred}"$@"${txtrst}
}
function nechodimblue {
    echo -n -e ${txtblu}"$@"${txtrst}
}
function nechodimgreen {
    echo -n -e ${txtgrn}"$@"${txtrst}
}
function nechodimcyan {
    echo -n -e ${txtcyn}"$@"${txtrst}
}
function nechodimyellow {
    echo -n -e ${txtylw}"$@"${txtrst}
}
function nechodimwhite {
    echo -n -e ${txtwht}"$@"${txtrst}
}
function nechodimblack {
    echo -n -e ${txtblk}"$@"${txtrst}
}

# echo with bg, black text
function echobgpurple {
    echo -e ${bldblk}${bakpur}"$@"${txtrst}
}
function echobgred {
    echo -e ${bldblk}${bakred}"$@"${txtrst}
}
function echobgblue {
    echo -e ${bldblk}${bakblu}"$@"${txtrst}
}
function echobggreen {
    echo -e ${bldblk}${bakgrn}"$@"${txtrst}
}
function echobgcyan {
    echo -e ${bldblk}${bakcyn}"$@"${txtrst}
}
function echobgyellow {
    echo -e ${bldblk}${bakylw}"$@"${txtrst}
}
function echobgwhite {
    echo -e ${bldblk}${bakwht}"$@"${txtrst}
}
function echobgblack {
    echo -e ${txtwht}${bakblk}"$@"${txtrst}
}

# echo with bg, black text; no new line
function nechobgpurple {
    echo -e -n ${trublk}${bakpur}"$@"${txtrst}
}
function nechobgred {
    echo -e -n ${trublk}${bakred}"$@"${txtrst}
}
function nechobgblue {
    echo -e -n ${trublk}${bakblu}"$@"${txtrst}
}
function nechobggreen {
    echo -e -n ${trublk}${bakgrn}"$@"${txtrst}
}
function nechobgcyan {
    echo -e -n ${trublk}${bakcyn}"$@"${txtrst}
}
function nechobgyellow {
    echo -e -n ${trublk}${bakylw}"$@"${txtrst}
}
function nechobgwhite {
    echo -e -n ${trublk}${bakwht}"$@"${txtrst}
}
function nechobgblack {
    echo -e -n ${txtwht}${bakblk}"$@"${txtrst}
}


# spit noticeable error
function echoerr {
    echo -e ${bakwht}${bldred}"$@"${txtrst} >&2
}
function exitwitherror {
    echo -e ${bakwht}${bldred}"$2"${txtrst} >&2
    exit $1
}

## musicbrowse.sh
#!/bin/bash

# cover art should be named cover.jpg in each folder

# give the terminal time to resize
sleep 0.3

source "$HOME/bin/color.sh"

# settings
MUSICFOLDER="$HOME/music"
DEFAULTART="$HOME/music/unknownartist.jpg"

# get size of terminal
COLS="$(tput cols)"
LINES="$(tput lines)"
MENULINES="$LINES"
let MENULINES=LINES-5

# art width, height, menusizes
declare -i COVERWIDTH=15
declare -i COVERHEIGHT=8
declare -i ITEMHEIGHT=0
let ITEMHEIGHT=COVERHEIGHT+2
declare -i ITEMSPERLINE=0
let ITEMSPERLINE=COLS/COVERWIDTH
declare -i ROWSTOFIT=0
let ROWSTOFIT=MENULINES/ITEMHEIGHT
declare -i MENUSIZE=0
let MENUSIZE=ROWSTOFIT*ITEMSPERLINE
MAXALBWIDTH=$((COVERWIDTH - 3))

#check if kitty
if [[ "$TERM" == "xterm-kitty" ]] ; then
    KITTY="yes"
else
    KITTY="no"
fi

# variable declaration
declare -a MENULIST=()
declare -a PLIST=()
declare -a SONGLIST=()
declare -a SONGLISTREFS=()
declare -i MENUOFFSET=0
MENUTYPE="main"
LPROMPTCHOICE=""
RANDOMTOKEN="Rr=A_ndD-OMm"
# AAORA = albumartist or artist
AAORA="albumartist"

####################
# FUNCTIONS
####################

# add a song from a song listing to the queue
# argument is 1-based number from song list
function addsong {
    local ARG="$1"
    # adjust to 0-based number
    local POS=$((ARG - 1))
    mpc add "${SONGLISTREFS[$POS]}"
}

# load a collection of albums by searching ARG
function albums {
    local ARG="$1"

    # if no argument given, ask for starting letter
    if [[ -z "$ARG" ]] ; then
        letter_prompt
        if [[ "$LPROMPTCHOICE" == '#' ]] ; then
            ARG='^[0-9]'
        elif [[ "$LPROMPTCHOICE" == '?' ]] ; then
            ARG="$RANDOMTOKEN"
        else
            ARG="^$LPROMPTCHOICE"
        fi
    fi

    # populate list of albums for the menu
    MENULIST=()
    if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
        # random list
        mapfile -t MENULIST < <(mpc -f "%album%=-=%${AAORA}%" listall | sort | uniq | shuf | head -n "$MENUSIZE")
    else
        # use argument to search
        mapfile -t MENULIST < <(mpc search -f "%album%=-=%${AAORA}%" "(( album =~ \"$ARG\" ))" | sort | uniq )
    fi

    # count number of albums loaded
    MCOUNT="${#MENULIST[@]}"
    if [[ "$MCOUNT" -eq 0 ]] ; then
        echo "No albums found."
        return
    fi

    # if there is only one, jump right to it
    if [[ "$MCOUNT" -eq 1 ]] ; then
        load_album "${MENULIST[0]}"
        return
    fi

    # display menu with coverart
    MENUTYPE="albums"
    MENUOFFSET=0
    art_menu

}

# load a collection of artists by searching for them
function artists {
    local ARG="$1"

    # turn into artists mode for finer grained albums
    AAORA="artist"

    # prompt for letter if search parameter is empty
    if [[ -z "$ARG" ]] ; then
        letter_prompt
        if [[ "$LPROMPTCHOICE" == '#' ]] ; then
            ARG='^[0-9]'
        elif [[ "$LPROMPTCHOICE" == '?' ]] ; then
            ARG="$RANDOMTOKEN"
        else
            ARG="^$LPROMPTCHOICE"
        fi
    fi

    # populate list of artists
    MENULIST=()
    if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
        mapfile -t MENULIST < <(mpc -f "%artist%" listall | sort | uniq | shuf | head -n "$MENUSIZE")
    else
        mapfile -t MENULIST < <(mpc search -f "%artist%" "(( artist =~ \"$ARG\" ))" | sort | uniq )
    fi

    # count size of list; if zero, return
    MCOUNT="${#MENULIST[@]}"

    if [[ "$MCOUNT" -eq 0 ]] ; then
        echo "No artists found."
        return
    fi

    # if one artist matching search, jump right to it
    if [[ "$MCOUNT" -eq 1 ]] ; then
        load_artist "${MENULIST[0]}"
        return
    fi

    # display cover art menu
    MENUTYPE="artists"
    MENUOFFSET=0
    art_menu
}

# function to display menu with cover art, either albums or artists
function art_menu {
    clear # clear the screen
    local ROWSDONE=0 # count how many rows filled in

    # loop over rows (Y), then columns (X)
    for ((Y=0;Y<ROWSTOFIT;Y++)) ; do
        for ((X=0;X<ITEMSPERLINE;X++)) ; do
            # find spot in array
            local SPOT=0
            let SPOT="MENUOFFSET+(ITEMSPERLINE*Y)+X"

            # break if we are past the end of the list
            if [[ "$SPOT" -ge ${#MENULIST[@]} ]] ; then
                break
            fi

            # if we haven't broken, then add 1 to rows on first item
            if [[ "$X" -eq 0 ]] ; then
                let ROWSDONE=ROWSDONE+1
            fi

            # read info to display from the menulist
            if [[ "$MENUTYPE" == "artists" ]] ; then
                # in artists mode, we just have name of artist
                local ARTIST="${MENULIST[$SPOT]}"
                local ALBUM=''
            else
                # in albums mode, we have both (album-)artist and album
                local FULLITEM="${MENULIST[$SPOT]}"
                local ALBUM="${FULLITEM%=-=*}"
                local ARTIST="${FULLITEM#*=-=}"
            fi

            # insert cover art
            if [[ "$KITTY" == "yes" ]] ; then
                local ART="$(get_menu_art "${MENULIST[$SPOT]}")"
                kitty +kitten icat --place ${COVERWIDTH}x${COVERHEIGHT}@$((X * $COVERWIDTH))x$((Y * ITEMHEIGHT)) --transfer-mode file "$ART"
            fi

            # put cursor under art
            tput cup $(( (Y * ITEMHEIGHT) + COVERHEIGHT )) $(( (X * $COVERWIDTH) ))

            # item number
            nechocyan "$((SPOT + 1))"
            nechowhite ") "

            # is album not blank, put it on first line
            if [[ -n "$ALBUM" ]] ; then
                nechoblue "${ALBUM:0:$MAXALBWIDTH}"
            fi

            # move to next line, insert artist or albumartist name
            tput cup $(( (Y * ITEMHEIGHT) + COVERHEIGHT + 1 )) $(( (X * $COVERWIDTH) ))
            nechoyellow "${ARTIST:0:$COVERWIDTH}"

        done
    done

    # insert cursor below menu based on rowsdone
    tput cup $(( ROWSDONE*ITEMHEIGHT  )) 0

    # input suggestions for this kind of menu
    nechowhite "["
    nechocyan "#"
    nechowhite "] "
    nechogreen 'choose #  '

    # only insert back suggestion if we're not at beginning
    if [[ "$MENUOFFSET" -gt 0 ]] ; then
        nechowhite "["
        nechocyan "<"
        nechowhite "] "
        nechogreen "back  "
    fi

    # only insert next suggestion if there are more to see
    if [[ "$((SPOT + 1))" -lt "${#MENULIST[@]}" ]] ; then
        nechowhite "["
        nechocyan ">"
        nechowhite "] "
        nechogreen "more "
    fi

    nechowhite "["
    nechocyan "m"
    nechowhite "] "
    echogreen "main menu"

}

# deletes items from play queue, or clears entire queue
function clearq {
    local ARG="$1"

    # if no argument given, or "all" given, clear everything
    if [[ -z "$ARG" ]] || [[ "$ARG" =~ [Aa][Ll][Ll] ]] ; then
        mpc clear
        return
    fi

    # if there is a comma in the argument, break off first part
    if [[ "$ARG" =~ , ]] ; then
        local FIRSTARG="${ARG%%,*}"
        local REMAINDER="${ARG#*,}"
        # do first part
        clearq "$FIRSTARG"
        # then do remainder, which may have additional commas
        clearq "$REMAINDER"
        return
    fi

    # if there is a hyphen, then do the range
    if [[ "$ARG" =~ - ]] ; then
        local STARTPOS="${ARG%%-*}"
        local ENDPOS="${ARG##*-}"
        for ((I=ENDPOS;I>=STARTPOS;I=I-1)) ; do
             mpc del "$I"
        done
        return
    fi

    # if we're here, we should have a single number
    mpc del "$ARG"
}

# add items to the play queue
function enqueue {
    local ARG="$1"

    # if argument is blank, or contains "all", add entire songlist
    if [[ -z "$ARG" ]] || [[ "$ARG" =~ [Aa][Ll][Ll] ]] ; then
        ARG="1-${#SONGLIST[@]}"
    fi

    # break up comma-ed arguments
    if [[ "$ARG" =~ , ]] ; then
        local FIRSTARG="${ARG%%,*}"
        local REMAINDER="${ARG#*,}"
        # do part before first comma
        enqueue "$FIRSTARG"
        # then do the rest (may end up back here)
        enqueue "$REMAINDER"
        return
    fi

    # if there is a hyphen, apply to range
    if [[ "$ARG" =~ - ]] ; then
        local STARTPOS="${ARG%%-*}"
        local ENDPOS="${ARG##*-}"
        for ((I=STARTPOS;I<=ENDPOS;I++)) ; do
            addsong "$I"
        done
        echo "Added to queue."
        return
    fi

    # if we are here, then argument should be single number
    addsong "$ARG"
    echo "Added to queue."
}

# determines art location by file, which should just be cover.jpg in same
# folder; otherwise, return default art
function get_art_for_file {
    local FIRST="$1"
    local DIR="$(dirname "$FIRST")"
    POSSCOVER="$MUSICFOLDER/$DIR/cover.jpg"
    if [[ -e "$POSSCOVER" ]] ; then
        echo "$POSSCOVER"
        return
    fi

    # return default
    echo "$DEFAULTART"
    return
}

# determines art for artist or artist/album-albumartist
function get_menu_art {
    local ARG="$1"

    # look in folder for artist or albumartist/album if it exists
    if [[ "$MENUTYPE" == "artists" ]] ; then
        local AUND="$ARG"
    else
        local ALBUM="${ARG%=-=*}"
        local ARTIST="${ARG#*=-=}"
        local AUND="$ARTIST/$ALBUM"
    fi
    AUND="${AUND// /_}"
    local POSSCOVER="$MUSICFOLDER/$AUND/cover.jpg"
    if [[ -e "$POSSCOVER" ]] ; then
        echo "$POSSCOVER"
        return
    fi

    # if not found yet, look for first search hit
    if [[ "$MENUTYPE" == "artists" ]] ; then
        local FIRST="$(mpc search "(( $AAORA == \"$ARG\" ))" | head -n 1)" #"
    else
        local FIRST="$(mpc search "(( $AAORA == \"$ARTIST\" ) AND ( album == \"$ALBUM\"))" | head -n 1)" #"
    fi
    # look for art in folder of first hit
    local DIR="$(dirname "$FIRST")"
    POSSCOVER="$MUSICFOLDER/$DIR/cover.jpg"
    if [[ -e "$POSSCOVER" ]] ; then
        echo "$POSSCOVER"
        return
    fi

    # if not found yet, return default
    echo "$DEFAULTART"
    return
}

# play a certain song in current playlist
function jump {
    mpc play "$1"
    viewqueue
}

# prompt for a letter, or # for numbers, or ? for random
function letter_prompt {
    LPROMPTCHOICE=''
    echo
    echogreen '# A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ?'
    echo -n 'Starting with: '
    while [[ -z "$LPROMPTCHOICE" ]] ; do
        read -r LPROMPTCHOICE
    done
}

# load a given album; argument with be [album]=-=[(album)artist]
function load_album {
    ARG="$1"

    # break up argument into album and (album)artist
    local ALBUM="${ARG%=-=*}"
    local ARTIST="${ARG#*=-=}"

    # populate lists
    # songlist is displayable list of songs; songlistrefs are filenames of
    # same songs
    SONGLIST=()
    SONGLISTREFS=()
    mapfile -t SONGLIST < <(mpc search -f '%artist% - %title%' "(( $AAORA == \"$ARTIST\" ) AND ( album == \"$ALBUM\"))" )
    mapfile -t SONGLISTREFS < <(mpc search "(( $AAORA == \"$ARTIST\" ) AND ( album == \"$ALBUM\"))" )

    # display list of songs
    song_menu
}

# load a given artist, argument is name of artist
function load_artist {
    local ARG="$1"

    # populate list of albums for that artist
    MENULIST=()
    mapfile -t MENULIST < <(mpc search -f '%album%=-=%artist%' "(( artist == \"$ARG\" ))" | sort | uniq)

    # count size of list; if empty, return
    MCOUNT="${#MENULIST[@]}"
    if [[ "$MCOUNT" -eq 0 ]] ; then
        echo "No albums found for that artist."
        return
    fi

    # if one item in album list, jump right to it
    if [[ "$MCOUNT" -eq 1 ]] ; then
        load_album "${MENULIST[0]}"
        return
    fi

    # display cover art menu of albums for that artist
    MENUTYPE="albums"
    MENUOFFSET=0
    art_menu

}

# create songlist for a given playlist; argument is name of playlist
function load_playlist {
    local ARG="$1"

    # songlist is displayablelist, songlistrefs is list of filenames
    SONGLIST=()
    SONGLISTREFS=()
    mapfile -t SONGLIST < <(mpc playlist "$ARG")
    mapfile -t SONGLISTREFS < <(mpc -f '%file%' playlist "$ARG")

    # display list of songs
    song_menu
}

# main menu gives main options
function main_menu {
    clear # clear the screen
    echo "Choose an option:"

    # queue
    nechowhite "   ["
    nechocyan "q"
    nechowhite "]"
    echogreen " View/edit queue"

    # artists
    nechowhite "   ["
    nechocyan "a"
    nechowhite "]"
    nechogreen " Select by artist "
    echodimwhite "(with optional search parameter)"

    # albums
    nechowhite "   ["
    nechocyan "l"
    nechowhite "]"
    nechogreen " Select by album "
    echodimwhite "(with optional search parameter)"

    # songs
    nechowhite "   ["
    nechocyan "s"
    nechowhite "]"
    nechogreen " Select by song title "
    echodimwhite "(with optional search parameter)"

    # playlists
    nechowhite "   ["
    nechocyan "p"
    nechowhite "]"
    nechogreen " Select playlist "
    echodimwhite "(with optional search parameter)"

    # random
    nechowhite "   ["
    nechocyan "r"
    nechowhite "]"
    nechogreen " Random "
    echodimwhite "(albums) (or add a for artists, s for songs, etc.)"

    # quit program
    nechowhite "   ["
    nechocyan "x"
    nechowhite "]"
    echogreen " Exit"

    # set menu type
    MENUTYPE="main"
}

# navigate to previous items in cover art menu
function menu_back {

    # if we are not in a cover art menu, do nothing
    if [[ "$MENUTYPE" != "artists" ]] && [[ "$MENUTYPE" != "albums" ]] ; then
            return
    fi

    # change menu offset
    if [[ "$MENUOFFSET" -le "$MENUSIZE" ]] ; then
        MENUOFFSET=0
    else
        MENUOFFSET=$((MENUOFFSET - MENUSIZE))
    fi

    # redisplay menu
    art_menu
}

# navigate forward in cover art menu
function menu_more {

    # if we are not in a cover art menu, do nothing
    if [[ "$MENUTYPE" != "artists" ]] && [[ "$MENUTYPE" != "albums" ]] ; then
            return
    fi

    # get index of last item current displayed, and how many items there are
    CURREND=$((MENUOFFSET + MENUSIZE))
    TOTITEMS=${#MENULIST[@]}

    # we are already at the end, do nothing and say so
    if [[ "$CURREND" -ge "$TOTITEMS" ]] ; then
        echo "Already at end."
        return
    fi

    # change offset
    MENUOFFSET=$((MENUOFFSET + MENUSIZE))

    # redisplay menu
    art_menu
}

# if just a number if given what happens depends on what kind of meny
# we are looking at
function numeric_choice {
    local ARG="$1"

    case $MENUTYPE in

        # in album menu, load the album in question
        albums)
            local I=$((ARG - 1))
            if [[ "$I" -lt "${#MENULIST[@]}" ]] ; then
                load_album "${MENULIST[$I]}"
            else
                echo "Not a valid choice."
            fi
            ;;

        # in artists meny, load an album menu for that artist
        artists)
            local I=$((ARG - 1))
            if [[ "$I" -lt "${#MENULIST[@]}" ]] ; then
                load_artist "${MENULIST[$I]}"
            else
                echo "Not a valid choice."
            fi
            ;;

        # if menu of playlists, view its songlist
        playlist)
            local I=$((ARG - 1))
            if [[ "$I" -lt "${#PLIST[@]}" ]] ; then
                load_playlist "${PLIST[$I]}"
            else
                echo "Not a valid choice."
            fi
            ;;

        # if viewing queue, jump to that song
        queue)
            jump "$ARG"
            ;;

        # if viewing a songlist, add that song to queue
        songs)
            enqueue "$ARG"
            ;;

        # otherwise, do nothing
        *)
            ;;

    esac
}

# play something immediately
function play_now {
    local ARG="$1"

    # clear the queue
    clearq

    # add what is requested back to queue and play it
    enqueue "$ARG"
    mpc play &> /dev/null
}

# listing of playlists, either narrowed by arg search, or all
function playlist_menu {
    local ARG="$1"

    # set type of meny and clear screen
    MENUTYPE=playlist
    clear

    # get list of playlists
    PLIST=()
    if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
        mapfile -t PLIST < <(mpc lsplaylists | shuf | head -n 5)
        ARG=''
    else
        mapfile -t PLIST < <(mpc lsplaylists)
    fi

    # if argument provided, filter it
    if [[ -n "$ARG" ]] ; then
        local NLIST=()
        for P in "${PLIST[@]}" ; do
            if [[ "$P" =~ "$ARG" ]] ; then
                NLIST+=($P)
            fi
        done
        PLIST=()
        PLIST="$NLIST"
    fi

    # count number of results
    local PCOUNT="${#PLIST[@]}"

    # if there is only one, go right there
    if [[ "$PCOUNT" -eq 1 ]] ; then
        load_playlist "${PLIST[0]}"
        return
    fi

    # if there is none, say so
    if [[ "$PCOUNT" -gt 0 ]] ; then
        echo "Playlists:"
    else
        echo "There are no playlists."
    fi

    # print numbered list of found playlists
    for ((I=0;I<PCOUNT;I++)) ; do
        C=$((I+1))
        printf -v C "%3s" "$C"
        echo -n "   "
        nechocyan "$C"
        nechowhite ") "
        echoblue "${PLIST[$I]}"
    done

    # input suggestions for this menu
    nechowhite '['
    nechoblue '#'
    nechowhite '] '
    nechogreen 'view #  '
    nechowhite '['
    nechoblue 'm'
    nechowhite '] '
    nechogreen 'main menu  '
}

# save or write current queue as playlist; argument is name of playlist
function plwrite {
    local ARG="$1"

    # if no name given, ask for one
    if [[ -z "$ARG" ]] ; then
        echo -n "Playlist name: "
        read -r ARG
    fi

    # if it works, tell them
    if mpc save "$ARG" ; then echo "Saved playlist as $ARG" ; fi
}

# this is the basic prompt for input, and is basically the same everywhere
function prompt {
    # prompt for and read choice
    echo
    echo -n "Your choice: "
    read -r CHOICE

    # react accordingly
    case $CHOICE in

        quit)
            exit 0
            ;;
        exit|x*|X*)
            exit 0
            ;;
        ','|'<')
            menu_back
            ;;
        '.'|'>')
            menu_more
            ;;
        '+'*)
            local ARG="${CHOICE:1}"
            enqueue "$ARG"
            ;;
        al*|l*|L*)
            AAORA="albumartist"
            local ARG="$(echo "$CHOICE" | sed 's/^\S*\s*//')"
            albums "$ARG"
            ;;
        a*|A*)
            local ARG="$(echo "$CHOICE" | sed 's/^\S*\s*//')"
            artists "$ARG"
            ;;
        c*|C*)
            local ARG="$(echo "$CHOICE" | sed 's/^[A-Za-z]*\s*//')"
            clearq "$ARG"
            viewqueue
            ;;
        j*|J*)
            local ARG="$(echo "$CHOICE" | sed 's/^[A-Za-z]*\s*//')"
            jump "$ARG"
            ;;
        m*|M*)
            main_menu
            ;;
        n*|N*)
            local ARG="$(echo "$CHOICE" | sed 's/^[A-Za-z]*\s*//')"
            play_now "$ARG"
            ;;
        p*|P*)
            local ARG="$(echo "$CHOICE" | sed 's/^\S*\s*//')"
            playlist_menu "$ARG"
            ;;
        q*|Q*)
            viewqueue
            ;;
        r*|R*)
            local ARG="$(echo "$CHOICE" | sed 's/^\S*\s*//')"
            random "$ARG"
            ;;
        s*|S*)
            local ARG="$(echo "$CHOICE" | sed 's/^\S*\s*//')"
            songs "$ARG"
            ;;
        w*|W*)
            local ARG="$(echo "$CHOICE" | sed 's/^\S*\s*//')"
            plwrite "$ARG"
            ;;
        [0-9]*)
            numeric_choice "$CHOICE"
            ;;
        *)
            ;;
    esac
}

# load stuff randomly, either albums (default), artists, songs
function random {
    local ARG="$1"
    # default to albums if no argument given
    if [[ -z "$ARG" ]] ; then
        ARG="l"
    fi

    # load appropriate kind of menu based on argument
    case $ARG in
        l*|al*)
            AAORA="albumartist"
            albums "$RANDOMTOKEN"
            ;;
        a*)
            artists "$RANDOMTOKEN"
            ;;
        s*)
            songs "$RANDOMTOKEN"
            ;;
        p*)
            playlist_menu "$RANDOMTOKEN"
            ;;
        *)
            ;;
    esac
}

# load a list of songs,  which might be an album, or playlist, or random, etc.
function song_menu {
    clear
    MENUTYPE="songs"

    # count list of list
    SCOUNT="${#SONGLIST[@]}"
    if [[ "$SCOUNT" -gt 0 ]] ; then
        if [[ "$KITTY" == "yes" ]] ; then
            # load art from first song
            ART="$(get_art_for_file "${SONGLISTREFS[0]}")"
            kitty +kitten icat --place ${COVERWIDTH}x${COVERHEIGHT}@2x1 --transfer-mode file "$ART"
            tput cup "$((COVERHEIGHT + 2))" 0
        fi
        echo "Songs:"
    else
        echo "There are no songs to view."
        return
    fi

    # actual list of songs, with numbers
    for ((I=0;I<SCOUNT;I++)) ; do
        echo -n " ";
        N=$((I + 1))
        printf -v N "%5s" "$N"
        echo -n " "
        nechocyan "$N"
        nechowhite ") "
        echoblue "${SONGLIST[$I]}"
    done

    # input suggests for this menu
    nechowhite '['
    nechocyan '+'
    nechowhite '] '
    nechogreen 'add (all/#)  '

    nechowhite '['
    nechocyan 'n'
    nechowhite '] '
    nechogreen 'play now (all/#)  '

    nechowhite '['
    nechocyan 'm'
    nechowhite '] '
    echogreen 'main menu'

}

# request a list of songs by search argument
function songs {
    ARG="$1"

    # if no search argument given, ask for first letter
    if [[ -z "$ARG" ]] ; then
        letter_prompt
        if [[ "$LPROMPTCHOICE" == '#' ]] ; then
            ARG='^[0-9]'
        elif [[ "$LPROMPTCHOICE" == '?' ]] ; then
            ARG="$RANDOMTOKEN"
        else
            ARG="^$LPROMPTCHOICE"
        fi
    fi

    # songlist is displayable list of songs; songlist refs is corresponding
    # filenames
    # here we populate those lists
    SONGLIST=()
    SONGLISTREFS=()
    # getsongs is a temporary array with both information in one
    # we populate it first
    local GETSONGS=()
    if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
        mapfile -t GETSONGS < <(mpc -f '%artist% - %title%:=:=:%file%' listall | sort | shuf | head -n 20)
    else
        mapfile -t GETSONGS < <(mpc search -f '%artist% - %title%:=:=:%file%' "(( title =~ \"$ARG\" ))")
    fi
    # loop through getsongs and split information into the two arrays we need
    GSCOUNT="${#GETSONGS[@]}"
    for ((I=0;I<GSCOUNT;I++)) ; do
        local BOTH="${GETSONGS[$I]}"
        local STITLE="${BOTH%:=:=:*}"
        local SFILE="${BOTH#*:=:=:}"
        SONGLIST[$I]="$STITLE"
        SONGLISTREFS[$I]="$SFILE"
    done

    # display list of songs
    song_menu
}

# view the current playlist
function viewqueue {
    clear
    MENUTYPE="queue"

    # read list from mpc; get its size
    local QLIST=()
    mapfile -t QLIST < <(mpc playlist)
    local QLENGTH="${#QLIST[@]}"

    # get current filename and position
    local CURRPOSITION="$(mpc current -f %position%)"
    local CURRFILE="$(mpc -f '%file%' current)"

    # if something playing, show the art for it
    if [[ -n "$CURRFILE" ]] && [[ "$KITTY" == "yes" ]] ; then
        local ART="$(get_art_for_file "$CURRFILE")"
        kitty +kitten icat --place ${COVERWIDTH}x${COVERHEIGHT}@2x1 --transfer-mode file "$ART"
        tput cup "$((COVERHEIGHT + 2))" 0
    fi

    # header at top
    if [[ "$QLENGTH" -eq 0 ]] ; then
        echo "The playlist is empty."
    else
        echo "Current playlist:"
    fi

    # loop over playlist items, display with number
    for ((I=0;I<QLENGTH;I++)) ; do
        local CURRTRACK=no
        local POS=$((I + 1))
        if [[ "$POS" -eq "$CURRPOSITION" ]] ; then
            CURRTRACK=yes
        fi

        # if current, add arrow with purple background
        if [[ "$CURRTRACK" == "yes" ]] ; then
            nechobgpurple " → "
        else
            echo -n "   "
        fi
        while [[ "${#POS}" -lt 3 ]] ; do
            POS=" $POS"
        done
        nechocyan "$POS"
        nechowhite ") "

        # if current, give purple background
        TT="${QLIST[$I]}"
        if [[ "$CURRTRACK" == "yes" ]] ; then
            nechobgpurple "$TT$(tput el)"
            echo
        else
            echoblue "$TT"
        fi

    done

    # Display hints for this menutype
    # jump
    echo
    nechowhite '['
    nechocyan '#'
    nechowhite '] '
    nechogreen 'jump to num  '

    # clear
    nechowhite '['
    nechocyan 'c(#)'
    nechowhite '] '
    nechogreen 'clear  '

    # save as playlist
    nechowhite '['
    nechocyan 'w'
    nechowhite '] '
    nechogreen 'write/save  '

    nechowhite '['
    nechocyan 'm'
    nechowhite '] '
    nechogreen 'main menu'

}

######################### main loop

function prompt_loop {
    main_menu
    while true ; do
        prompt
    done
}

prompt_loop
	#!/bin/bash

	# Define colors
	txtblk='\e[0;30m' # Black - Regular
	txtred='\e[0;31m' # Red
	txtgrn='\e[0;32m' # Green
	txtylw='\e[0;33m' # Yellow
	txtblu='\e[0;34m' # Blue
	txtpur='\e[0;35m' # Purple
	txtcyn='\e[0;36m' # Cyan
	txtwht='\e[0;37m' # White
	bldblk='\e[1;30m' # Black - Bold
	bldred='\e[1;31m' # Red
	bldgrn='\e[1;32m' # Green
	bldylw='\e[1;33m' # Yellow
	bldblu='\e[1;34m' # Blue
	bldpur='\e[1;35m' # Purple
	bldcyn='\e[1;36m' # Cyan
	bldwht='\e[1;37m' # White
	unkblk='\e[4;30m' # Black - Underline
	undred='\e[4;31m' # Red
	undgrn='\e[4;32m' # Green
	undylw='\e[4;33m' # Yellow
	undblu='\e[4;34m' # Blue
	undpur='\e[4;35m' # Purple
	undcyn='\e[4;36m' # Cyan
	undwht='\e[4;37m' # White
	bakblk='\e[40m' # Black - Background
	bakred='\e[41m' # Red
	bakgrn='\e[42m' # Green
	bakylw='\e[43m' # Yellow
	bakblu='\e[44m' # Blue
	bakpur='\e[45m' # Purple
	bakcyn='\e[46m' # Cyan
	bakwht='\e[47m' # White
	trublk='\e[38;2;0;0;0m' # TrueColor Black
	txtrst='\e[0m' # Text Reset

	function echocolor {
	local COLOR="$1"
	local BG="$2"
	shift 2
	echo -e ${COLOR}${BG}"$@"${txtrst}
	}

	# echo with a color
	function echopurple {
	echo -e ${bldpur}"$@"${txtrst}
	}
	function echored {
	echo -e ${bldred}"$@"${txtrst}
	}
	function echoblue {
	echo -e ${bldblu}"$@"${txtrst}
	}
	function echogreen {
	echo -e ${bldgrn}"$@"${txtrst}
	}
	function echocyan {
	echo -e ${bldcyn}"$@"${txtrst}
	}
	function echoyellow {
	echo -e ${bldylw}"$@"${txtrst}
	}
	function echowhite {
	echo -e ${bldwht}"$@"${txtrst}
	}
	function echoblack {
	echo -e ${bldblk}"$@"${txtrst}
	}


	# echo with color; no newline
	function nechopurple {
	echo -n -e ${bldpur}"$@"${txtrst}
	}
	function nechored {
	echo -n -e ${bldred}"$@"${txtrst}
	}
	function nechoblue {
	echo -n -e ${bldblu}"$@"${txtrst}
	}
	function nechogreen {
	echo -n -e ${bldgrn}"$@"${txtrst}
	}
	function nechocyan {
	echo -n -e ${bldcyn}"$@"${txtrst}
	}
	function nechoyellow {
	echo -n -e ${bldylw}"$@"${txtrst}
	}
	function nechowhite {
	echo -n -e ${bldwht}"$@"${txtrst}
	}
	function nechoblack {
	echo -n -e ${bldblk}"$@"${txtrst}
	}

	# echodim with a color
	function echodimpurple {
	echo -e ${txtpur}"$@"${txtrst}
	}
	function echodimred {
	echo -e ${txtred}"$@"${txtrst}
	}
	function echodimblue {
	echo -e ${txtblu}"$@"${txtrst}
	}
	function echodimgreen {
	echo -e ${txtgrn}"$@"${txtrst}
	}
	function echodimcyan {
	echo -e ${txtcyn}"$@"${txtrst}
	}
	function echodimyellow {
	echo -e ${txtylw}"$@"${txtrst}
	}
	function echodimwhite {
	echo -e ${txtwht}"$@"${txtrst}
	}
	function echodimblack {
	echo -e ${txtblk}"$@"${txtrst}
	}

	# echodim with color; no newline
	function nechodimpurple {
	echo -n -e ${txtpur}"$@"${txtrst}
	}
	function nechodimred {
	echo -n -e ${txtred}"$@"${txtrst}
	}
	function nechodimblue {
	echo -n -e ${txtblu}"$@"${txtrst}
	}
	function nechodimgreen {
	echo -n -e ${txtgrn}"$@"${txtrst}
	}
	function nechodimcyan {
	echo -n -e ${txtcyn}"$@"${txtrst}
	}
	function nechodimyellow {
	echo -n -e ${txtylw}"$@"${txtrst}
	}
	function nechodimwhite {
	echo -n -e ${txtwht}"$@"${txtrst}
	}
	function nechodimblack {
	echo -n -e ${txtblk}"$@"${txtrst}
	}

	# echo with bg, black text
	function echobgpurple {
	echo -e ${bldblk}${bakpur}"$@"${txtrst}
	}
	function echobgred {
	echo -e ${bldblk}${bakred}"$@"${txtrst}
	}
	function echobgblue {
	echo -e ${bldblk}${bakblu}"$@"${txtrst}
	}
	function echobggreen {
	echo -e ${bldblk}${bakgrn}"$@"${txtrst}
	}
	function echobgcyan {
	echo -e ${bldblk}${bakcyn}"$@"${txtrst}
	}
	function echobgyellow {
	echo -e ${bldblk}${bakylw}"$@"${txtrst}
	}
	function echobgwhite {
	echo -e ${bldblk}${bakwht}"$@"${txtrst}
	}
	function echobgblack {
	echo -e ${txtwht}${bakblk}"$@"${txtrst}
	}

	# echo with bg, black text; no new line
	function nechobgpurple {
	echo -e -n ${trublk}${bakpur}"$@"${txtrst}
	}
	function nechobgred {
	echo -e -n ${trublk}${bakred}"$@"${txtrst}
	}
	function nechobgblue {
	echo -e -n ${trublk}${bakblu}"$@"${txtrst}
	}
	function nechobggreen {
	echo -e -n ${trublk}${bakgrn}"$@"${txtrst}
	}
	function nechobgcyan {
	echo -e -n ${trublk}${bakcyn}"$@"${txtrst}
	}
	function nechobgyellow {
	echo -e -n ${trublk}${bakylw}"$@"${txtrst}
	}
	function nechobgwhite {
	echo -e -n ${trublk}${bakwht}"$@"${txtrst}
	}
	function nechobgblack {
	echo -e -n ${txtwht}${bakblk}"$@"${txtrst}
	}


	# spit noticeable error
	function echoerr {
	echo -e ${bakwht}${bldred}"$@"${txtrst} >&2
	}
	function exitwitherror {
	echo -e ${bakwht}${bldred}"$2"${txtrst} >&2
	exit $1
	}
	#!/bin/bash

	# cover art should be named cover.jpg in each folder

	# give the terminal time to resize
	sleep 0.3

	source "$HOME/bin/color.sh"

	# settings
	MUSICFOLDER="$HOME/music"
	DEFAULTART="$HOME/music/unknownartist.jpg"

	# get size of terminal
	COLS="$(tput cols)"
	LINES="$(tput lines)"
	MENULINES="$LINES"
	let MENULINES=LINES-5

	# art width, height, menusizes
	declare -i COVERWIDTH=15
	declare -i COVERHEIGHT=8
	declare -i ITEMHEIGHT=0
	let ITEMHEIGHT=COVERHEIGHT+2
	declare -i ITEMSPERLINE=0
	let ITEMSPERLINE=COLS/COVERWIDTH
	declare -i ROWSTOFIT=0
	let ROWSTOFIT=MENULINES/ITEMHEIGHT
	declare -i MENUSIZE=0
	let MENUSIZE=ROWSTOFIT*ITEMSPERLINE
	MAXALBWIDTH=$((COVERWIDTH - 3))

	#check if kitty
	if [[ "$TERM" == "xterm-kitty" ]] ; then
	KITTY="yes"
	else
	KITTY="no"
	fi

	# variable declaration
	declare -a MENULIST=()
	declare -a PLIST=()
	declare -a SONGLIST=()
	declare -a SONGLISTREFS=()
	declare -i MENUOFFSET=0
	MENUTYPE="main"
	LPROMPTCHOICE=""
	RANDOMTOKEN="Rr=A_ndD-OMm"
	# AAORA = albumartist or artist
	AAORA="albumartist"

	####################
	# FUNCTIONS
	####################

	# add a song from a song listing to the queue
	# argument is 1-based number from song list
	function addsong {
	local ARG="$1"
	# adjust to 0-based number
	local POS=$((ARG - 1))
	mpc add "${SONGLISTREFS[$POS]}"
	}

	# load a collection of albums by searching ARG
	function albums {
	local ARG="$1"

	# if no argument given, ask for starting letter
	if [[ -z "$ARG" ]] ; then
	letter_prompt
	if [[ "$LPROMPTCHOICE" == '#' ]] ; then
	ARG='^[0-9]'
	elif [[ "$LPROMPTCHOICE" == '?' ]] ; then
	ARG="$RANDOMTOKEN"
	else
	ARG="^$LPROMPTCHOICE"
	fi
	fi

	# populate list of albums for the menu
	MENULIST=()
	if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
	# random list
	mapfile -t MENULIST < <(mpc -f "%album%=-=%${AAORA}%" listall \| sort \| uniq \| shuf \| head -n "$MENUSIZE")
	else
	# use argument to search
	mapfile -t MENULIST < <(mpc search -f "%album%=-=%${AAORA}%" "(( album =~ \"$ARG\" ))" \| sort \| uniq )
	fi

	# count number of albums loaded
	MCOUNT="${#MENULIST[@]}"
	if [[ "$MCOUNT" -eq 0 ]] ; then
	echo "No albums found."
	return
	fi

	# if there is only one, jump right to it
	if [[ "$MCOUNT" -eq 1 ]] ; then
	load_album "${MENULIST[0]}"
	return
	fi

	# display menu with coverart
	MENUTYPE="albums"
	MENUOFFSET=0
	art_menu

	}

	# load a collection of artists by searching for them
	function artists {
	local ARG="$1"

	# turn into artists mode for finer grained albums
	AAORA="artist"

	# prompt for letter if search parameter is empty
	if [[ -z "$ARG" ]] ; then
	letter_prompt
	if [[ "$LPROMPTCHOICE" == '#' ]] ; then
	ARG='^[0-9]'
	elif [[ "$LPROMPTCHOICE" == '?' ]] ; then
	ARG="$RANDOMTOKEN"
	else
	ARG="^$LPROMPTCHOICE"
	fi
	fi

	# populate list of artists
	MENULIST=()
	if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
	mapfile -t MENULIST < <(mpc -f "%artist%" listall \| sort \| uniq \| shuf \| head -n "$MENUSIZE")
	else
	mapfile -t MENULIST < <(mpc search -f "%artist%" "(( artist =~ \"$ARG\" ))" \| sort \| uniq )
	fi

	# count size of list; if zero, return
	MCOUNT="${#MENULIST[@]}"

	if [[ "$MCOUNT" -eq 0 ]] ; then
	echo "No artists found."
	return
	fi

	# if one artist matching search, jump right to it
	if [[ "$MCOUNT" -eq 1 ]] ; then
	load_artist "${MENULIST[0]}"
	return
	fi

	# display cover art menu
	MENUTYPE="artists"
	MENUOFFSET=0
	art_menu
	}

	# function to display menu with cover art, either albums or artists
	function art_menu {
	clear # clear the screen
	local ROWSDONE=0 # count how many rows filled in

	# loop over rows (Y), then columns (X)
	for ((Y=0;Y<ROWSTOFIT;Y++)) ; do
	for ((X=0;X<ITEMSPERLINE;X++)) ; do
	# find spot in array
	local SPOT=0
	let SPOT="MENUOFFSET+(ITEMSPERLINE*Y)+X"

	# break if we are past the end of the list
	if [[ "$SPOT" -ge ${#MENULIST[@]} ]] ; then
	break
	fi

	# if we haven't broken, then add 1 to rows on first item
	if [[ "$X" -eq 0 ]] ; then
	let ROWSDONE=ROWSDONE+1
	fi

	# read info to display from the menulist
	if [[ "$MENUTYPE" == "artists" ]] ; then
	# in artists mode, we just have name of artist
	local ARTIST="${MENULIST[$SPOT]}"
	local ALBUM=''
	else
	# in albums mode, we have both (album-)artist and album
	local FULLITEM="${MENULIST[$SPOT]}"
	local ALBUM="${FULLITEM%=-=*}"
	local ARTIST="${FULLITEM#*=-=}"
	fi

	# insert cover art
	if [[ "$KITTY" == "yes" ]] ; then
	local ART="$(get_menu_art "${MENULIST[$SPOT]}")"
	kitty +kitten icat --place ${COVERWIDTH}x${COVERHEIGHT}@$((X * $COVERWIDTH))x$((Y * ITEMHEIGHT)) --transfer-mode file "$ART"
	fi

	# put cursor under art
	tput cup $(( (Y * ITEMHEIGHT) + COVERHEIGHT )) $(( (X * $COVERWIDTH) ))

	# item number
	nechocyan "$((SPOT + 1))"
	nechowhite ") "

	# is album not blank, put it on first line
	if [[ -n "$ALBUM" ]] ; then
	nechoblue "${ALBUM:0:$MAXALBWIDTH}"
	fi

	# move to next line, insert artist or albumartist name
	tput cup $(( (Y * ITEMHEIGHT) + COVERHEIGHT + 1 )) $(( (X * $COVERWIDTH) ))
	nechoyellow "${ARTIST:0:$COVERWIDTH}"

	done
	done

	# insert cursor below menu based on rowsdone
	tput cup $(( ROWSDONE*ITEMHEIGHT )) 0

	# input suggestions for this kind of menu
	nechowhite "["
	nechocyan "#"
	nechowhite "] "
	nechogreen 'choose # '

	# only insert back suggestion if we're not at beginning
	if [[ "$MENUOFFSET" -gt 0 ]] ; then
	nechowhite "["
	nechocyan "<"
	nechowhite "] "
	nechogreen "back "
	fi

	# only insert next suggestion if there are more to see
	if [[ "$((SPOT + 1))" -lt "${#MENULIST[@]}" ]] ; then
	nechowhite "["
	nechocyan ">"
	nechowhite "] "
	nechogreen "more "
	fi

	nechowhite "["
	nechocyan "m"
	nechowhite "] "
	echogreen "main menu"

	}

	# deletes items from play queue, or clears entire queue
	function clearq {
	local ARG="$1"

	# if no argument given, or "all" given, clear everything
	if [[ -z "$ARG" ]] \|\| [[ "$ARG" =~ [Aa][Ll][Ll] ]] ; then
	mpc clear
	return
	fi

	# if there is a comma in the argument, break off first part
	if [[ "$ARG" =~ , ]] ; then
	local FIRSTARG="${ARG%%,*}"
	local REMAINDER="${ARG#*,}"
	# do first part
	clearq "$FIRSTARG"
	# then do remainder, which may have additional commas
	clearq "$REMAINDER"
	return
	fi

	# if there is a hyphen, then do the range
	if [[ "$ARG" =~ - ]] ; then
	local STARTPOS="${ARG%%-*}"
	local ENDPOS="${ARG##*-}"
	for ((I=ENDPOS;I>=STARTPOS;I=I-1)) ; do
	mpc del "$I"
	done
	return
	fi

	# if we're here, we should have a single number
	mpc del "$ARG"
	}

	# add items to the play queue
	function enqueue {
	local ARG="$1"

	# if argument is blank, or contains "all", add entire songlist
	if [[ -z "$ARG" ]] \|\| [[ "$ARG" =~ [Aa][Ll][Ll] ]] ; then
	ARG="1-${#SONGLIST[@]}"
	fi

	# break up comma-ed arguments
	if [[ "$ARG" =~ , ]] ; then
	local FIRSTARG="${ARG%%,*}"
	local REMAINDER="${ARG#*,}"
	# do part before first comma
	enqueue "$FIRSTARG"
	# then do the rest (may end up back here)
	enqueue "$REMAINDER"
	return
	fi

	# if there is a hyphen, apply to range
	if [[ "$ARG" =~ - ]] ; then
	local STARTPOS="${ARG%%-*}"
	local ENDPOS="${ARG##*-}"
	for ((I=STARTPOS;I<=ENDPOS;I++)) ; do
	addsong "$I"
	done
	echo "Added to queue."
	return
	fi

	# if we are here, then argument should be single number
	addsong "$ARG"
	echo "Added to queue."
	}

	# determines art location by file, which should just be cover.jpg in same
	# folder; otherwise, return default art
	function get_art_for_file {
	local FIRST="$1"
	local DIR="$(dirname "$FIRST")"
	POSSCOVER="$MUSICFOLDER/$DIR/cover.jpg"
	if [[ -e "$POSSCOVER" ]] ; then
	echo "$POSSCOVER"
	return
	fi

	# return default
	echo "$DEFAULTART"
	return
	}

	# determines art for artist or artist/album-albumartist
	function get_menu_art {
	local ARG="$1"

	# look in folder for artist or albumartist/album if it exists
	if [[ "$MENUTYPE" == "artists" ]] ; then
	local AUND="$ARG"
	else
	local ALBUM="${ARG%=-=*}"
	local ARTIST="${ARG#*=-=}"
	local AUND="$ARTIST/$ALBUM"
	fi
	AUND="${AUND// /_}"
	local POSSCOVER="$MUSICFOLDER/$AUND/cover.jpg"
	if [[ -e "$POSSCOVER" ]] ; then
	echo "$POSSCOVER"
	return
	fi

	# if not found yet, look for first search hit
	if [[ "$MENUTYPE" == "artists" ]] ; then
	local FIRST="$(mpc search "(( $AAORA == \"$ARG\" ))" \| head -n 1)" #"
	else
	local FIRST="$(mpc search "(( $AAORA == \"$ARTIST\" ) AND ( album == \"$ALBUM\"))" \| head -n 1)" #"
	fi
	# look for art in folder of first hit
	local DIR="$(dirname "$FIRST")"
	POSSCOVER="$MUSICFOLDER/$DIR/cover.jpg"
	if [[ -e "$POSSCOVER" ]] ; then
	echo "$POSSCOVER"
	return
	fi

	# if not found yet, return default
	echo "$DEFAULTART"
	return
	}

	# play a certain song in current playlist
	function jump {
	mpc play "$1"
	viewqueue
	}

	# prompt for a letter, or # for numbers, or ? for random
	function letter_prompt {
	LPROMPTCHOICE=''
	echo
	echogreen '# A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ?'
	echo -n 'Starting with: '
	while [[ -z "$LPROMPTCHOICE" ]] ; do
	read -r LPROMPTCHOICE
	done
	}

	# load a given album; argument with be [album]=-=[(album)artist]
	function load_album {
	ARG="$1"

	# break up argument into album and (album)artist
	local ALBUM="${ARG%=-=*}"
	local ARTIST="${ARG#*=-=}"

	# populate lists
	# songlist is displayable list of songs; songlistrefs are filenames of
	# same songs
	SONGLIST=()
	SONGLISTREFS=()
	mapfile -t SONGLIST < <(mpc search -f '%artist% - %title%' "(( $AAORA == \"$ARTIST\" ) AND ( album == \"$ALBUM\"))" )
	mapfile -t SONGLISTREFS < <(mpc search "(( $AAORA == \"$ARTIST\" ) AND ( album == \"$ALBUM\"))" )

	# display list of songs
	song_menu
	}

	# load a given artist, argument is name of artist
	function load_artist {
	local ARG="$1"

	# populate list of albums for that artist
	MENULIST=()
	mapfile -t MENULIST < <(mpc search -f '%album%=-=%artist%' "(( artist == \"$ARG\" ))" \| sort \| uniq)

	# count size of list; if empty, return
	MCOUNT="${#MENULIST[@]}"
	if [[ "$MCOUNT" -eq 0 ]] ; then
	echo "No albums found for that artist."
	return
	fi

	# if one item in album list, jump right to it
	if [[ "$MCOUNT" -eq 1 ]] ; then
	load_album "${MENULIST[0]}"
	return
	fi

	# display cover art menu of albums for that artist
	MENUTYPE="albums"
	MENUOFFSET=0
	art_menu

	}

	# create songlist for a given playlist; argument is name of playlist
	function load_playlist {
	local ARG="$1"

	# songlist is displayablelist, songlistrefs is list of filenames
	SONGLIST=()
	SONGLISTREFS=()
	mapfile -t SONGLIST < <(mpc playlist "$ARG")
	mapfile -t SONGLISTREFS < <(mpc -f '%file%' playlist "$ARG")

	# display list of songs
	song_menu
	}

	# main menu gives main options
	function main_menu {
	clear # clear the screen
	echo "Choose an option:"

	# queue
	nechowhite " ["
	nechocyan "q"
	nechowhite "]"
	echogreen " View/edit queue"

	# artists
	nechowhite " ["
	nechocyan "a"
	nechowhite "]"
	nechogreen " Select by artist "
	echodimwhite "(with optional search parameter)"

	# albums
	nechowhite " ["
	nechocyan "l"
	nechowhite "]"
	nechogreen " Select by album "
	echodimwhite "(with optional search parameter)"

	# songs
	nechowhite " ["
	nechocyan "s"
	nechowhite "]"
	nechogreen " Select by song title "
	echodimwhite "(with optional search parameter)"

	# playlists
	nechowhite " ["
	nechocyan "p"
	nechowhite "]"
	nechogreen " Select playlist "
	echodimwhite "(with optional search parameter)"

	# random
	nechowhite " ["
	nechocyan "r"
	nechowhite "]"
	nechogreen " Random "
	echodimwhite "(albums) (or add a for artists, s for songs, etc.)"

	# quit program
	nechowhite " ["
	nechocyan "x"
	nechowhite "]"
	echogreen " Exit"

	# set menu type
	MENUTYPE="main"
	}

	# navigate to previous items in cover art menu
	function menu_back {

	# if we are not in a cover art menu, do nothing
	if [[ "$MENUTYPE" != "artists" ]] && [[ "$MENUTYPE" != "albums" ]] ; then
	return
	fi

	# change menu offset
	if [[ "$MENUOFFSET" -le "$MENUSIZE" ]] ; then
	MENUOFFSET=0
	else
	MENUOFFSET=$((MENUOFFSET - MENUSIZE))
	fi

	# redisplay menu
	art_menu
	}

	# navigate forward in cover art menu
	function menu_more {

	# if we are not in a cover art menu, do nothing
	if [[ "$MENUTYPE" != "artists" ]] && [[ "$MENUTYPE" != "albums" ]] ; then
	return
	fi

	# get index of last item current displayed, and how many items there are
	CURREND=$((MENUOFFSET + MENUSIZE))
	TOTITEMS=${#MENULIST[@]}

	# we are already at the end, do nothing and say so
	if [[ "$CURREND" -ge "$TOTITEMS" ]] ; then
	echo "Already at end."
	return
	fi

	# change offset
	MENUOFFSET=$((MENUOFFSET + MENUSIZE))

	# redisplay menu
	art_menu
	}

	# if just a number if given what happens depends on what kind of meny
	# we are looking at
	function numeric_choice {
	local ARG="$1"

	case $MENUTYPE in

	# in album menu, load the album in question
	albums)
	local I=$((ARG - 1))
	if [[ "$I" -lt "${#MENULIST[@]}" ]] ; then
	load_album "${MENULIST[$I]}"
	else
	echo "Not a valid choice."
	fi
	;;

	# in artists meny, load an album menu for that artist
	artists)
	local I=$((ARG - 1))
	if [[ "$I" -lt "${#MENULIST[@]}" ]] ; then
	load_artist "${MENULIST[$I]}"
	else
	echo "Not a valid choice."
	fi
	;;

	# if menu of playlists, view its songlist
	playlist)
	local I=$((ARG - 1))
	if [[ "$I" -lt "${#PLIST[@]}" ]] ; then
	load_playlist "${PLIST[$I]}"
	else
	echo "Not a valid choice."
	fi
	;;

	# if viewing queue, jump to that song
	queue)
	jump "$ARG"
	;;

	# if viewing a songlist, add that song to queue
	songs)
	enqueue "$ARG"
	;;

	# otherwise, do nothing
	*)
	;;

	esac
	}

	# play something immediately
	function play_now {
	local ARG="$1"

	# clear the queue
	clearq

	# add what is requested back to queue and play it
	enqueue "$ARG"
	mpc play &> /dev/null
	}

	# listing of playlists, either narrowed by arg search, or all
	function playlist_menu {
	local ARG="$1"

	# set type of meny and clear screen
	MENUTYPE=playlist
	clear

	# get list of playlists
	PLIST=()
	if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
	mapfile -t PLIST < <(mpc lsplaylists \| shuf \| head -n 5)
	ARG=''
	else
	mapfile -t PLIST < <(mpc lsplaylists)
	fi

	# if argument provided, filter it
	if [[ -n "$ARG" ]] ; then
	local NLIST=()
	for P in "${PLIST[@]}" ; do
	if [[ "$P" =~ "$ARG" ]] ; then
	NLIST+=($P)
	fi
	done
	PLIST=()
	PLIST="$NLIST"
	fi

	# count number of results
	local PCOUNT="${#PLIST[@]}"

	# if there is only one, go right there
	if [[ "$PCOUNT" -eq 1 ]] ; then
	load_playlist "${PLIST[0]}"
	return
	fi

	# if there is none, say so
	if [[ "$PCOUNT" -gt 0 ]] ; then
	echo "Playlists:"
	else
	echo "There are no playlists."
	fi

	# print numbered list of found playlists
	for ((I=0;I<PCOUNT;I++)) ; do
	C=$((I+1))
	printf -v C "%3s" "$C"
	echo -n " "
	nechocyan "$C"
	nechowhite ") "
	echoblue "${PLIST[$I]}"
	done

	# input suggestions for this menu
	nechowhite '['
	nechoblue '#'
	nechowhite '] '
	nechogreen 'view # '
	nechowhite '['
	nechoblue 'm'
	nechowhite '] '
	nechogreen 'main menu '
	}

	# save or write current queue as playlist; argument is name of playlist
	function plwrite {
	local ARG="$1"

	# if no name given, ask for one
	if [[ -z "$ARG" ]] ; then
	echo -n "Playlist name: "
	read -r ARG
	fi

	# if it works, tell them
	if mpc save "$ARG" ; then echo "Saved playlist as $ARG" ; fi
	}

	# this is the basic prompt for input, and is basically the same everywhere
	function prompt {
	# prompt for and read choice
	echo
	echo -n "Your choice: "
	read -r CHOICE

	# react accordingly
	case $CHOICE in

	quit)
	exit 0
	;;
	exit\|x\|X)
	exit 0
	;;
	','\|'<')
	menu_back
	;;
	'.'\|'>')
	menu_more
	;;
	'+'*)
	local ARG="${CHOICE:1}"
	enqueue "$ARG"
	;;
	al\|l\|L*)
	AAORA="albumartist"
	local ARG="$(echo "$CHOICE" \| sed 's/^\S\s//')"
	albums "$ARG"
	;;
	a\|A)
	local ARG="$(echo "$CHOICE" \| sed 's/^\S\s//')"
	artists "$ARG"
	;;
	c\|C)
	local ARG="$(echo "$CHOICE" \| sed 's/^[A-Za-z]\s//')"
	clearq "$ARG"
	viewqueue
	;;
	j\|J)
	local ARG="$(echo "$CHOICE" \| sed 's/^[A-Za-z]\s//')"
	jump "$ARG"
	;;
	m\|M)
	main_menu
	;;
	n\|N)
	local ARG="$(echo "$CHOICE" \| sed 's/^[A-Za-z]\s//')"
	play_now "$ARG"
	;;
	p\|P)
	local ARG="$(echo "$CHOICE" \| sed 's/^\S\s//')"
	playlist_menu "$ARG"
	;;
	q\|Q)
	viewqueue
	;;
	r\|R)
	local ARG="$(echo "$CHOICE" \| sed 's/^\S\s//')"
	random "$ARG"
	;;
	s\|S)
	local ARG="$(echo "$CHOICE" \| sed 's/^\S\s//')"
	songs "$ARG"
	;;
	w\|W)
	local ARG="$(echo "$CHOICE" \| sed 's/^\S\s//')"
	plwrite "$ARG"
	;;
	[0-9]*)
	numeric_choice "$CHOICE"
	;;
	*)
	;;
	esac
	}

	# load stuff randomly, either albums (default), artists, songs
	function random {
	local ARG="$1"
	# default to albums if no argument given
	if [[ -z "$ARG" ]] ; then
	ARG="l"
	fi

	# load appropriate kind of menu based on argument
	case $ARG in
	l\|al)
	AAORA="albumartist"
	albums "$RANDOMTOKEN"
	;;
	a*)
	artists "$RANDOMTOKEN"
	;;
	s*)
	songs "$RANDOMTOKEN"
	;;
	p*)
	playlist_menu "$RANDOMTOKEN"
	;;
	*)
	;;
	esac
	}

	# load a list of songs, which might be an album, or playlist, or random, etc.
	function song_menu {
	clear
	MENUTYPE="songs"

	# count list of list
	SCOUNT="${#SONGLIST[@]}"
	if [[ "$SCOUNT" -gt 0 ]] ; then
	if [[ "$KITTY" == "yes" ]] ; then
	# load art from first song
	ART="$(get_art_for_file "${SONGLISTREFS[0]}")"
	kitty +kitten icat --place ${COVERWIDTH}x${COVERHEIGHT}@2x1 --transfer-mode file "$ART"
	tput cup "$((COVERHEIGHT + 2))" 0
	fi
	echo "Songs:"
	else
	echo "There are no songs to view."
	return
	fi

	# actual list of songs, with numbers
	for ((I=0;I<SCOUNT;I++)) ; do
	echo -n " ";
	N=$((I + 1))
	printf -v N "%5s" "$N"
	echo -n " "
	nechocyan "$N"
	nechowhite ") "
	echoblue "${SONGLIST[$I]}"
	done

	# input suggests for this menu
	nechowhite '['
	nechocyan '+'
	nechowhite '] '
	nechogreen 'add (all/#) '

	nechowhite '['
	nechocyan 'n'
	nechowhite '] '
	nechogreen 'play now (all/#) '

	nechowhite '['
	nechocyan 'm'
	nechowhite '] '
	echogreen 'main menu'

	}

	# request a list of songs by search argument
	function songs {
	ARG="$1"

	# if no search argument given, ask for first letter
	if [[ -z "$ARG" ]] ; then
	letter_prompt
	if [[ "$LPROMPTCHOICE" == '#' ]] ; then
	ARG='^[0-9]'
	elif [[ "$LPROMPTCHOICE" == '?' ]] ; then
	ARG="$RANDOMTOKEN"
	else
	ARG="^$LPROMPTCHOICE"
	fi
	fi

	# songlist is displayable list of songs; songlist refs is corresponding
	# filenames
	# here we populate those lists
	SONGLIST=()
	SONGLISTREFS=()
	# getsongs is a temporary array with both information in one
	# we populate it first
	local GETSONGS=()
	if [[ "$ARG" == "$RANDOMTOKEN" ]] ; then
	mapfile -t GETSONGS < <(mpc -f '%artist% - %title%:=:=:%file%' listall \| sort \| shuf \| head -n 20)
	else
	mapfile -t GETSONGS < <(mpc search -f '%artist% - %title%:=:=:%file%' "(( title =~ \"$ARG\" ))")
	fi
	# loop through getsongs and split information into the two arrays we need
	GSCOUNT="${#GETSONGS[@]}"
	for ((I=0;I<GSCOUNT;I++)) ; do
	local BOTH="${GETSONGS[$I]}"
	local STITLE="${BOTH%:=:=:*}"
	local SFILE="${BOTH#*:=:=:}"
	SONGLIST[$I]="$STITLE"
	SONGLISTREFS[$I]="$SFILE"
	done

	# display list of songs
	song_menu
	}

	# view the current playlist
	function viewqueue {
	clear
	MENUTYPE="queue"

	# read list from mpc; get its size
	local QLIST=()
	mapfile -t QLIST < <(mpc playlist)
	local QLENGTH="${#QLIST[@]}"

	# get current filename and position
	local CURRPOSITION="$(mpc current -f %position%)"
	local CURRFILE="$(mpc -f '%file%' current)"

	# if something playing, show the art for it
	if [[ -n "$CURRFILE" ]] && [[ "$KITTY" == "yes" ]] ; then
	local ART="$(get_art_for_file "$CURRFILE")"
	kitty +kitten icat --place ${COVERWIDTH}x${COVERHEIGHT}@2x1 --transfer-mode file "$ART"
	tput cup "$((COVERHEIGHT + 2))" 0
	fi

	# header at top
	if [[ "$QLENGTH" -eq 0 ]] ; then
	echo "The playlist is empty."
	else
	echo "Current playlist:"
	fi

	# loop over playlist items, display with number
	for ((I=0;I<QLENGTH;I++)) ; do
	local CURRTRACK=no
	local POS=$((I + 1))
	if [[ "$POS" -eq "$CURRPOSITION" ]] ; then
	CURRTRACK=yes
	fi

	# if current, add arrow with purple background
	if [[ "$CURRTRACK" == "yes" ]] ; then
	nechobgpurple " → "
	else
	echo -n " "
	fi
	while [[ "${#POS}" -lt 3 ]] ; do
	POS=" $POS"
	done
	nechocyan "$POS"
	nechowhite ") "

	# if current, give purple background
	TT="${QLIST[$I]}"
	if [[ "$CURRTRACK" == "yes" ]] ; then
	nechobgpurple "$TT$(tput el)"
	echo
	else
	echoblue "$TT"
	fi

	done

	# Display hints for this menutype
	# jump
	echo
	nechowhite '['
	nechocyan '#'
	nechowhite '] '
	nechogreen 'jump to num '

	# clear
	nechowhite '['
	nechocyan 'c(#)'
	nechowhite '] '
	nechogreen 'clear '

	# save as playlist
	nechowhite '['
	nechocyan 'w'
	nechowhite '] '
	nechogreen 'write/save '

	nechowhite '['
	nechocyan 'm'
	nechowhite '] '
	nechogreen 'main menu'

	}

	######################### main loop

	function prompt_loop {
	main_menu
	while true ; do
	prompt
	done
	}

	prompt_loop