script

#!/bin/bash
# https://github.com/einstweilen/tvmenu
# 2022-12-29


if [ "$#" -eq 0 ]; then
    cached_sender="data/cached_sender.txt"
    cached_servicemenu="data/cached_servicemenu.txt"
    if [ -f "$cached_sender" ] && [ -f "$cached_servicemenu" ]; then
        cat "$cached_sender" "$cached_servicemenu"
        exit 0
    fi
fi

init(){
    DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" # Pfad zum Skript
    cd "$DIR" || exit
    DIR_DATA="$DIR/data"
    mkdir -p "$DIR_DATA"
    channels_file="$DIR_DATA/channels.txt" # ZAPP Sender, gefiltert und vorformatiert
    channels_backup_file="$DIR_DATA/channels_backup.txt" # falls Server nicht erreichbar
    channels_fixer="$DIR_DATA/channels_fix.txt" # zusätzliche Sender z.B. Ersatz für Streams mit '@'
    channels_all="$DIR_DATA/channels_all.txt" # channels_file + channels_fixer
    channels_menu_grup="$DIR_DATA/menu_gruppiert.txt" # Sendernamensliste MIT Gruppierung
    channels_menu_ohne="$DIR_DATA/menu_ohne.txt" # Sendernamensliste OHNE Gruppierung
    cached_sender="$DIR_DATA/cached_sender.txt" # Sendernamensliste wie im Menü angezeigt
    cached_servicemenu="$DIR_DATA/cached_servicemenu.txt" # Einstellungssubmenü
    channels_url='https://raw.githubusercontent.com/mediathekview/zapp/main/app/src/main/res/raw/channels.json'
    pref_file='com.einstweilen.tvmenu'
}

get_player(){
    defaults read "$pref_file" player 2>/dev/null || err=$?
    if [ $err ]; then # bei Fehler Default wiederherstellen
        defaults write "$pref_file" 'player' 'QuickTime'
        echo 'QuickTime'
    fi
}

get_submenu(){
    defaults read "$pref_file" submenus 2>/dev/null || err=$?
    if [ $err ]; then # bei Fehler Default wiederherstellen
        defaults write "$pref_file" 'submenus' 'an'
        echo 'aus'
    fi
}

check_VLC(){
    mdfind kind:application -name 'VLC' 2>/dev/null | grep -q 'VLC.app' && return 0 || return 1
}

close_player_windows(){
    if [[ "$1" == 'QuickTime' ]]; then
        osascript -e 'tell application "QuickTime Player" to close every window' >> /dev/null 2>&1
    else
        osascript -e 'tell application "VLC" to close every window' >> /dev/null 2>&1
    fi
}

stream_abspielen(){
    get_channels
    for channel in "${channels[@]}"; do
        sender="${channel%|*}"
        url="${channel##*|}"
        if [ "$sender" == "$1" ]; then
            player="$(get_player)"
            close_player_windows "$player"
            if [[ "$player" == 'QuickTime' ]]; then
                open -a 'QuickTime Player.app' -u "$url"
            else
                open -a 'VLC.app' -u "$url"
            fi
            exit 0
        fi
    done
    # Sender nicht gefunden
    exit 1
}

