timer

#!/usr/bin/env bash

# timer
# A lightweight, feature-rich timer program written entirely in bash
# See README.md for details

# Nate Faber, 2016-2018


# Main function body
function main () {
    # Define where all the files are
    timerFile=~/.timer
    undoFile=~/.timerundo
    alarmFile=$(dirname "$(readlink -f "$0")")/timer_expire.wav
    scriptFile=~/.timerscript
    
    # If the timer file doesn't exist create it
    if [ ! -e $timerFile ]; then
        touch $timerFile
    fi

    # If the first argument is a number, use that as the active timer
    if [ "$1" -eq "$1" ] 2>/dev/null; then
        nTimer="$1"
        shift
        
        showNumber=true
    else
        nTimer=1
        showNumber=
    fi

    # TODO: Allow option to make timer 0 based by adding 1 here
    nLine=$(( nTimer + 0 ))

    # If the timer file does not currently have enough lines, add timers until it does
    while [ $(wc -l < $timerFile) -lt "$nLine" ]; do
        echo "+0" >> $timerFile
    done

    # Get the command
    if [ $# -gt 0 ]; then
        command=$1
        shift
    else
        # Default command
        command=show
    fi


    case $command in    
        
        set|s)
            remember
            set $*
            ;;

        from|until|til|to)
            remember
            relative $*
            ;;

        recur|r)
            remember
            symbol="R"
            set $*
            ;;
        
        add|plus|+)
            remember
            add $*
            ;;

        sub|minus|-)
            remember
            doSubtraction=true
            add $*
            ;;

        reverse|rev)
            remember
            reverse
            ;;

        pause|stop)
            remember
            pause
            ;;
            
        go|start|play)
            remember
            unpause
            ;;
            
        p|pp|toggle)
            remember
            toggle_pause
            ;;
        
        zero|z|0)
            remember
            zero
            ;;

        undo|u)
            undo
            ;;
        
        view|v)
            while [ $# -gt "0" ]; do
                case "$1" in
                
                    alarm)
                        useAlarm=true
                        ;;
                    
                    script)
                        alarmScript=true
                        ;;
                        
                    *)
                        echo "Unrecognized alarm function" >&2
                        ;;
                
                esac
                shift
            done

            view
            ;;
        
        print|show|now)
            show
            ;;

        *)
            echo "$1" is an invalid command
            ;;
    esac
}

# Clean up when done
function finish () {
  # Turn cursor visible again
  tput cnorm
  # Echo keyboard strokes to terminal
  stty echo
}
trap finish EXIT


function get () {
	# Parses the timer FILE. Only needs to be run each time the FILE is changed
	
	# Read the value in the file
	inLine=$(awk "NR==$nLine"'{print $1}' < $timerFile)
	
	# Get the starting symbol
	case ${inLine:0:1} in
		[0-9]) # Just a normal timer
			symbol=
			currentVal=$inLine
			;;
		
		\+) # A countup timer
			symbol=+
			currentVal=${inLine##\+}
			;;
		
		\-) # An expired timer
			symbol=-
			currentVal=${inLine##\-}
			;;
		
		R) # A recurring timer (uses comma separated current,recurvalue)
			symbol=R
			inLine=${inLine##\R}
			IFS=',' read currentVal RECUR_VAL <<< $inLine
			
			# Make it easier for functions to write recurring timers
			recurStr=",$RECUR_VAL"
			;;


		*)
			echo "Invalid timer file. Use 'timer zero' or 'timer set' to fix"
			exit 26
			;;
	esac
	
	# Divide the current epoch time by 2 to get the arbitrary divider between paused and active timers
	epochDivider=$((( $(date +%s) / 2 )))
	
	# Set the state of the timer and also calculate the complementary second amount
	
	if [ "$currentVal" -gt "$epochDivider" ]; then
		timerState=running
		runningTime="$currentVal"
		case $symbol in
			\-|\+)
				pauseTime=$(( $(date '+%s') - $currentVal ))
				;;
			*)
				pauseTime=$(( $currentVal - $(date '+%s') ))
				;;
		esac
		
	else
		timerState=paused
		pauseTime="$currentVal"
		case $symbol in
			\-|\+)
				runningTime=$(date -d "now - $currentVal seconds" '+%s')
				;;
			*)
				runningTime=$(date -d "now + $currentVal seconds" '+%s')
				;;
		esac
	fi
	
	# This variable tells timer view whether or not it has refreshed yet since the last get
	viewRefreshed=
	
}


