timer

#!/usr/bin/env bash

# ╺┳╸╻┏┳┓┏━╸┏━┓
#  ┃ ┃┃┃┃┣╸ ┣┳┛
#  ╹ ╹╹ ╹┗━╸╹┗╸
# set timers

set -eou pipefail

PROG="${0##*/}"
DURATION="${1:-}"
TIMER_NAME="${2:-}"
ICON=""
ICON=""
DEPS=(notify-send dmenu mpv)

# files
SOUND="$HOME"/bin/assets/alarm-beepbeep.mp3
PIDFILE="/tmp/$PROG.pid"
TIMEFILE="/tmp/$PROG.time"
MPVPID="/tmp/$PROG.mpv"

# TODO:
# - [ ] add support for multiple timers (unique names)

function _notifyme {
    declare -a notify_args=(-r 888 --icon="alarm-timer")
    prog=$(echo "$PROG" | tr '[:lower:]' '[:upper:]')
    notify_args+=("$prog")
    notify-send "${notify_args[@]}" "$*"
}

function _logerr {
    local msg="$1"
    printf "%s: %s\n" "$PROG" "$msg" >&2
    _notifyme "$msg"
    exit 1
}

function _logme {
    printf "%s: %s\n" "$PROG" "$1"
}

function _has {
    local c
    local verbose=false
    if [[ $1 == '-v' ]]; then
        verbose=true
        shift
    fi
    for c in "$@"; do
        c="${c%% *}"
        if ! command -v "$c" &>/dev/null; then
            [[ "$verbose" == true ]] && _logerr "$c not found"
            return 1
        fi
    done
}

function _checkdeps {
    _has -v "${DEPS[@]}"
    if [[ ! -e "$SOUND" ]]; then
        _logerr "timer file not found: $SOUND"
    fi
}

function pre_exit {
    local files=("$TIMEFILE" "$PIDFILE")
    for f in "${files[@]}"; do
        [[ -e "$f" ]] && rm -f "$f"
    done
    _logme "cleaning up..."
    _notifyme "timer finished"
    exit 0
}

function usage {
    cat <<-EOF
Usage: $PROG [[+|-<duration>]]

    Sets timers

Options:
    status          Show current status
    cancel, stop    Remove current timer
EOF
}

function _get_random_str {
    echo "$RANDOM" | base64 | head -c5 | tr '[:upper:]' '[:lower:]'
}

function _interpret_time {
    local input last_char time
    if [[ ${#1} -eq 1 ]]; then
        input="${1}m"
    else
        input="$1"
    fi

    last_char="${input: -1}"
    time="${input:0:-1}"

    if [[ "$last_char" == "m" ]]; then
        time=$((time * 60))
    elif [[ "$last_char" == "s" ]]; then
        time=$((time))
    elif [[ "$last_char" == "h" ]]; then
        time=$((time * 60 * 60))
    else
        _logerr "invalid input: $input"
    fi

    echo "$time"
}

function _cancel_timer {
    if [[ -e "$MPVPID" ]]; then
        kill -9 "$(cat "$MPVPID")" &>/dev/null
        rm "$MPVPID"
    fi

    if [[ ! -e "$PIDFILE" ]]; then
        _logme "no timer found"
        return
    fi

    _logme "timer '$TIMER_NAME' cancelled"
    kill -9 "$(cat "$PIDFILE")" &>/dev/null

    pre_exit
}

function _save_pid {
    echo "$1" | tee "$PIDFILE" >/dev/null
}

function _save_timestamp {
    echo "$1" | tee "$TIMEFILE" >/dev/null
}

function _get_timestamp {
    cat "$TIMEFILE"
}

function _update_timestamp {
    echo "${1:-0}" | tee "$TIMEFILE" >/dev/null
}

function _update_time {
    local time new_time current
    if [[ ! -e "$TIMEFILE" ]]; then
        err_msg="no timer found"
        _notifyme "$err_msg"
        _logerr "$err_msg"
    fi
    time=$(_interpret_time "${1:-0}")
    current=$(_get_timestamp)
    new_time=$((current + time))
    _update_timestamp "$new_time"
}

function _show_status {
    local current time result
    local time_diff_hours time_diff_minutes time_diff_seconds

    if [[ ! -f "$TIMEFILE" ]]; then
        return 1
    fi

    current=$(date +%s)
    time=$(_get_timestamp)
    time_diff=$((time - current))

    if [[ "$time_diff" -lt 0 ]]; then
        return 1
    fi

    time_diff=${time_diff#-}

    if [[ $time_diff -ge 3600 ]]; then
        time_diff_hours=$((time_diff / 3600))
        time_diff=$((time_diff % 3600))
        time_diff_minutes=$((time_diff / 60))
        time_diff_seconds=$((time_diff % 60))
        result="${time_diff_hours}h ${time_diff_minutes}m ${time_diff_seconds}s"
    elif [[ $time_diff -ge 60 ]]; then
        time_diff_minutes=$((time_diff / 60))
        time_diff_seconds=$((time_diff % 60))
        result="${time_diff_minutes}m ${time_diff_seconds}s"
    else
        result="${time_diff}s"
    fi

    echo "$result"
}

function _sound_the_alarm {
    _notifyme "timer <b>'$TIMER_NAME'</b> is up!!!"
    mpv "$SOUND" --mute=no --loop-file=10 --no-resume-playback >/dev/null 2>&1 &
    mpv_pid=$!
    echo "$mpv_pid" >"$MPVPID"
}

function _validate_input {
    local input="$1"
    if [[ $input =~ [0-9] ]]; then
        return 0
    else
        return 1
    fi
}

function _set_timer {
    trap pre_exit EXIT SIGTERM SIGINT

    local duration="$1"
    local name="$2"
    local current current_time
    current=$(date +%s)
    duration=$(_interpret_time "$duration")
    current_time=$((current + duration))
    _save_timestamp "$current_time"

    _notifyme "setting $(_show_status) timer for '$name'"

    while true; do
        current=$(date +%s)
        time=$(_get_timestamp)
        time_diff=$((current - time))
        time_diff=${time_diff#-}
        if [[ $time_diff -le 0 ]]; then
            break
        fi
        sleep 1s
    done

    _sound_the_alarm
}

function _get_input {
    local data
    local prompt="$1"
    data=$(: | dmenu -i -p "$ICON $prompt")
    echo "$data"
}

function _get_duration {
    local icon=""
    DURATION=$(: | dmenu -i -p "$icon Duration:")
    echo "$DURATION"
}

function parse_and_exit {
    case "$1" in
    status)
        _show_status
        exit 0
        ;;
    -h | --help | help)
        usage
        exit 1
        ;;
    cancel | stop | kill)
        _cancel_timer
        ;;
    +* | -*)
        _update_time "$@"
        exit 0
        ;;
    *) ;;
    esac
}

function main {
    local opt="${1:-}"
    parse_and_exit "$opt"
    _checkdeps
    if [[ -z "$DURATION" ]]; then
        DURATION=$(_get_input "Duration>")
    fi

    [[ -z "$DURATION" ]] && exit 1
    if ! _validate_input "$DURATION"; then
        _logerr "invalid duration: $DURATION"
    fi

    [[ -z "$TIMER_NAME" ]] && TIMER_NAME="${DURATION}-$(_get_random_str)"

    _save_pid "$$" "$TIMER_NAME"
    _set_timer "$DURATION" "$TIMER_NAME"
}

main "$@"