#!/bin/sh
# Requires: curl, jq, a Nerd Font (the glyphs are nf-md-*), and linecast plus a
# terminal for the `detail` action.
# Weather for the bar, straight from the US National Weather Service. It began
# as polybar-scripts' openweathermap-fullfeatured, but against api.weather.gov,
# so there is no API key to keep out of the repo. The trade is that NWS only
# covers the US and its territories: /points returns 404 for anywhere else and
# the module goes blank.
#
# The bar gets current conditions and nothing else -- an icon and a temperature,
# the same shape as every other module here. The forecast is a click away.
#
#   weather          one line for the bar (the default)
#   weather detail   opens $TERMINAL on `linecast weather` for the full forecast
#
# NWS asks callers for a contactable User-Agent and for restraint, and this
# honours both. The grid lookup is cached for a day because a grid square does
# not move, and the rendered line for NWS_INTERVAL seconds, so the polybar
# restarts that screenchange-reload makes routine cost no requests at all. A
# failed fetch falls back to the last good line rather than blanking the bar.
set -u

# The location, in decimal degrees. There is no geolocation lookup here -- set
# both, in modules/weather.ini or in the environment, or the module stays blank
# and says why on stderr.
LAT=${NWS_LAT:-}
LON=${NWS_LON:-}
# us = degrees F, si = degrees C. Passed straight through to NWS for the
# forecast; observations always arrive in Celsius and are converted here.
UNITS=${NWS_UNITS:-us}
# Seconds a rendered line is reused before refetching. The module may poll
# faster than this -- it just gets the cache back until this expires.
INTERVAL=${NWS_INTERVAL:-900}
# NWS wants a User-Agent it can contact about a misbehaving client; an email
# address or a URL is what they ask for. Put yours here.
UA=${NWS_UA:-"polybar-nws (https://github.com/polybar/polybar-scripts)"}
# Polybar colour markup, left empty so the script prints plain text anywhere
# else. modules/weather.ini fills both in from colors.ini, which is where the
# palette belongs -- nothing in here should need editing to match the bar.
ICON_COLOR=${NWS_ICON_COLOR:-}
ALERT_COLOR=${NWS_ALERT_COLOR:-}
# 1 names the active alert on the bar as well as flagging it. Off by default:
# "Severe Thunderstorm Warning" is wider than everything else put together,
# and it is one click away in `detail` either way.
SHOW_ALERT_LABEL=${NWS_SHOW_ALERT_LABEL:-0}

SYMBOL=°
API=https://api.weather.gov
CACHE=${XDG_CACHE_HOME:-$HOME/.cache}/polybar-nws
GRID=$CACHE/grid
# Icon, temperature and alert event, tab separated -- deliberately not the
# finished bar string. The colours arrive from the module, so a bare run from a
# shell has none; caching a painted line would let whichever ran last decide
# how the bar looked for the next quarter hour, and would freeze the palette
# in until the cache expired.
LINE=$CACHE/line
# How long the /points and station lookup is trusted. The square does not move
# now that the coordinates are pinned, but stations do come and go, so the
# lookup is redone daily.
GRID_TTL=86400

# NWS condition token -> glyph. $1 is day or night, $2 the token lifted out of
# the icon URL; the full token list is at https://api.weather.gov/icons.
#
# These are nf-md (Material Design) glyphs, the family every other module here
# draws from. nf-weather has a finer-grained set, but it is a visibly lighter
# weight and read as pasted-in next to the solid icons around it.
#
# Every glyph below was checked at 13pt against the bar's own font. Material
# only splits day from night for clear and partly cloudy skies; nothing else
# needs it, since rain looks like rain whatever the hour.
get_icon() {
    case $2 in
        skc)                          d='󰖙'; n='󰖔';;
        few|sct)                      d='󰖕'; n='󰼱';;
        bkn|ovc)                      d='󰖐'; n='󰖐';;
        wind_skc|wind_few|wind_sct|wind_bkn|wind_ovc)
                                      d='󰖝'; n='󰖝';;
        rain)                         d='󰖖'; n='󰖖';;
        rain_showers|rain_showers_hi) d='󰖗'; n='󰖗';;
        tsra|tsra_sct|tsra_hi)        d='󰙾'; n='󰙾';;
        snow)                         d='󰖘'; n='󰖘';;
        blizzard)                     d='󰼶'; n='󰼶';;
        sleet|fzra|rain_snow|rain_sleet|snow_sleet|rain_fzra|snow_fzra)
                                      d='󰙿'; n='󰙿';;
        fog)                          d='󰖑'; n='󰖑';;
        haze|dust)                    d='󰼰'; n='󰼰';;
        smoke)                        d='󰩱'; n='󰩱';;
        hot)                          d='󱃂'; n='󱃂';;
        cold)                         d='󱃃'; n='󱃃';;
        tornado)                      d='󰼸'; n='󰼸';;
        hurricane|tropical_storm)     d='󰢘'; n='󰢘';;
        *)                            d='󰼯'; n='󰼯';;
    esac

    if [ "$1" = night ]; then printf '%s' "$n"; else printf '%s' "$d"; fi
}