function parse-time () {
    # Parses durations specified on the command line
    # 2 formats are available:
    # 1. [HH:[[MM]:SS]] style phrases (colon separated numbers)
    # 2. '5 minutes 3 seconds', time phrases, which are parsed by date utility
    
    
	# Determine which format the value is in
	if [ $# -eq "0" ]; then
        echo "duration must be specified with that command" >&2
        
	elif [ $# -eq "1" ]; then
        # Format 1: M, MM:SS, HH:MM:SS, DDD:HH:MM:SS (use this format if only one argument is given)
        
        # Use janky bash method to get the hours, minutes and seconds into an array (splitting at :)
        IFS_OLD=$IFS
        IFS=':'
        read -r -a timeArray <<< "$1"
        IFS=$IFS_OLD
        
        # Now look at the length of the array to determine if minutes, minutes and seconds, or hours minutes and seconds
        arrayLen=${#timeArray[@]}
        case $arrayLen in
            1)
                days=0
                hours=0
                minutes=${timeArray[0]}
                seconds=0
                ;;
            2)
                days=0
                hours=0
                minutes=${timeArray[0]}
                seconds=${timeArray[1]}
                ;;
            3)
                days=0
                hours=${timeArray[0]}
                minutes=${timeArray[1]}
                seconds=${timeArray[2]}
                ;;
            4)
                days=${timeArray[0]}
                hours=${timeArray[1]}
                minutes=${timeArray[2]}
                seconds=${timeArray[3]}
                ;;
        esac
	
        totalSeconds=$(( (($days * 24 + $hours) * 60 + $minutes) * 60 + $seconds ))
      
    else
        # Format 2: 5 days 4 hours 3 minutes, smart parsing using the built in date parser
        timePoint=$(date -d "now + $*" '+%s')
        totalSeconds=$(( $timePoint - $(date '+%s') ))
    fi	
	
}


function set () {
	# Parse the inputs
    parse-time $*
    
    # After setting the timer, start immediately
    setTime=$(date -d "now + $totalSeconds seconds" '+%s')
    
    # If this is a recurring timer, set the recur string to be the seconds until the set time
    if [[ $symbol == "R" ]]; then
        recurStr=",$totalSeconds"
    fi
    
    timerVal="$symbol$setTime$recurStr"
    
	# Change the correct line in the timer file
	sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"
}

function relative () {
	# Set the timer relative to a certain time
	timerVal=$(date -d "$*" '+%s')

	# If date occured in the past, this is a countup timer
	if [ "$timerVal" -lt "$(date '+%s')" ]; then
		timerVal="+$timerVal"
	fi

	# Change the correct line in the timer file
	sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"

}

function reverse () {
    # Reverse the direction of the timer
    # Countup becomes countdown
    # Unexpired countdown becomes countup
    # Expired countdown becomes unexpired countdown

    get
    case $symbol in
        +|-)
            symbol=
            ;;
        R)
            echo "You can't reverse a recurring timer" >&2
            exit 1
            ;;
        *)
            symbol='+'
            ;;
    esac

    # Write to file
    timerVal="$symbol$pauseTime$recurStr"
    sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"

    # If timer was running before, keep it running now
    if [ "$timerState" == "running" ]; then
		    unpause
	  fi

}
function add () {
    # Adds minutes to the timer
    parse-time $*

    get
    
    # If subtracting, flip the sign
    if [[ $doSubtraction ]]; then
        totalSeconds=$(( $totalSeconds * -1 ))
    fi

    # Use what the pause time would be to calculate the new pause time
    if [[ $symbol == "-" ]]; then
        # If timer is expired then direction is inverted
        newPauseTime=$(( $pauseTime - $totalSeconds ))
        echo $newPauseTime
        # if now above 0, get rid of the minus sign (it's less than 0 in the equation because pauseTime ignores the symbol)
        if [ $newPauseTime -lt 0 ]; then
            newPauseTime=$(( $newPauseTime * -1 ))
            symbol=
        fi

    else
        
        newPauseTime=$(( $pauseTime + $totalSeconds ))
    fi

    # Write to file
    timerVal="$symbol$newPauseTime$recurStr"
    sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"

    # If timer was running before, keep it running now
    if [ "$timerState" == "running" ]; then
		    unpause
	  fi

}

function recur () {
	parse-time $1
	totalSeconds=$(( (($days * 24 + $hours) * 60 + $minutes) * 60 + $seconds ))

	# Add the recur value after the timer value (separated by a comma)
	timerVal="R$(date -d "now + $totalSeconds seconds" '+%s'),$totalSeconds"

	# Change the correct line in the timer file
	sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"
}

####### Pause and Unpause the Timer ########
function pause () {
    get
    case $timerState in
    
		running)
			timerVal="$symbol$pauseTime$recurStr"

			# Change the correct line in the timer file
			sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"

			timerState=paused
			;;
		
		paused)
			;;
	esac
}

function unpause () {
    get
    case $timerState in    
		running)
			;;
			
		paused)
			timerVal="$symbol$runningTime$recurStr"

			# Change the correct line in the timer file
			sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"

			timerState=running
			;;
	esac
}	

