tubes.sh

#!/bin/bash
# grbl play and get from youtube casa@ujo.guru 2022
# Based on yt-dlp https://github.com/yt-dlp/yt-dlp

# youtube player/downloader on terminal window
# - based on yt-dlp, youtube-search, mpv, tiv, 
# - youtbe puzzle solver 
# - search and download
# - colorful menu view
# - text mode thumbnails (tiv)
# - player gui when playing
# - download guide
# - mpv playtime keyboard ui
# - scalable on terminal window size
# - no adds 

# Active degub and color mode, and setup verbole level: 0:no colors >1: colors >3 tumbnails 
export GRBL_COLOR=true
export GRBL_DEBUG=
export GRBL_VERBOSE=2

# Home folder
base=$HOME/.tubes

# Additional functions 
source $base/bin/color.sh
source $base/bin/common.sh    

# Locations
declare -g youtube_data=$HOME/.tubes
declare -g youtube_cfg=$youtube_data/tubes.cfg
declare -g youtube_rc="/tmp/tubes.rc"
declare -g youtube_error=/tmp/tubes.error
declare -g mpv_error=/tmp/mpv.error
declare -g save_location=

# Options for external software
declare -g youtube_remote_java="--remote-components ejs:github "
declare -g youtube_java=
declare -g youtube_options= #"-f worst"

# Otions for this module
declare -g save_to_file=
declare -g continue_to_play=
declare -g media_type=
declare -g module_command=()
declare -g autoplay_delay=4

# Debug stuff (for final version remove all lines that contains '#!debug' tag)
__youtube=$(readlink --canonicalize --no-newline $BASH_SOURCE) #!debug
__youtube_color="red" #!debug

# more global variables downstairs (after sourcing rc file)

youtube.help () {
# main help of youtube module

    gr.msg -v1 "grbl youtube help " -h
    gr.msg -v2
    gr.msg -v0 "Usage:    tubes play|get|list|song|search|install|uninstall|help"
    gr.msg -v2
    gr.msg -v1 "Commands: " -c white
    gr.msg -v2
    gr.msg -v1 "  play <id|url>           play media from stream (BROKEN!)"
    gr.msg -v1 "  get <ids|url>           download list of media to media folder "
    gr.msg -v1 "  list <search string>    play list of search results, no video playback"
    #gr.msg -v3 "  song <id|url>           download audio to audio folder "
    gr.msg -v3 "  search <string>         search, printout list of results "
    gr.msg -v1 "  install                 install requirements"
    gr.msg -v1 "  uninstall               remove requirements "
    gr.msg -v1 "  upgrade                 upgrades (run this if stops working)"
    gr.msg -v1 "  help                    this help window"
    gr.msg -v2
    gr.msg -v1 "Examples: " -c white
    gr.msg -v2
    gr.msg -v1 "  tubes get https://www.youtube.com/watch?v=z9PWGAxy5zU" 
    gr.msg -v1 "  tubes get 3l65TSnK8h4" 
    gr.msg -v1 "  tubes play r9Qma8tpSeE      <- some issues for now" 
    gr.msg -v1 "  tubes nyan cat "
    gr.msg -v1 "  tubes juna kulkee taas "
    gr.msg -v1 "  tubes mitä kuuluu marja leena"
    gr.msg -v1 "  tubes upgrade  # fixes 9/10 times when youtube changes something "
    gr.msg -v2
    # own function to able player menu access for menu player function
    gr.player_help
    gr.msg -v2
}

youtube.player_help () {
# menu help
    gr.msg -v1 "Search menu: " -c white
    gr.msg -v2
    gr.msg -v1 " Menu navigation is key based, see command keys below. "
    gr.msg -v1 " Search string can be given as argument. Options should also apply here.  "
    gr.msg -v2
    gr.msg -v1 "    <search phrase>       just type to something to find in youtube"
    gr.msg -v1 "    <1..20>               select media from result list"
    gr.msg -v1 "    (n)ext                jump to next list item "
    gr.msg -v1 "    (p)revious            jump to previous in list"
    gr.msg -v1 "    (w)ait                wait until previous audio is ended"
    gr.msg -v1 "    (a)utoplay            continue to play next item "
    gr.msg -v1 "    (s)ingin              sing in with google account add details to youtube.cfg"
    gr.msg -v1 "    (t)ype                switch between audio or video mode"
    gr.msg -v1 "    (d)onwload            switch between  download ans player mode"
    gr.msg -v1 "    (l)ist                printout list of search result"
    gr.msg -v1 "    (e)rror               print last error "
    gr.msg -v1 "    (v)erbose <1..3>      1= basic, 2=more details, 3= thumbnails"
    gr.msg -v1 "    (q)uit                bye bye"
    gr.msg -v2
    gr.msg -v1 "Functions:" -c white
    gr.msg -v2
}


youtube.main () {
# module command parser
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    youtube.options $@

    case ${module_command[@]:0:1} in

        install|uninstall|upgrade|search|help|status)
            youtube.${module_command[@]:0:1} ${module_command[@]:1}
            ;;

        get|dl|download)
            gr.msg "Download mode"
            for item in ${module_command[@]:1} ; do
               youtube.get_media $item
            done
            ;;

        song|music)
            youtube.get_audio ${module_command[@]:1}
            ;;

        list)
            youtube.search_list ${module_command[@]:1}
            ;;

        play)
            youtube.search_n_play ${module_command[@]:1}
            ;;

        *) 
            youtube.search ${module_command[@]:0:1} ${module_command[@]:1}
            ;;

    esac
    return 0
}

youtube.venv () {
# activated venv
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    gr.msg -v3 -n "checking venv.. "

    if [[ $VIRTUAL_ENV == $HOME/.venv ]]; then
        gr.msg -v4 -c green "activated"
    else 
        if ! [[ -d $HOME/.venv ]]; then 
            python3 -m venv $HOME/.venv
            gr.msg -v3 -n -c white "set up "
        fi
        source $HOME/.venv/bin/activate
        gr.msg -v3 -c aqua "actived"
    fi      
}

youtube.status () {
# printout status
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    gr.msg -n -v1 -t "${FUNCNAME[0]}: "
    if [[ -f /usr/local/bin/yt-dlp ]] || [[ -f /usr/bin/yt-dlp ]] ; then
        gr.msg -c green "installed"
        return 0
    else
        gr.msg -c dark_grey "not installed"
        return 1
    fi
}


youtube.options () {
# module argument parser
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    local got_args=($@)

    for (( i = 0; i < ${#got_args[@]}; i++ )); do

        case ${got_args[$i]} in

            --get|--download|--save|dl)
                youtube_options="-f b"
                save_to_file=true 
                ;;

            --continue|--c|--cont)
                continue_to_play=true
                ;;

            --repeat|--l|--loop)
                mpv_options="$mpv_options --loop" 
                ;;

            --fullscreen|--fs|--f)
                mpv_options="$mpv_options --fs" 
                ;;

            --video|--v)
                youtube_options= # export
                save_location=$GRBL_MOUNT_VIDEO 
                media_type=video
                ;;
            --audio|--a)
                youtube_options="-f bestaudio --no-resize-buffer --ignore-errors" 
                mpv_options="$mpv_options --no-video"
                save_location=$GRBL_MOUNT_AUDIO 
                media_type=audio
                ;;

            --list-formats)
                youtube_options="$youtube_options --list-formats" 
                ;;

            *)
                module_command+=("${got_args[$i]}") 
                ;;
        esac
    done

    # When file is downloaded donwloader settings include file format
    if [[ $save_to_file ]] ; then
        if [[ $media_type == audio ]]; then 
            youtube_options="$youtube_options -x --audio-format mp3" 
        else # video
            youtube_options="$youtube_options --recode-video mp4" 
        fi
    fi

}