# The condition lives in the icon URL's path, not in a field of its own:
#   .../icons/land/day/tsra_hi,40/tsra,60?size=medium
# Prints "day tsra_hi" -- the leading period wins, and both the ",40" chance
# suffix and any second period are dropped.
icon_parts() {
    printf '%s' "${1%%\?*}" | awk -F/ '
        {
            for (i = 1; i < NF; i++)
                if ($i == "day" || $i == "night") {
                    sub(/,.*/, "", $(i + 1))
                    print $i, $(i + 1)
                    found = 1
                    exit
                }
        }
        END { if (!found) print "day unknown" }'
}

# curl with the headers NWS expects, plus a retry: gridpoint requests return
# a 500 often enough that one attempt is not a fair test.
fetch() {
    curl -sfL --compressed --max-time 8 --retry 2 --retry-delay 1 \
        -H "User-Agent: $UA" -H "Accept: application/geo+json" "$1"
}

# $2 wrapped in polybar's colour markup, or left alone when $1 is empty.
paint() {
    if [ -n "$1" ]; then printf '%%{F%s}%s%%{F-}' "$1" "$2"; else printf '%s' "$2"; fi
}

# The bar line, built from the three cached fields: glyph, temperature, and the
# active alert event (empty when there is none). Painting happens here, at the
# last possible moment, so the module's colours apply to a cached reading too.
#
# The trailing space goes *inside* the colour run. polybar clips each %{F...}
# segment at the advance width of the text in it, and these glyphs draw wider
# than the single cell they advance -- put the space after the %{F-} and the
# overflow is cut off, leaving a half-rendered blob. It is the same reason
# every other module here writes format-prefix = "<glyph> " rather than
# hanging the space off the label.
format_line() {
    line="$(paint "$ICON_COLOR" "$1 ")$2$SYMBOL"
    if [ -n "$3" ]; then
        if [ "$SHOW_ALERT_LABEL" = 1 ]; then flag="󰀦 $3"; else flag='󰀦'; fi
        line="$(paint "$ALERT_COLOR" "$flag ")$line"
    fi
    printf '%s\n' "$line"
}

# One field out of a JSON blob on stdin's place, empty rather than "null".
j() { printf '%s' "$1" | jq -r "$2 // empty" 2>/dev/null; }

# Seconds since $1 was last written; effectively infinite if it is not there.
age() {
    if [ -f "$1" ]; then
        echo $(( $(date +%s) - $(stat -c %Y "$1") ))
    else
        echo 999999999
    fi
}

# Observations are always Celsius no matter what ?units= asked for, so the
# conversion happens here rather than being left to the API.
c_to_display() {
    [ -n "${1:-}" ] || return 1
    if [ "$UNITS" = us ]; then
        awk -v c="$1" 'BEGIN { printf "%.0f", c * 9 / 5 + 32 }'
    else
        awk -v c="$1" 'BEGIN { printf "%.0f", c }'
    fi
}

# Whether $obs is recent enough to show as "now". Stations that report hourly
# routinely skip a cycle, so the cutoff is two hours; past that the forecast is
# the better answer. busybox date cannot parse an ISO stamp with an offset, and
# jq's fromdateiso8601 insists on a "Z" -- NWS only ever sends "+00:00", so that
# is the one offset translated, and anything else counts as fresh rather than
# throwing away a good observation over a timestamp this cannot read.
fresh_obs() {
    [ -n "$obs" ] || return 1
    ts=$(j "$obs" '.properties.timestamp | sub("\\+00:00$"; "Z") | fromdateiso8601')
    [ -n "$ts" ] || return 0
    [ $(( $(date +%s) - ts )) -lt 7200 ]
}