get_channels(){
    if [ ! -f "$channels_all" ]; then
        # Sender von ZAPP holen
        if [ ! -f "$channels_file" ]; then
            raw=$(curl -s --max-time 9 "$channels_url")
            if [ "$?" -eq 0 ]; then
                IFS=$'\n' ch_rw=($(grep '"name"' <<< "$raw")) ; unset IFS
                IFS=$'\n' url_rw=($(grep '"stream_url"' <<< "$raw")) ; unset IFS
                if [[ ${#ch_rw[*]} -eq ${#url_rw[*]} ]]; then
                    t='": "' # Trenner im JSON File
                    for ((i=0;i<${#ch_rw[*]}; i++)); do
                        n=${ch_rw[i]}; n=${n#*"$t"} ; n=${n:0:$((${#n} - 2))}
                        u=${url_rw[i]}; u=${u#*"$t"} ; u=${u:0:$((${#u} - 2))}
                        if [[ ! "$u" == *@* ]]; then # nur wenn kein @ in der StreamURL
                            n=${n//\\u00ad/} # Weiches Trennzeichen im Sendernamen entfernen
                            url_test=$(curl -sL "$u") 
                            if grep -q EXTM3U <<< "$url_test"; then
                                echo "$n|$u" | iconv -f UTF-8 -t UTF-8-MAC >> "$channels_file"
                            fi
                        fi
                    done
                else
                    # falls Fehler im JSON File sind, Backup einspielen
                    cp "$channels_backup_file" "$channels_file" 2>/dev/null || :
                fi
            else
                # falls der Server nicht erreichbar ist, Backupfile verwenden
                cp "$channels_backup_file" "$channels_file" 2>/dev/null || :
            fi
        fi
        # Sender aus statischer Datei hinzufügen
        # z.B. Ersatz für die NDR Sender, die von ZAPP nicht im QTP funktionieren
        if [ ! -f "$channels_fixer" ]; then
            touch "$channels_fixer"
        fi

        cat "$channels_file" "$channels_fixer" | sort -f  > "$channels_all"
        rm -f "$cached_sender" # erzwingt Menü Neugenerierung 
    fi
    unset channels
    IFS=$'\n' read -d '' -r -a channels < "$channels_all"
}

channels_update(){
    # fehlende Datei erzwingen Neugenerierung
    rm -f "$channels_all"
    rm -f "$channels_file"
    rm -f "$channels_menu_grup"
    rm -f "$channels_menu_ohne"
    menu_ausgeben
}

menu_ausgeben(){
    update_sendermenu
    update_servicemenu
    cat "$cached_sender" "$cached_servicemenu"
}

update_sendermenu(){
    if [ ! -f "$channels_menu_grup" ] || [ ! -f "$channels_menu_ohne" ] || [ ! -f "$cached_sender" ]; then
        # anzeigbare Sender ermitteln
        unset menu_items  # Inhalt der Sendermenüs
        unset sender_menu  # Sender die im Menü angezeigt werden
        unset sender_gruppen  # Lokalsender NDR Nds, NDR HH, NDR SH usw.
        get_channels
        for channel in "${channels[@]}"; do
            sender="${channel%|*}"
            url="${channel##*|}"
            sendername="$sender"
            sender_menu+=("$sendername")
            sender_gruppen+=("${sendername%% *}") # erstes Wort des Namens als Gruppenkennung
        done

        # Sendermenüs mit Gruppierung erzeugen
        IFS=$'\n' sender_menu=($(sort -f <<<"${sender_menu[*]}")); unset IFS
        IFS=$'\n' sender_gruppen=($(sort -f <<<"${sender_gruppen[*]}")); unset IFS
        # Sendergruppen anhand Mehrfachnennungen ermitteln
        gruppen_min=2 # Sendergruppe beginnt ab 2 Sendern in Sendergruppe
        unset gruppen_submenu # Sendergruppen mit eigenem Submenü
        temp="" ; temp_c=0
        for ((i=0;i<${#sender_gruppen[*]}; i++)); do
            if [[ ${sender_gruppen[i]} == "$temp" ]]; then
                ((temp_c++))
            else
                temp="${sender_gruppen[i]}"
                temp_c=1
            fi
            if [[ temp_c -ge gruppen_min ]] && [[ ! " ${gruppen_submenu[*]} " =~ ${sender_gruppen[i]} ]]; then
                gruppen_submenu+=("${sender_gruppen[i]}")
            fi
        done

        # Senderlistenmenu
        sender_submenu=""
        submenu_aktiv=false
        sender_menu+=('----') # Navigationstrenner nach letztem Sender einfügen
        gruppe_aktuell=""
        for sendername in "${sender_menu[@]}"; do
            gruppe="${sendername%% *}"
            if [[ " ${gruppen_submenu[*]} " =~ ${gruppe} ]]; then
                if [[ ${gruppe} != "${gruppe_aktuell}" ]]; then
                    if [[ $submenu_aktiv == true ]]; then
                        menu_items+=("${sender_submenu}")
                        submenu_aktiv=false
                    fi
                    sender_submenu="SUBMENU|${gruppe}"
                    gruppe_aktuell="$gruppe"
                    submenu_aktiv=true
                fi
                sender_submenu="${sender_submenu}|${sendername}"
            else
                if [[ $submenu_aktiv == true ]]; then
                    menu_items+=("${sender_submenu}")
                    submenu_aktiv=false
                    menu_items+=("${sendername}")
                else
                    menu_items+=("${sendername}")
                fi
            fi
        done
        printf "%s\n" "${menu_items[@]}" > "$channels_menu_grup"

        # Sendermenü ohne Gruppierung erzeugen
        printf "%s\n" "${sender_menu[@]}" > "$channels_menu_ohne"
    fi
    sender_menu_aktivieren
}

sender_menu_aktivieren(){
    submenu=$(get_submenu)
    if [[ $submenu == 'an' ]]; then
         cp "$channels_menu_grup" "$cached_sender" 2>/dev/null || :
    else
         cp "$channels_menu_ohne" "$cached_sender" 2>/dev/null || :
    fi

}

update_servicemenu(){
    # Einstellungssubmenü
    if check_VLC ; then
        # Playerauswahl nur anzeigen, wenn VLC installiert ist
        player=$(get_player)
        if [[ $player == 'QuickTime' ]]; then
            playermenuitem='VLC verwenden'
        else
            playermenuitem='QT Player verwenden'
        fi
    else # VLC Option ausgrauen
        playermenuitem='DISABLED|VLC verwenden'
    fi

    submenu=$(get_submenu)
    if [[ $submenu == 'an' ]]; then
        submenuitem='Gruppierung ausschalten'
    else
        submenuitem='Sender gruppieren'
    fi
    servicemenu="SUBMENU|Einstellungen|${submenuitem}|${playermenuitem}|----|Senderliste aktualisieren"
    printf "%s\n" "$servicemenu" > "$cached_servicemenu"
}

init
# Übergabeparameter auswerten
if [ "$#" -gt 0 ]; then
    parameter="$*"
    case "$parameter" in
        'Senderliste aktualisieren')
            channels_update
            ;;
        'VLC verwenden')
            if check_VLC ; then
                defaults write "$pref_file" 'player' 'VLC'
            fi
            ;;
        'QT Player verwenden')
            defaults write "$pref_file" 'player' 'QuickTime'
            ;;
        'Gruppierung ausschalten')
            defaults write "$pref_file" 'submenus' 'aus'
            ;;
        'Sender gruppieren')
            defaults write "$pref_file" 'submenus' 'an'
            ;;
        *)
            stream_abspielen "$parameter"
            exit 0
            ;;
    esac
    if [[ "$parameter" == 'VLC verwenden' ]] || [[ "$parameter" == 'QT Player verwenden' ]]; then
        update_servicemenu
    fi
    if [[ "$parameter" == 'Sender gruppieren' ]] || [[ "$parameter" == 'Gruppierung ausschalten' ]]; then
        update_servicemenu
        sender_menu_aktivieren
    fi
    cat "$cached_sender" "$cached_servicemenu"
    exit 0
else
    menu_ausgeben
fi
exit 0