function toggle_pause () {
	get
	case $timerState in
		running)
			pause
			;;
			
		paused)
			unpause
			;;
	esac
}

############################################

function alarm () {
if [[ "$useAlarm" ]]; then
	paplay $alarmFile
fi

if [[ "$alarmScript" ]]; then
    $scriptFile $nTimer
fi
}

function output () {
		
	# Find the days worth of seconds left as an integer, than get the remainder. Repeat for hours, minutes, and seconds
	displayDays=$(( $secondsLeft / $(( 60 * 60 * 24 )) ))
	secondsLeft=$(( $secondsLeft - $displayDays * 60 * 60 * 24 ))
	
	displayHours=$(( $secondsLeft / $(( 60 * 60)) ))
	secondsLeft=$(( $secondsLeft - $displayHours * 60 * 60 ))
	
	displayMinutes=$(( $secondsLeft / 60 ))
	secondsLeft=$(( $secondsLeft - $displayMinutes * 60 ))
	
	displaySeconds=$secondsLeft
	
	# Format string for outputting the timer
	formatStr='%1.1s%d:%.2d:%.2d:%.2d'
	
	# If days or hours are zero, make them blank
	if [ "$displayDays" -eq "0" ]; then
		formatStr='%1.1s%.0d%.2d:%.2d:%.2d'
		
		if [ "$displayHours" -eq "0" ]; then
			formatStr='%1.1s%.0d%.0d%.2d:%.2d'
		fi
	fi
	
	# if timer view is called with a timer number, show the number
	if [ "$showNumber" ]; then
		tput dim
		echo -n "$nTimer|"
		tput sgr0
	fi

	# Print the time
	printf "$formatStr" "$symbol" "$displayDays" "$displayHours" "$displayMinutes" "$displaySeconds"
}

function view () {
	tput civis
	tput clear
	stty -echo
	get
	
	# Whenever the timer file is updated, rerun get to get the new state
	trap get SIGUSR1
	echo $timerFile | entr -p kill -SIGUSR1 $$ &
	
	while true; do
		case $timerState in
		
			running)
				secondsLeft=$(( $currentVal - $(date '+%s') ))
				
				if [ -z $viewRefreshed ]; then
					# Refresh the screen if a get has been run
					tput clear
				fi
				
				# If seconds is less than 0, then change seconds to positive. Symbols are added later.
				if [ "$secondsLeft" -le "0" ]; then
					(( secondsLeft *= -1 ))
					
					# If symbol is empty, this means the timer has counted down to zero. Sound alarm and signal timer as expired
					if [[ ! $symbol ]]; then
						alarm &
						
						# Write a '-' to the beginning of the line in the timer file
						symbol="-"
						sed -i --follow-symlinks "$nLine"'s/^\(.*\)/'"$symbol"'\1/' "$timerFile"

					fi

					# If symbol is R, this is a recurring timer. Sound the alarm and reset the timer
					if [ "$symbol" = "R" ]; then
						alarm &

						# Add the recur value to the current timer
						# If no timer view has been active might have to catch up multiple cycles (hence the while loop)
						while 
							let "currentVal += RECUR_VAL"
							[ "$currentVal" -lt $(date '+%s') ]
						do true; done

						# Change the correct line in the timer file
						timerVal="$symbol$currentVal$recurStr"
						sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"
					fi


				
				fi
				# Move cursor to begining of the linene, outoutput the timer, and then clear to the end of thline
				tput cup 0 0
				output
				tput el
				;;
			
			paused)
				if [ -z $viewRefreshed ]; then
					secondsLeft=$currentVal
					
					# Refresh the screen if a get has been run
					tput clear
					
					output
					viewRefreshed=true
				fi

				# Refresh if enter is pressed on the timer
				if $(read -t0); then
					tput clear
					output
				fi
			;;
			
		esac
		
		sleep 1
	done
			
	
}

function show () {
	get
	case $timerState in
		running)
			secondsLeft=$(( $currentVal - $(date '+%s') ))

			if [ "$secondsLeft" -le "0" ]; then
					(( secondsLeft *= -1 ))
      fi

			;;
		paused)
			secondsLeft=$currentVal
			;;
	esac
	output
}

function remember () {
	# Save the current timer state to the UNDO file
	cat $timerFile > $undoFile
}

function undo () {
	# If undo has already been used once report that to the user
	if [ ! -s $undoFile ]; then
		echo "Undo currently has a max depth of 1"

	else
		# Replace the timer file with the undo file
		cat $undoFile > $timerFile

		# Empty the undoFile to indicate that it has been used
		:>$undoFile

	fi
}

function zero () {
	timerVal="+0"

	# Change the correct line in the timer file
	sed -i --follow-symlinks "$nLine"'s/.*/'"$timerVal"'/' "$timerFile"

	get
}

# Run the main function
main $*