# Resolve coordinates to the three URLs everything else needs, and cache them.
# NWS models the country as a grid of 2.5km squares; /points is the only way
# to learn which square a latitude and longitude fall in, and the answer is
# stable, so this runs once a day at most.
resolve_grid() {
    if [ -z "$LAT" ] || [ -z "$LON" ]; then
        echo "${0##*/}: set NWS_LAT and NWS_LON to the location you want" >&2
        return 1
    fi

    # NWS caps coordinate precision at four decimals: /points answers anything
    # longer with a 301 to the truncated form, and /alerts just returns a 500.
    # Round here so neither can surprise a hand-set NWS_LAT.
    loc=$(printf '%s' "$LAT,$LON" | awk -F, '{ printf "%.4f,%.4f", $1, $2 }')

    points=$(fetch "$API/points/$loc") || return 1
    hourly=$(j "$points" '.properties.forecastHourly')
    stations=$(j "$points" '.properties.observationStations')
    [ -n "$hourly" ] && [ -n "$stations" ] || return 1

    # The station list is not sorted by distance despite looking like it is --
    # for Denver it leads with an airport 24km up the highway -- so pick the
    # nearest one properly. Flat-earth distance with a cosine correction on the
    # longitude is plenty over the handful of kilometres in play here.
    station=$(fetch "$stations" | jq -r --argjson lat "${loc%,*}" --argjson lon "${loc#*,}" '
        [ .features[]
          | { id: .properties.stationIdentifier,
              dx: ((.geometry.coordinates[0] - $lon) * (($lat * 3.14159265 / 180) | cos)),
              dy: (.geometry.coordinates[1] - $lat) } ]
        | min_by(.dx * .dx + .dy * .dy)
        | .id // empty')
    [ -n "$station" ] || return 1

    mkdir -p "$CACHE"
    printf '%s\n%s\n%s\n' "$hourly" "$station" "$loc" > "$GRID"
}

# Populates grid_hourly, grid_station and grid_point.
load_grid() {
    if [ "$(age "$GRID")" -gt "$GRID_TTL" ]; then
        resolve_grid || [ -f "$GRID" ] || return 1
    fi
    grid_hourly=$(sed -n 1p "$GRID")
    grid_station=$(sed -n 2p "$GRID")
    grid_point=$(sed -n 3p "$GRID")
    [ -n "$grid_hourly" ]
}

# NWS hands back active alerts in no particular order, so severity has to be
# sorted on rather than assumed -- the bar only ever shows the worst one. The
# severity has to be bound before the ranking array is piped in, or the index
# lookup reads .severity off the array instead of off the alert.
ALERT_ORDER='[.features[].properties]
    | sort_by((.severity // "Unknown") as $s
              | (["Extreme", "Severe", "Moderate", "Minor"] | index($s)) // 9)'

# The most serious active alert for our point, or nothing.
active_alert() {
    fetch "$API/alerts/active?point=$grid_point" | jq -r "$ALERT_ORDER | .[0].event // empty"
}

render() {
    load_grid || return 1

    temp=
    icon_url=
    obs=$(fetch "$API/stations/$grid_station/observations/latest")

    # The observation is a real measurement and is what "now" ought to mean.
    if fresh_obs; then
        temp=$(c_to_display "$(j "$obs" '.properties.temperature.value')") || temp=
        icon_url=$(j "$obs" '.properties.icon')
    fi

    # Small stations drop out for hours at a time, and a four-hour-old reading
    # is worse than none. Period 1 of the hourly forecast covers the current
    # hour and stands in when that happens -- which is why this request sits
    # down here rather than up beside the observation: in the ordinary case the
    # station answers and it never runs at all.
    if [ -z "$temp" ] || [ -z "$icon_url" ]; then
        hourly=$(fetch "$grid_hourly?units=$UNITS")
        [ -n "$temp" ] || temp=$(j "$hourly" '.properties.periods[0].temperature')
        [ -n "$icon_url" ] || icon_url=$(j "$hourly" '.properties.periods[0].icon')
    fi

    [ -n "$temp" ] || return 1
    # NWS sends whole numbers today; this is here so a stray decimal cannot
    # turn up inside the bar label.
    temp=${temp%%.*}

    # Unquoted on purpose: icon_parts prints the two arguments get_icon takes.
    icon=$(get_icon $(icon_parts "$icon_url"))
    alert=$(active_alert)

    mkdir -p "$CACHE"
    printf '%s\t%s\t%s\n' "$icon" "$temp" "$alert" > "$LINE"
    format_line "$icon" "$temp" "$alert"
}

# The cached reading, repainted with whatever colours this run was given.
# Fails on a missing file, and on the painted single-field line older versions
# of this script wrote, so either one just falls through to a fresh fetch.
show_cached() {
    [ -f "$LINE" ] || return 1
    IFS=$(printf '\t') read -r icon temp alert < "$LINE" || return 1
    [ -n "$temp" ] || return 1
    format_line "$icon" "$temp" "$alert"
}

# The bar line, from cache when it is still fresh. A failed fetch prints the
# last good line however old it is: a stale temperature is more use on a bar
# than a module that vanishes whenever the wifi hiccups.
bar() {
    if [ "$(age "$LINE")" -lt "$INTERVAL" ] && show_cached; then
        return 0
    fi
    render && return 0

    # Nothing new and nothing cached is either the first run without a network
    # or a location NWS does not cover. Say so on stderr, where polybar's log
    # will keep it, and exit clean so polybar does not treat it as a crash.
    show_cached ||
        echo "${0##*/}: no forecast (offline, or outside NWS coverage)" >&2
    return 0
}

# Everything that does not fit on the bar. linecast already draws the whole
# thing -- hourly curve, alerts, sun times -- in a terminal, and does it better
# than a notification body can, so the click just opens it. exec because
# nothing here needs to outlive the terminal.
#
# $TERMINAL comes from the shell profile, which polybar only inherits if it was
# started from a login session; wezterm is the fallback so a click still works
# when it was not. -e is what wezterm, alacritty, kitty and xterm all take.
detail() {
    exec "${TERMINAL:-wezterm}" -e linecast weather
}

case "${1:-bar}" in
    bar)    bar ;;
    detail) detail ;;
    *) echo "usage: ${0##*/} [bar|detail]" >&2; exit 2 ;;
esac