config.make_rc () {
# make rc file out of configuration file
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo $@ #!debug

    local _chapter=
    local _source_cfg="$1"  # source configuration file
    local _target_rc="$2"   # target rc file


    gr.msg -n -v3 -c gray "$_source_cfg "

    if ! [[ -f $_source_cfg ]] ; then
        gr.msg -c yellow "$_source_cfg not found"
        return 100
    fi

    case $(head -n 1 $_source_cfg) in
        *"source"*) gr.msg -v3 -c dark_grey "..no need to compile this type of configs"
        return 0 ;;
    esac

    # append mode is third static argument 
    if [[ $3 == "append" ]] ; then     
        gr.msg -n -v3 -c gray "(append mode) "
    else 
        [[ -f $_target_rc ]] && rm $_target_rc 
    fi

    gr.msg -v3 -c gray "$_mode $_target_rc"

    # read config file, use chapter name as second part of variable name
    while IFS='= ' read -r lhs rhs ;  do
      if [[ ! $lhs =~ ^\ *# && -n $lhs ]]; then
          rhs="${rhs%%\#*}"         # remove in line right comments
          rhs="${rhs%%*( )}"        # remove trailing spaces
          rhs="${rhs// =/=}"        # remove spaces from =
          rhs="${rhs//= /=}"

          case "$lhs" in
                *[*)  _chapter=${lhs//[}
                      _chapter=${_chapter//]}
                      [[ $_chapter ]] && _chapter="${_chapter}_" ;;
                *)    echo "export TUBES_${_chapter^^}${lhs^^}=$rhs"
            esac
      fi
    done < $_source_cfg >> $_target_rc
    chmod +x $_target_rc
    return $?
}


youtube.rc () {
# source configurations (to be faster)
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    local config_date=$(stat -c %Y $youtube_cfg)
    local rc_date=$(stat -c %Y $youtube_rc)

    gr.varlist "debug youtube_cfg config_date youtube_rc rc_date" #!debug #!debug

    # check are user configs changed, and update rc file if are
    if [[ ! -f $youtube_rc ]] || [[ $(( $config_date - $rc_date )) -gt 0 ]]; then
        config.make_rc "$youtube_cfg" "$youtube_rc" 
    fi

    # get config
    source $youtube_rc
}


youtube.search () {
# search from youtube, print list of results and ask user to select one, then play it
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    # initialize
    local items=
    local optimization="video"
    local list=()
    local urls=()
    local duration=()
    local last_item=
    local thubnails=
    local search_phrase=
    local todo="play"
    local mp4=
    local cols=
    # local youtube_data=$GRBL_DATA/youtube
    [[ $save_to_file ]] && todo="download"

    # terminal type
    case $TERM in
        xterm-256color)
            thubnails=true
            ;;
        linux|*)
            optimization="audio"
            [[ $TUBES_LIMIT_VERBOSE -gt 2 ]] && export TUBES_LIMIT_VERBOSE=2
            export youtube_options=
            export mpv_options="--input-ipc-server=$TUBES_MPV_SOCKET_FILE --vo=null --no-video "
    esac

    # make needed folders
    if ! [[ -d $youtube_data ]] ; then
        [[ -d $youtube_data ]] || mkdir $youtube_data
    fi

    [[ -d "$youtube_data/played" ]] || mkdir -p "$youtube_data/played"
    [[ -d "$youtube_data/cache" ]] || mkdir -p "$youtube_data/cache"

    search () {
    # search from by yt-dlp

        gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

        # get search phrase
        search_phrase=$@

        # user did not give search string
        [[ $search_phrase ]] || read -p "search term: " search_phrase

        gr.debug "$FUNCNAME search_phrase:'$search_phrase'" #!debug
        [[ $search_phrase == "" ]] && return 0

        # search from youtube.com, i think youtube limits results to 20 items
        local _json="/tmp/youtube_results.json"
        youtube.find $TUBES_LIMIT_SEARCH_RESULT json "$search_phrase" >$_json

        # fulfill list variables from data got from youtube search
        ifs=$IFS ; IFS=$'\n'
        id=($(jq '.videos [] | .id ' $_json))
        title=($(jq '.videos [] | .title ' $_json))
        url=($(jq '.videos [] | .url_suffix ' $_json))
        duration=($(jq '.videos [] | .duration ' $_json))
        channel=($(jq '.videos [] | .channel ' $_json))
        views=($(jq '.videos [] | .views ' $_json))
        publish=($(jq '.videos [] | .publish_time ' $_json))
        description=($(jq '.videos [] | .long_desc ' $_json))
        thumb=($(jq '.videos [] | .thumbnails [0] ' $_json | cut -d'?' -f1))
        IFS=$ifs
        last_item=1
    }

    compose_list () {
    # make list from search results
        [[ ${#title[@]} -lt 10 ]] && width=3
        [[ ${#title[@]} -gt 9 ]] && width=4
        [[ ${#title[@]} -gt 99 ]] && width=5

        # go trough found list items
        for (( i = 0; i < ${#title[@]}; i++ )); do
            title[$i]=${title[$i]//'"'}
            url[$i]=${url[$i]//'"'}
            duration[$i]="${duration[$i]//'"'}"
            id[$i]=${id[$i]//'"'}
            publish[$i]=${publish[$i]//'"'}
            [[ ${publish[$i]} == "0" ]] && publish[$i]="" || publish[$i]="${publish[$i]}"
            [[ ${description[$i]} == "null" ]] && description[$i]=""
            thumb[$i]=${thumb[$i]//'"'}
            views[$i]=${views[$i]//'"'}
            channel[$i]="${channel[$i]//'"'}"
            [[ $TUBES_LIMIT_VERBOSE -gt 2 ]] && ! [[ -f $youtube_data/cache/${id[$i]}.jpg ]] \
                && curl -s ${thumb[$i]} --output "$youtube_data/cache/${id[$i]}.jpg"
        done
        items=${#title[@]}
    }

    print_list() {
    # format and printout list of composed search results   
        gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

        cols=$(echo "cols" | tput -S) # cols variable has to be available for all search sub functions
        
        # Header for search results
        local clean_search_phrase=$(sed -e "s/\b\(.\)/\u\1/g" <<<$([[ $search_phrase ]] && echo $search_phrase || echo $@))
        if [[ $items -gt 0 ]]; then 
            if [[ $cols -lt 10 ]] ; then 
                gr.msg "${clean_search_phrase:0:5}"
            elif [[ $cols -lt 15 ]] ; then 
                gr.msg -N -h "$clean_search_phrase"
            elif [[ $cols -lt 25 ]] ; then 
                gr.msg -N -h "Search: $clean_search_phrase"
            elif [[ $cols -lt 100 ]] ; then 
                gr.msg -N -h "Results for '$clean_search_phrase'"
            else 
                gr.msg -N -h "Search results for '$clean_search_phrase'"
            fi
        fi

        # limit thumbnail size to whatever specified in user conf
        [[ $cols -gt $TUBES_LIMIT_THUMBNAIL_SIZE ]] && thumb_cols=$TUBES_LIMIT_THUMBNAIL_SIZE || thumb_cols=$cols

        # go trough found list items
        for (( i = 0; i < ${#title[@]}; i++ )); do

            # print list without thumbnails, and try to optimize to column width
            if [[ $TUBES_LIMIT_VERBOSE -lt 3 ]] ; then

                # printout only number add title
                if [[ $cols -lt 10 ]] ; then
                    gr.msg -hn "$(( $i + 1 ))"                    
                    gr.msg -n -c dark_grey "|"                    
                elif [[ $cols -lt 80 ]] ; then
                    gr.msg -hn -w $width "$(( $i + 1 )))"
                    gr.msg -w $(($cols - $width - 1)) -c light_blue "${title[$i]}"
                # printout number, title and duration
                elif [[ $cols -ge 80 ]] && [[ $cols -lt 120 ]] ; then
                    gr.msg -hn -w $width "$(( $i + 1 )))"
                    gr.msg -n -c light_blue "${title[$i]} "
                    gr.msg -c gray "${duration[$i]}"
                # printout number, title, duration and publish date
                elif [[ $cols -ge 120 ]] ; then
                    gr.msg -hn -w $width "$(( $i + 1 )))"
                    gr.msg -n  -c light_blue "${title[$i]} "
                    gr.msg -v0 -nc gray "(${duration[$i]}) "
                    gr.msg -c dark_gray "(${publish[$i]}) "
                fi
            # verbosity 3, all information
            else
                # printout number add title
                gr.msg -hn -w $width "$(( $i + 1 )))"
                gr.msg -n -c light_blue "${title[$i]} "
                # printout rest of information
                gr.msg -c gray "(${duration[$i]}) "
                gr.msg -nc dark_gray "[${channel[$i]}] "
                gr.msg -c dark_gray "(${publish[$i]}) "
                gr.msg -c dark_gray "${views[$i]} "
                # printout descriptions (it any)
                [[ ${description[$i]} ]] && gr.msg -c gray "${description[$i]} "
                # printout thumbnail
                [[ $thubnails ]] && tiv -w $thumb_cols "$youtube_data/cache/${id[$i]}.jpg"
                gr.msg
            fi
        done
    }

    print_prompt () {
    # print help and prompt
        gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug
        
        # print menu help bar
        if [[ $items -lt 1 ]] ; then 
            gr.msg -c dark_cyan "search by typing search phrase and press enter"
        else

            if [[ $cols -gt 79 ]] ; then
                _white=(n p w a l t d s e v q 1 $'\b'$items $'\n')
                _grey=(ext revious ait utoplay ogin ype onwload earch rror erbose uit '..')
                _space=' '

            elif [[ $cols -gt 74 ]] ; then
                _white=(n p w a l t d s e v q $'\n')
                _grey=(ext revious ait utoplay ogin ype onwload earch rror erbose uit )
                _space=' '
            
            elif [[ $cols -gt 59 ]] ; then
                _white=(n p w a l t d s e v q $'\n')
                _grey=(ext rev ait utop ogin ype onwl earch rror erb uit )
                _space=' '

            elif [[ $cols -gt 29 ]] ; then
                _white=('' n p w a l t d s e v q 1 $items $'\n')
                _grey=('[' '|' '|' '|' '|' '|' '|' '|' '|' '|' '|' '|' '..' ']')
                _space=''

            elif [[ $cols -gt 10 ]] ; then
                _white=('' n p w a l t d s e v q $'\n')
                _grey=('' '|' '|' '|' '|' '|' '|' '|' '|' '|' '|' '')
                _space=''

            else
                _white=('' n p w a l t d s e v q $'\n')
                _grey=('' '' '' '' '' '' '' '' '' '' '' '')
                _space=''
            fi

            for (( i = 0; i < ${#_white[@]}; i++ )); do
                gr.msg -n -c white "${_white[$i]}"
                gr.msg -n -c grey "${_grey[$i]}$_space"
            done
        fi

        # genrating prompt
        if [[ $cols -lt 6 ]] ; then
            _prompt=$'\r'""
            _prompt+="$(gr.msg -n -c cyan ${todo:0:1})" 
            _prompt+="$(gr.msg -n -c white ':')" 
        elif [[ $cols -lt 10 ]] ; then
            _prompt=$'\r'""
            _prompt+="$(gr.msg -n -c cyan ${todo:0:1}${optimization:0:1})" 
            _prompt+="$(gr.msg -n -c white ':')" 
        elif [[ $cols -lt 25 ]] ; then
            _prompt=$'\r'""
            _prompt+="$(gr.msg -n -c cyan ${todo:0:2}/${optimization:0:2})" 
            _prompt+="$(gr.msg -n -c white ': ')" 
        elif [[ $cols -lt 60 ]] ; then
            _prompt=$'\r'"[$last_item/${#title[@]}] "
            _prompt+="$(gr.msg -n -c cyan $todo $optimization)" 
            _prompt+="$(gr.msg -n -c white ': ')" 
        else
            _prompt=$'\r'"[$last_item/${#title[@]}] "
            _prompt+="$(gr.msg -n -c dark_cyan command or number to) "
            _prompt+="$(gr.msg -n -c cyan $todo $optimization)" 
            _prompt+="$(gr.msg -n -c white ': ')" 
        fi

        # if continue playing is set , wait few second and jump to next item
        if [[ $continue_to_play ]]; then
            read -e -t $autoplay_delay -p "$_prompt" ans
            ans=${ans:-continue}
        # initially with no arguments go stait to search 
        elif [[ $last_item -lt 1 ]]; then 
            ans='s'
        # Normal prompt
        else
            read -e -p "$_prompt" ans
        fi
    }

    play_item () {
    # play item
        gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug
    
        # limit thumbnail size
        cols=$(echo "cols"|tput -S) # update column size

        local _error=0

        [[ $cols -gt 80 ]] && cols=80

        # make shown list number to real list location
        local item=$(($1-1))

        # format header and now playing data
        local np="youtube [$1/$items] ${title[$item]} ${duration[$item]}"

        # place formatted headers, sleep one second cause last player might delete updated file
        echo "$np" >$TUBES_NOWPLAYING_FILE
        create_time=$(stat -c %Y $TUBES_NOWPLAYING_FILE)
        gr.msg -N -h "$np"

        # log what played today
        echo "$(date -d now +%Y-%m-%d-%H:%M:%S) ${id[$item]} ${title[$item]}" >>"$youtube_data/played/$(date -d now +%Y-%m-%d).list"

        # fetch thumbnail if not done already
        if [[ $thubnails ]] && [[ $TUBES_LIMIT_VERBOSE -ge 1 ]] && [[ ! $save_to_file ]]; then
            [[ -f $youtube_data/cache/${id[$item]}.jpg ]] || curl -s ${thumb[$item]} --output "$youtube_data/cache/${id[$item]}.jpg"
            tiv -w $cols "$youtube_data/cache/${id[$item]}.jpg"
        fi

        local media_address="https://www.youtube.com${url[$item]}"

        # if download selected
        if [[ $save_to_file ]] ; then
            # open repository to select quality separately for video and audio
            gr.debug "download call $media_address" #!debug
            youtube.get_media $media_address
            # nothing more to do here?
            return $?
        fi

        # print media address below the thumbnail (link to youtube)
        gr.msg -c dark_grey "$media_address"

        # this is shown only then debug mote '-d' is flagged (or verbose 4+)
        if [[ $GRBL_DEBUG ]]; then
            echo "yt-dlp --no-playlist $youtube_remote_java $youtube_java $youtube_options $sing_in_option $media_address -o - 2>$youtube_error | mpv $mpv_options -"
            yt-dlp --no-playlist $youtube_remote_java $youtube_java $youtube_options $sing_in_option $media_address -o - | mpv $mpv_options -
            gr.ask "continue?" || return 192
        fi

        yt-dlp --no-playlist $youtube_remote_java $youtube_java $youtube_options $sing_in_option $media_address -o - 2>$youtube_error | mpv $mpv_options -
        # in every module, function error is returned to core in continued return chain, and can be processed by core to
        # exits from module function are logged specially old method gr.msg -x 128 exits can cause extra logging, more for lacy prototyping
        _error=$?

        # transfer errors for future processing in main loop
        gr.debug "$FUNCNAME _error:$_error" #!debug

        # remove now playing only if it's created by current me. made by checking creation time
        # Okey, here is late night implementation, but it seem to work, stay there then.
        [[ -f $TUBES_NOWPLAYING_FILE ]] && [[ $(($(stat -c %Y $TUBES_NOWPLAYING_FILE) - $create_time)) -lt 1 ]] \
            && rm $TUBES_NOWPLAYING_FILE

        # module maker (2025) declare module error as $_error=(), compatible with below
        (( $_error > 0 )) && gr.msg -c yellow "${FUNCNAME[0]} returned $_error"
        return $_error
    }

    set_sing_in () {
        # get cookies from firefox and set youtube sing in options for user set in configuration
        # NOTE: this might not work anymore: https://github.com/yt-dlp/yt-dlp/issues/8079
        gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

        if ! [[ -f $youtube_data/cookies.txt ]] ; then
            yt-dlp --cookies-from-browser $TUBES_COOKIE_BROWSER --cookies $youtube_data/cookies.txt --skip-download 2>$youtube_error
            gr.msg -c white "cookies saved to $youtube_data/cookies.txt"
            gr.ask "file contains all your cookies, so you might like to delete it on exit? " && delete_cookies=true
        fi
        if ! [[ $TUBES_YOUTUBE_USER ]] ; then
            gr.msg -e1 "no youtube user set in configuration "
            return 122
        fi

        [[ $TUBES_YOUTUBE_PASSWORD ]] \
            && sing_in_option="-u $TUBES_YOUTUBE_USER -p $TUBES_YOUTUBE_PASSWORD" \
            || sing_in_option="-u $TUBES_YOUTUBE_USER"

        sing_in_option="$sing_in_option --cookies $youtube_data/cookies.txt"
    }


    # search and printout search results
    [[ $1 ]] && search "$@"
    compose_list
    print_list

    # main menu loop
    while true ; do

        # update column count every loop
        cols=$(echo "cols" | tput -S)

        print_prompt

        # parse user input
        case ${ans%% *} in

            # play selected search result
            [1-9]|1[0-9]|2[0-9]|3[0-9])
                if [[ $ans -gt $items ]] ; then
                    gr.msg -c error "list is $items items long"
                    continue
                fi
                last_item=$ans
                ;;

            continue) # continuous playing, increase item number
                [[ $last_item -ge ${#title[@]} ]] && last_item=0
                last_item=$(( last_item + 1 ))
                ;;

            v*)  # set verbosity
                [[ ${#ans} -le 1 ]] && read -p "set verbosity 0..3: " ans
                [[ ${#ans} == 2 ]] && ans=${ans:1}
                [[ "${#ans}" -ge 3 ]] && ans=${ans#* }
                gr.debug "VERBOSE:'$ans" #!debug
                [[ ! $thubnails ]] && [[ $ans -gt 2 ]] && ans=2
                export TUBES_LIMIT_VERBOSE=$ans
                export GRBL_VERBOSE=$TUBES_LIMIT_VERBOSE
                [[ $TUBES_LIMIT_VERBOSE -gt 2 ]] && compose_list
                print_list
                continue
                ;;

            d)  if [[ $save_to_file ]] ; then
                    save_to_file=
                    todo="play"
                else
                    save_to_file=true
                    todo="download"
                    # if [[ $optimization == "video" ]] ; then
                    #     gr.ask "convert to webm files to mp4 format?" && mp4=true || mp4=
                    # fi
                fi
                gr.msg "selected to $todo $optimization"
                continue
                ;;

            t)  # content type selector, video or audio
                if [[ $optimization == "audio" ]] ; then
                    optimization=video
                    youtube_options="-f best"
                    mpv_options="--input-ipc-server=$TUBES_MPV_SOCKET_FILE"
                else
                    optimization=audio
                    youtube_options=
                    mpv_options="--input-ipc-server=$TUBES_MPV_SOCKET_FILE --vo=null --no-video "
                fi
                gr.msg "selected to $todo $optimization"
                continue
                ;;

            a)  # toggle continuous and normal playing
                if [[ $continue_to_play ]] ; then
                    gr.msg "autoplay canceled"
                    continue_to_play=
                else
                    gr.msg "autoplay set ($autoplay_delay sec delay)"
                    continue_to_play=true
                fi
                continue
                ;;

            f) # not really sure what this were
                if ! [[ $mpv_temp_options ]] ; then
                    mpv_temp_options=$mpv_options
                    mpv_options="$mpv_options --fs"
                else
                    mpv_options=$mpv_temp_options
                    mpv_temp_options=
                fi
                continue
                ;;

            n)  # play next item
                last_item=$(( last_item + 1 ))
                [[ $last_item -ge ${#title[@]} ]] && last_item=1
                ;;

            p)  # play previous item
                last_item=$(( last_item - 1 ))
                [[ $last_item -le 0 ]] && last_item=${#title[@]}
                ;;
            w)  # wait until now playing is empty and start to play
                [[ "${#ans}" -ge 3 ]] && last_item=${ans#* }
                item=$(( $last_item - 1 ))
                sleep 1
                gr.msg -n "waiting [$last_item/$items] ${title[$item]} ${duration[$item]} (press any key to play now)"
                while [[ -f $TUBES_NOWPLAYING_FILE ]] ; do
                    read -s -n1 -t1 && break
                done
                ;;
            l)  # sing in toggle
                if [[ $sing_in_option ]] ; then
                    gr.msg -c dark_grey "removing login options"
                    sing_in_option=
                else
                    gr.msg -c white "setting $TUBES_YOUTUBE_USER login options"
                    set_sing_in
                fi
                continue
                ;;
            e)  #show last error log
                gr.msg -h "printing error log from $youtube_error "
                [[ -f $youtube_error ]] && cat $youtube_error || gr.msg "no error log found"
                continue
                ;;
            q*|exit|bye) # exit
                break
                ;;

            s)  # new search
                local s_phrase=${ans#* }
                [[ ${#ans} -le 1 ]] && read -p "search: " s_phrase
                search "$s_phrase"
                compose_list
                print_list
                continue
                ;;
            l|"")  # print list of results again
                print_list
                continue
                ;;
            *)  gr.msg -c yellow "unknown command"
                continue
        esac

        # pause other players, but only once
        if ! [[ $stopped ]] && [[ $optimization == audio ]] ; then
            local stopped=true
            # audio.pause others youtube
        fi

        play_item $last_item

        if [[ $? -eq 143 ]] ; then

            # # some module asked to hold on a moment
            # if flag.get audio_hold ; then
            #     while flag.get audio_hold >/dev/null ; do
            #         sleep 2
            #     done
            # else
            #     gr.msg "continues playing canceled"
            #     continue_to_play=
            # fi
            true
        fi
    done

    # do not compromise user privacy
    if [[ $delete_cookies ]] && [[ -f $youtube_data/cookies.txt ]] ; then
        gr.msg -n "deleting cookies $youtube_data/cookies.txt.. "
        rm $youtube_data/cookies.txt && gr.msg -c green "ok" || gr.msg -e3 "failed"
    fi

    return 0
}


youtube.find () {
# search from youtube and return json of $1 amount of results
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    # deliver decimal value for inline python
    result_count=$1

    # if output format is specified, set it and remove it from input string
    case $2 in
        dict) return_format=dict ; shift ;;
        json) return_format=json ; shift ;;
        *) return_format=json
    esac

    # remove result count
    shift    
    search_string="$@"

    # with python, indentation is critical, therefore following lines needs to be like this
    if [[ -f $HOME/.venv/bin/activate ]]; then 
        python3 -m venv $HOME/.venv
    fi

    source $HOME/.venv/bin/activate
    python3 - << EOF
import os
import json
from youtube_search import YoutubeSearch
results = YoutubeSearch("$search_string", max_results=$result_count).to_$return_format()
print(results)
EOF

}


youtube.firefox_cookies () {
# get youtube cookie from firefox 
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug
    
    local cookie_yt="$youtube_data/youtube_cookie.txt"

    if [[ -f $cookie_yt ]]; then 
        if ! gr.ask "$cookie_yt exist, overwrite?"; then 
            gr.msg "skipping.. "
            return 99
        fi
    fi

    local cookie_db="/tmp/fox-cookies.sqlite"
    local profiles="$HOME/.mozilla/firefox/profiles.ini"

    if ! [[ -f $profiles ]] ; then
        gr.msg -e2 no profiles '$profiles' found
        return 112
    fi

    # fast way to get default profile
    head -n 3 $profiles | grep "Default" >/tmp/fox-profile
    source /tmp/fox-profile
    profile=$Default
    rm /tmp/fox-profile
    gr.debug "profile:'$profile'" #!debug
    [[ $profile ]] || return 113

    # get cookies database
    fox_cookie_db=$HOME/.mozilla/firefox/$profile/cookies.sqlite
    gr.debug "cookie_db:'$fox_cookie_db'" #!debug
    [[ -f $fox_cookie_db ]] || return 114

    cp $fox_cookie_db $cookie_db

    python3 "$GRBL_BIN/audio/get_cookie.py" youtube.com $cookie_db >$cookie_yt
    rm $cookie_db
}


youtube.search_n_play () {
# search input and play it from youtube. use long arguments --video or --audio to select optimization
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug
    
    local base_url="https://www.youtube.com"
    local _error=

    # to fulfill global variables: save_to_file save_location mpv_options youtube_options
    youtube.options $@

    # make search and get media data and address
    local query=$(youtube.find 1 json ${module_command[@]})

    # get information of found media
    # TBD make able to parse multiple search results ans for them trough to replace search_list function"
    local title=$(echo $query | jq | grep title | cut -d':' -f2 | sed 's/"//g' | sed 's/,//g' | xargs -0 )
    local duration=$(echo $query | jq | grep duration | cut -d':' -f2 | xargs | sed 's/,//g')
    local media_address=$base_url$(echo $query | jq | grep url_suffix | cut -d':' -f 2 | xargs)

    gr.msg -v1 -h "$title ($duration) "
    gr.msg -v2 $media_address

    # if just saving the file
    if [[ $save_to_file ]]; then
        #save the file to media folder
        youtube_options="$youtube_options --continue --output $save_location/%(title)s.%(ext)s"
        gr.msg -v1 "downloading to $save_location.. "
        # save file
        yt-dlp --no-playlist $youtube_remove_java $youtube_options $media_address
        # a bit dangero if some of location variables are empty
        #new_name=$(detox -v *mp4 -n | grep ">" | cut -d '>' -f 2 |xargs)
        detox -v *mp3 *mp4 $save_location 2>/dev/null

        #source tag.sh
        #tag.main add $new_name "grbl youtube.sh $title"
        return $?
    fi

    # make now playing info available for audio module
    echo "youtube $title" >$TUBES_NOWPLAYING_FILE

    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]]  #!debug
    
    # start stream and play
    yt-dlp --no-playlist $youtube_remove_java $youtube_java \
        $youtube_options $media_address -o - 2>$youtube_error \
        | mpv $mpv_options - >$mpv_error

    # in some cases there is word fuck or exposed tits in video, therefore:
    if grep 'Sign in to' $youtube_error; then
        [[ -f $mpv_error ]] && rm $mpv_error
        [[ -f $youtube_error ]] && rm $youtube_error

        # if user willing to save password in configs (who would?) serve him/her anyway
        [[ $TUBES_YOUTUBE_PASSWORD ]] \
            && sing_in="-u $TUBES_YOUTUBE_USER -p $TUBES_YOUTUBE_PASSWORD --cookies-from-browser" \
            || sing_in="-u $TUBES_YOUTUBE_USER --cookies-from-browser"

            gr.msg -v2 "signing in as $TUBES_YOUTUBE_USER"

            # then perform re-try
            yt-dlp --no-playlist $youtube_remove_java -v $youtube_options $sing_in $media_address -o - 2>$youtube_error \
                | mpv $mpv_options - >$mpv_error
    fi

    # lacy error printout
    if [[ -f $mpv_error ]]; then
        _error=$(grep 'ERROR:' $youtube_error)
        [[ $_error ]] && gr.msg -v2 -c red $_error
        rm "$mpv_error"
    fi

    if [[ -f $youtube_error ]]; then
        _error=$(grep 'Failed' $mpv_error)
        [[ $_error ]] && gr.msg -v2 -c yellow $_error
        rm "$youtube_error"
    fi
    # remove now playing and error data
    [[ -f $TUBES_NOWPLAYING_FILE ]] && rm $TUBES_NOWPLAYING_FILE

    return 0
}


youtube.search_list () {
# search input and play it from youtube, optimized for audio, no video at all
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    local base_url=https://www.youtube.com/watch?v=

    # check is installed
    yt-dlp --version || youtube.install

    # overwrite global variables, optimize for audio
    youtube_options="-f bestaudio --no-resize-buffer --ignore-errors"

    # make search and get media data and address
    local query=$(youtube.find 20 json $@)

    # format information of found media
    declare -a id_list=($(echo $query | jq | grep url_suffix \
        | sed 's/"url_suffix"://g' \
        | sed 's/ //g' \
        | sed 's/"\/watch?v=//g'\
        | sed 's/"//g' ))
    # TBD declare -a title_list="$(echo $query | jq | grep title | sed 's/"title": "//g' | sed 's/"//g')"

    # go trough list of search results
    for (( i = 0; i < ${#id_list[@]}; i++ )); do
        _url="$base_url$(echo ${id_list[$i]} | cut -d':' -f2 | xargs | sed 's/"//g' | cut -d' ' -f 1)"

        # TBD _title="$(echo ${title_list[$i]} | cut -d':' -f2 | xargs | sed 's/,//g')"
        # gr.msg -v1 -h "${id_list[$i]} [$(($i+1))/${#id_list[@]}]" # might contain '-' and its read as an option =/
        echo "${id_list[$i]} [$(($i+1))/${#id_list[@]}]"

        # make now playing info available for audio module
        echo "youtube $_url" >$TUBES_NOWPLAYING_FILE

        # start stream and play
        yt-dlp $youtube_options "$_url" -o - 2>/dev/null| mpv $mpv_options --no-video - >$mpv_error

        #remove now playing data
        [[ -f $TUBES_NOWPLAYING_FILE ]] && rm $TUBES_NOWPLAYING_FILE

        # if flag.get audio_stop ; then
        #     flag.rm audio_stop
        #     break
        # fi
    done
    return 0
}


youtube.get_media () {
# download videos from tube by youtube id or url
# print list of formats and let user select proper one
# can be used to download audio only, select '0' or 'a' in video list
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    local input=$1
    local url_base="https://www.youtube.com/watch?v"
    local url=
    local filename=
    local save_location=$(pwd) # user config will overwrite if not empty
    local resolution=
    local quality=
    local color=gray
    local audio=
    local selected=
    local audio_only=
    local base_name=

    # Check save location
    if [[ $TUBES_SAVE_LOCATION ]]; then 
        
        if [[ -d  $TUBES_SAVE_LOCATION ]]; then 
            save_location=$TUBES_SAVE_LOCATION
        else
            gr.msg -e1 "$TUBES_SAVE_LOCATION is not exists"
            if gr.ask "greate it?" ; then 
                if mkdir -p $TUBES_SAVE_LOCATION ; then 
                    save_location=$TUBES_SAVE_LOCATION \
                    else 
                        gr.msg -e "unable to create $TUBES_SAVE_LOCATION" 
                        return 122
                    fi
            else 
                gr.msg -e "unable to continue, pls. edit $youtube_cfg" 
                return 123
            fi
        fi
    fi

    # check is installed
    yt-dlp --version >/dev/null || youtube.install
    gr.debug "soft check" #!debug

    deno=$(which deno)

    if [[ -z $deno ]]; then 
        gr.msg -e1 "unable to find java runtime, may be unabe to download"
        gr.ask "install now?" && youtube.install
    fi

    # url or id selector
    if [[ $input == "https:"* ]]; then
        # input is url
        url="$input"
    else
        # input is video id
        url="$url_base=$input"
    fi

    # get data from youtube
    ifs=$IFS
    IFS=$'\n'
    gr.debug "generating list" #!debug
    if [[ $GRBL_DEBUG ]]; then 
        yt-dlp --no-playlist -F $url 
        gr.ask "contunue?" || return 102
    fi 

    list=( $(yt-dlp --no-playlist -F $url 2>/dev/null | grep "|" ) )
    gr.debug "list ok" #!debug
    # make separated lists for video and audio
    for (( i = 0; i < ${#list[@]}; i++ )); do
        if echo ${list[$i]} | grep -v "mp4a." | grep -q -e "video only" -e "mp4" ; then
            video_list+=( "${list[$i]}" )
        fi     
        if echo ${list[$i]} | grep -q -e "audio only" -e "m4a" -e "mp3" ; then
            audio_list+=( "${list[$i]}" )
        fi
    done
    IFS=$ifs
    gr.debug "video list" #!debug

    # video select loop

    gr.msg -h "#   ${list[0]}"
    for (( i = 1; i < ${#video_list[@]}; i++ )); do
        color=list
        gr.msg -n -h -w 4 "$i:"

        # get file size
        size="$(echo ${video_list[$i]} | cut -d " " -f6 | cut -d "x" -f1)"

        # clean up file size
        [[ $size == '~' ]] && size="$(echo ${video_list[$i]} | cut -d " " -f7 | cut -d "x" -f1)"
        size=${size//'~'/}
        size=${size/'iB'/}

        # printout video selection menu, colorize by file size
        case $size in
            *K)
                size=${size/'K'/}
                size=${size%%.*}
                color=black
                ;;
            *M)
                size=${size/'M'/}
                size=${size%%.*}
                if [[ $size -lt 5 ]] ; then  color=dark_gray
                elif [[ $size -ge 5 ]] && [[ $size -lt 10 ]] ; then color=gray
                elif [[ $size -ge 10  ]] && [[ $size -lt 30 ]] ; then color=list
                elif [[ $size -ge 30  ]] && [[ $size -lt 50 ]] ; then color=white
                elif [[ $size -ge 50  ]] && [[ $size -lt 100 ]] ; then color=lime
                elif [[ $size -ge 100  ]] && [[ $size -lt 300 ]] ; then color=yellow
                elif [[ $size -ge 300  ]] && [[ $size -lt 500 ]] ; then color=orange
                elif [[ $size -ge 500  ]] && [[ $size -lt 999 ]] ; then color=red
                fi
                ;;
            *G)
                size=${size/'G'/}
                size=${size%%.*}
                color=deep_pink
                ;;
        esac
        gr.msg -c $color "${video_list[$i]}"
    done

    gr.varlist "debug size video_list" #!debug

    # clear keyboard buffer
    # while read -e -t 0.1; do : ; done

    gr.debug "video list done" #!debug

    # ask to select video (0 or a is audio only)
    while true; do
        read -p "select video (a audio only, w worst quality, b best, q exit): " ans

        if [[ $ans == "q" ]]; then
            echo
            return 12

        # audio only
        elif [[ $ans == "0" ]] || [[ $ans == "a" ]]; then
            audio_only=true
            quality=
            break

        # select worst quality
        elif [[ $ans == "w" ]] || [[ $ans == "" ]]; then
            quality="-f $(echo ${video_list[0]} | cut -d " " -f1)"
            resolution="$(echo ${video_list[0]} | cut -d " " -f3)"
            v_size="$(echo ${video_list[0]} | cut -d " " -f6 | cut -d "x" -f1)"
            [[ $v_size == '~' ]] && v_size="$(echo ${video_list[0]} | cut -d " " -f7 | cut -d "x" -f1)"
            v_size=${v_size//'~'/}
            break

        # select best quality
        elif [[ $ans == "b" ]] || [[ $ans == "" ]]; then
            quality="-f $(echo ${video_list[${#video_list[@]}]} | cut -d " " -f1)"
            resolution="$(echo ${video_list[${#video_list[@]}]} | cut -d " " -f3)"
            v_size="$(echo ${video_list[${#video_list[@]}]} | cut -d " " -f6 | cut -d "x" -f1)"
            [[ $v_size == '~' ]] && v_size="$(echo ${video_list[${#video_list[@]}]} | cut -d " " -f7 | cut -d "x" -f1)"
            v_size=${v_size//'~'/}
            break

        # check answer is number
        elif ! [[ $ans =~ ^[0-9]+$ ]] || [[ $ans -lt 1 ]] || [[ $ans -gt ${#video_list[@]} ]]; then
            gr.msg -N "please select 1..${#video_list[@]} 'b' for best, 'w' for worst, or 'q' to exit"
            continue

        # go here if all fine
        else
            quality="-f $(echo ${video_list[$ans]} | cut -d " " -f1)"
            resolution="$(echo ${video_list[$ans]} | cut -d " " -f3)"
            v_size="$(echo ${video_list[$ans]} | cut -d " " -f6 | cut -d "x" -f1)"
            [[ $v_size == '~' ]] && v_size="$(echo ${video_list[$i]} | cut -d " " -f7 | cut -d "x" -f1)"
            v_size=${v_size//'~'/}
            break
        fi
    done

    gr.varlist "debug quality resolution v_size" #!debug
    gr.debug "getting filename.." #!debug
    # get filename
    # --no-playlist --remote-components ejs:github --js-runtimes $deno
    if [[ $GRBL_DEBUG ]]; then 
        yt-dlp --no-playlist $youtube_remote_java $youtube_java $quality --print filename $url 
        gr.ask "contunue?" || return 103
    fi 
    local raw_filename=$(yt-dlp --no-playlist $youtube_remote_java $youtube_java $quality --print filename $url 2>/dev/null)
    gr.debug "raw file name: $raw_filename" #!debug
    
    if ! [[ $raw_filename ]]; then 
        gr.msg -e1 "unable to get filename, pls try again"
        return 192
    fi

    # clean up filename
    base_name=${raw_filename%%.*}
    file_ending=${raw_filename##*.}
    base_name=${base_name/\＂/-}
    base_name=${base_name//\＂/}
    base_name=${base_name//\ /_}
    base_name=${base_name//'!'/}
    base_name=${base_name//'['/}
    base_name=${base_name//']'/}
    base_name=${base_name//']'/}
    base_name=${base_name//'#'/}
    base_name=${base_name//'*'/}
    base_name=${base_name//'('/}
    base_name=${base_name//')'/}
    base_name=${base_name//'?'/}
    base_name=${base_name//'？'/} # that was not normal mot*fucker
    base_name=${base_name//','/}
    base_name="${base_name/'_-_'/'-'}" 
    filename="${base_name}-${resolution}.${file_ending}"

    # clear keyboard buffer
    # while read -e -t 0.1; do : ; done

    gr.debug "fixed name: ${filename}" #!debug

    ## Audio select loop
    while true; do

        # printout header
        gr.msg -h "#   ${list[0]}"

        # printout audio selection menu, red are non compatible formats
        for (( i = 1; i < ${#audio_list[@]}; i++ )); do
            number_color="-h"

            if echo ${audio_list[$i]} | grep -q "unknown" ; then
                continue
            elif echo ${audio_list[$i]} | grep -q '\[en' ; then
                color=lime
            elif echo ${audio_list[$i]} | grep -q '\[fi' ; then
                color=aqua
            elif echo ${audio_list[$i]} | grep -q '\[de' ; then
                color=white
            else
                color=gray
                number_color="-c gray"
            fi

            # skip non supported audio type
            if [[ $file_ending == "mp4" ]] && echo ${audio_list[$i]} | grep -q "webm"; then
                color=red
                [[ $list_all ]] || continue
            elif [[ $file_ending == "webm" ]] && echo ${audio_list[$i]} | grep -q "m4a"; then
                color=red
                [[ $list_all ]] || continue
            fi

            gr.msg -n -h -w 4 "$i:"
            gr.msg -c $color "${audio_list[$i]}"
        done

        # process audio selection
        read -p "select audio: " ans

        # quit
        if [[ $ans == "q" ]]; then
            echo
            return 12
        # toggle all items view (default is off)
        elif [[ $ans == "a" ]]; then
            [[ $list_all ]] && list_all= || list_all=true
            continue
        # select best audio (last on list)
        elif [[ $ans == "b" ]] || [[ $ans == "" ]]; then
            audio="$(cut -d " " -f1 <<<${audio_list[${#audio_list[@]}]})"
            a_size="$(echo ${audio_list[${#audio_list[@]}]} | cut -d " " -f6 | cut -d "x" -f1)"
            break
        # select worst audio (first on list)
        elif [[ $ans == "w" ]]; then
            audio="$(cut -d " " -f1 <<<${audio_list[0]})"
            a_size="$(echo ${audio_list[0]} | cut -d " " -f6 | cut -d "x" -f1)"
            break
        # check answer is number
        elif ! [[ $ans =~ ^[0-9]+$ ]] || [[ $ans -lt 1 ]] || [[ $ans -gt ${#audio_list[@]} ]]; then
            gr.msg -N "please select 1..${#audio_list[@]} 'a' for all audio files, or 'q' to exit"
            continue
        # all fine
        else
            audio=$(cut -d " " -f1 <<<${audio_list[$ans]})
            a_size="$(echo ${audio_list[$ans]} | cut -d " " -f7 | cut -d "x" -f1)"
            break
        fi
    done

    gr.varlist "debug audio a_size" #!debug
    
    gr.debug "starting audio download" #!debug
    gr.varlist "debug save_location base_name" #!debug

    ### audio download

    if [[ $audio_only ]];then
        gr.debug "output file: ${save_location}/$base_name.mp3" #!debug
        # check existence
        if [[ -f "${save_location}/$base_name.mp3" ]]; then
            if gr.ask "${save_location}/$base_name.mp3 exist, overwrite?"; then
                rm "${save_location}/$base_name.mp3"
            else
                return 0
            fi
        fi


        # yt-dlp -q --progress -x --audio-format mp3 --ignore-errors --continue --no-overwrites  --output "${save_location}/$base_name.mp3" -f $audio "$url" 2>/tmp/$USER/youtube.error
        # --no-playlist --remote-components ejs:github --js-runtimes $deno
        # download audio and convert it to mp3
   
        if [[ $GRBL_DEBUG ]]; then 
            yt-dlp --no-playlist $youtube_remote_java $youtube_java \
               -q --progress -x --audio-format mp3 --ignore-errors --continue --no-overwrites \
               --output "${save_location}/$base_name.mp3" \
               -f $audio "$url" 2>/tmp/youtube.error
              gr.ask "contunue?" || return 104
        fi 

        if yt-dlp --no-playlist $youtube_remote_java $youtube_java \
                -q --progress -x --audio-format mp3 --ignore-errors --continue --no-overwrites \
                --output "${save_location}/$base_name.mp3" \
                -f $audio "$url" 2>/tmp/youtube.error
        then
            # check file is created
            if [[ -f ${save_location}/${base_name}.mp3 ]]; then
                gr.msg -n -c green "saved to "
                gr.msg -c white "${save_location}/${base_name}.mp3"
                echo "${save_location}/${base_name}.mp3" | xclip -i -selection clipboard
                return 0
            else # file not created
                gr.msg -e2 "error during download"
                [[ $TUBES_LIMIT_VERBOSE -gt 0 ]] && cat /tmp/youtube.error
                return 128
            fi
        else
            # yt-dlp error
            gr.msg -e1 "failed get data from youtube"
            [[ $TUBES_LIMIT_VERBOSE -gt 0 ]] && cat /tmp/youtube.error
            return 129
        fi
    fi

    gr.debug "output file: ${save_location}/$filename" #!debug

    ### video download
    if [[ -f "${save_location}/$filename" ]]; then
        if gr.ask "${save_location}/$filename exist, overwrite?"; then
            rm "${save_location}/$filename"
        else
            return 0
        fi
    fi

    # information to user
    gr.msg -v2 -c dark_gray "selected: $quality+$audio resolution: $resolution, video: ${v_size} audio: ${a_size}"
    gr.msg -n -v2 -c white "downloading "
    gr.msg -v1 -c white "${url}"

    # combine video and audio selections
    selected="$quality+$audio"
    gr.varlist "debug selected" #!debug

    if [[ $GRBL_DEBUG ]]; then 
        yt-dlp --no-playlist $youtube_remote_java $youtube_java \
               -q --progress --ignore-errors --continue --write-auto-sub --sub-lang "$TUBES_YOUTUBE_SUB_LANG" --no-overwrites \
               --output "${save_location}/${filename}" \
               $selected "$url" 2>/tmp/youtube.error

          gr.ask "contunue?" || return 104
    fi 

    # make download
    if yt-dlp --no-playlist $youtube_remote_java $youtube_java \
            -q --progress --ignore-errors --continue --write-auto-sub --sub-lang "$TUBES_YOUTUBE_SUB_LANG" --no-overwrites \
           --output "${save_location}/${filename}" \
            $selected "$url" 2>/tmp/youtube.error
    then
        # check file is created
        if [[ -f ${save_location}/${filename} ]]; then
            gr.msg -n -c green "saved to "
            gr.msg -c white "${save_location}/${filename}"
            echo ${save_location}/${filename} | xclip -i -selection clipboard
            return 0
        else
            # file not created
            gr.msg -e2 "error during download"
            [[ $TUBES_LIMIT_VERBOSE -gt 0 ]] && cat /tmp/youtube.error
            return 128
        fi
    else
        # yt-dlp error
        gr.msg -e1 "failed get data from youtube"
        [[ $TUBES_LIMIT_VERBOSE -gt 0 ]] && cat /tmp/youtube.error
        return 129
    fi
}


youtube.get_audio () {
# download audio from tube by youtube id
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    local id=$1
    local url_base="https://www.youtube.com/watch?v"
    local save_location=$(pwd)

    # Check save location
    if [[ $TUBES_SAVE_LOCATION ]]; then 
        
        if [[ -d  $TUBES_SAVE_LOCATION ]]; then 
            save_location=$TUBES_SAVE_LOCATION
        else
            gr.msg -e1 "$TUBES_SAVE_LOCATION is not exists"
            if gr.ask "greate it?" ; then 
                mkdir -p $TUBES_SAVE_LOCATION 
            else 
                gr.msg -e "unable to continue, pls. edit $youtube_cfg" 
                return 123
            fi
        fi
    fi

    [[ -d $save_location/new ]] || mkdir -p $save_location/new

    # check is installed
    yt-dlp --version || youtube.install

    # inform user
    gr.msg -c white "downloading $url_base=$id to $save_location.. "

    # download and convert to mp3 format, then save to audio base location named by title
    yt-dlp --no-playlist $youtube_remote_java $youtube_java \
           -x --audio-format mp3 --ignore-errors --continue --no-overwrites \
           --output "$save_location/%(title)s.%(ext)s" \
           "$url_base=$id"
    return $?
}


youtube.play () {
# play input file
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    # check is user input url or id
    echo "$@" | grep -q "https://" && base_url="" || base_url="https://www.youtube.com/watch?v="

     # debug stuff (TBD remove later)
    gr.debug "$FUNCNAME save_to_file" "$save_to_file" #!debug
    gr.debug "$FUNCNAME youtube_options" "$youtube_options" #!debug
    gr.debug "$FUNCNAME module_command" "${module_command[@]}" #!debug
    gr.debug "$FUNCNAME mpv_options" "$mpv_options" #!debug
    gr.debug "$FUNCNAME save_location" "$save_location" #!debug

    # set playing and saving options and generate url
    local media_address="$base_url$1"

    # indicate playing
    gr.msg -c dark_grey "$media_address" # -k $GRBL_AUDIO_INDICATOR_KEY

    # get steam and play
    gr.debug "$FUNCNAME yt-dlp $youtube_options $media_address -o - | mpv $mpv_options -" #!debug

    yt-dlp --no-playlist $youtube_remote_java $youtube_java $youtube_options $sing_in_option $media_address -o - 2>$youtube_error | mpv $mpv_options -
    local _error=$?
    gr.debug "$FUNCNAME _error:$_error" #!debug

    # if ! grep 'Sign in to' $youtube_error; then
    #     [[ -f $mpv_error ]] && rm $mpv_error
    #     [[ -f $youtube_error ]] && rm $youtube_error

    # remove playing indications
    gr.msg -c reset # -k $GRBL_AUDIO_INDICATOR_KEY

    (( $_error > 0 )) && gr.msg -c yellow "${FUNCNAME[0]} returned $_error"
    return $_error
}


youtube.upgrade() {
# upgrade needed tools, youtube do changes often and shit causing weird errors
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    youtube.venv

    [[ -f /usr/local/bin/yt-dlp ]] && rm /usr/local/bin/yt-dlpq

    # get new version of
    sudo wget https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -O /usr/local/bin/yt-dlp
    sudo chmod a+rx /usr/local/bin/yt-dlp
    pip3 install --upgrade pip || rm -r ~/.cache/pip/selfcheck/ && pip3 install --upgrade pip
    pip3 install --upgrade yt-dlp
    return 0
}


youtube.install() {
# install requirements
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug
    
    local command=$1
    shift 

    local apt_require=(python3-venv mpv ffmpeg detox python3-pip jq pipx imagemagick python3-full g++)

    case $command in 
        
        check) 
            gr.msg -v2 -n "checking requirements.. "
            local install_required=
            
            for install in ${apt_require[@]} ; do
                
                if apt list -i $install 2>/dev/null >/dev/null | grep installed; then 
                    true #gr.msg -v2 -n -c green "$install " 
                else
                    gr.msg -v2 -n -c red "$install " 
                    install_required=true
                fi
            done

            if [[ -z $install_required ]]; then                 
                gr.msg -v2 -c green "ok" 
            else
                if gr.ask -h "install requrements?" ; then 
                    GRBL_FORCE=true
                else
                    return 0        
                fi
            fi
            ;;
    esac
    
    sudo apt-get update

    # ask 'n' install 
    for install in ${apt_require[@]} ; do
        apt list -i $install 2>/dev/null | grep -q installed && continue
        gr.ask -H $install "install $install?" || continue
        sudo apt-get -y install $install
    done

    # setup/active environment
    youtube.venv 

    # install tiv
    if ! [[ -f /usr/local/bin/tiv ]]; then
        if gr.ask "compile terminal image view (tiv)?"; then
            cd /tmp
            git clone https://github.com/stefanhaustein/TerminalImageViewer.git
            cd TerminalImageViewer/src
            make
            sudo make install
        fi
    fi

    ## TODO tähän testeri
    if gr.ask "install youtube-search?"; then 
        pip3 install --upgrade pip
        pip3 install youtube-search
    fi

    # install patched yt-dlp
    if [[ -f /usr/local/bin/yt-dlp ]]; then 
        if gr.ask "install patched yt-dlp?"; then 
            sudo wget https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -O /usr/local/bin/yt-dlp
            sudo chmod a+rx /usr/local/bin/yt-dlp
        fi
    fi
    
    touch $youtube_data/installed
   
    gr.ask "Following steps are EXPERIMENTAL, may have issues what comes to security, still go?" || return 123
    
    if gr.ask "install java environment for youtube problem solver?"; then 

        ## EXPERIMENTAL, may have issues what comes to security
        curl -Lo "/tmp/deno.zip" "https://github.com/denoland/deno/releases/latest/download/deno-x86_64-unknown-linux-gnu.zip"

        # alternative
        # if [ -z "$deno_version" ]; then
        # deno_version="$(curl -s https://dl.deno.land/release-latest.txt)"
        # fi
        # deno_uri="https://dl.deno.land/release/${deno_version}/deno-${target}.zip"
        # deno_install="${DENO_INSTALL:-$HOME/.deno}"

        if ! [[ -f /tmp/deno.zip ]]; then 
            gr.msg -c yellow "Unable to install java runtime, downloading videos will not work"
        fi
        sudo unzip -d /usr/local/bin /tmp/deno.zip
    fi

}

youtube.uninstall(){
# remove requirements
    gr.msg -v4 -n -c $__youtube_color "$__youtube [$LINENO] $FUNCNAME: " >&2 ; [[ $GRBL_DEBUG ]] && echo "'$@'" >&2 #!debug

    # remove only youtube special requiderements, leave players etc.
    #[[ -f /usr/bin/yt-dlp ]] && rm -y /usr/bin/yt-dlp

    [[ -f /usr/local/bin/yt-dlp ]] && rm -y /usr/local/bin/yt-dlp
    pip3 uninstall youtube-search
    sudo rm /usr/local/bin/deno
    gr.msg -c green "uninstalled"
    rm $youtube_data/installed
}

if [[ "$1" == "help" ]]; then 
    # GRBL_VERBOSE=3
    youtube.help 
    exit 0        
fi 

# get configs and set variables
youtube.rc

declare -g mpv_options="--input-ipc-server=$TUBES_MPV_SOCKET_FILE "
[[ $TUBES_LIMIT_VERBOSE -lt 1 ]] && mpv_options="$mpv_options --really-quiet "
# export GRBL_VERBOSE=$TUBES_LIMIT_VERBOSE

# run main only if run, not sourced
if [[ ${BASH_SOURCE[0]} == ${0} ]]; then
    
    runtime=$(which deno)
    if [[ $runtime ]]; then 
        youtube_java="--js-runtimes $(which deno)"
    else
        gr.msg -e1 "java runtime environment not installed, may have issues to solve youtube problems"
    fi

    gr.varlist "debug GRBL_VERBOSE GRBL_COLOR GRBL_DEBUG TUBES_MPV_SOCKET_FILE TUBES_LIMIT_VERBOSE TUBES_LIMIT_SEARCH_RESULT TUBES_LIMIT_THUMBNAIL_SIZE  TUBES_NOWPLAYING_FILE TUBES_COOKIE_BROWSER TUBES_YOUTUBE_USER TUBES_YOUTUBE_SUB_LANG" #!debug
    
    if ! [[ -f $youtube_data/installed ]]; then 
        gr.msg -h "Need to install some software first"
        youtube.install 
        youtube.upgrade 
    fi

    youtube.venv && \
    youtube.main $@
fi