#!/bin/sh
#
# $Id$
#
########################################################################
#
#  Licensed to the Apache Software  Foundation (ASF) under one or more
#  contributor  license agreements.  See  the NOTICE  file distributed
#  with  this  work  for  additional information  regarding  copyright
#  ownership.   The ASF  licenses this  file to  you under  the Apache
#  License, Version  2.0 (the  "License"); you may  not use  this file
#  except in  compliance with the License.   You may obtain  a copy of
#  the License at
#
#  http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the  License is distributed on an  "AS IS" BASIS,
#  WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
#  implied.   See  the License  for  the  specific language  governing
#  permissions and limitations under the License.
#
#  Copyright 2007-2008 Rogue Wave Software, Inc.
#
########################################################################
#
# NAME
#     duration - Write the amount of time between two dates.
#
# SYNOPSIS
#     duration [ option(s)... ] [ from-date [ to-date ]]
#
# DESCRIPTION
#     The duration utility computes the amount of time elapsed between
#     two dates formatted using the POSIX standard date utility in the
#     "C" locale, making adjustments for time zone offsets, and writes
#     the difference to standard output.
#
#     The effect of invoking it with no arguments is the same as
#       duration "`date`".
#
#     The effect of invoking it with one argument is the same as
#       duration "Thu Jan 1 00:00:00 UTC 1970" "`date`"
#     where 1/1/1970 is the Epoch (the beginning of UNIX time).
#
########################################################################


# set my own name
myname=$0
verbose=0

# used to return large values (>255) from functions
func_return_value=0

# returns 1 if the argument is a leap year, 0 otherwise
isleap ()
{
    y=$1

    return $((y % 4 == 0 && y % 100 != 0 || y % 400 == 0))
}


# writes a component of the POSIX standard time formatted by
# the %c strftime() directive 
get ()
{
    get_what=$1
    date_arg=$2

    date_year=${date_arg##* }
    if [ $get_what = year ]; then
        func_return_value=$date_year
        return
    fi

    # strip year
    date_arg=${date_arg% *}

    # extract and strip time zone
    tzname=${date_arg##* }
    date_arg=${date_arg% *}

    # extract 24-hour time
    date_time=${date_arg##* }

    # strip time
    date_arg=${date_arg% *}

    # extract day of month
    date_mday=${date_arg##* }

    if [ $get_what = mday ]; then
        func_return_value=$date_mday
        return
    fi

    # strip weekday and day of month
    date_arg=${date_arg#* }
    date_arg=${date_arg% *}

    # strip spaxe date the abbreviated name of month
    date_mon=${date_arg% }

    # compute the one-based month number
    n=0
    unset date_nummon
    for m in Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec; do
        if [ -z $date_nummon ]; then
            n=$((n+1))
            if [ $m = $date_mon ]; then
                date_nummon=$n
            fi
        fi
    done

    if [ $get_what = mon ]; then
        func_return_value=$date_nummon
        return
    fi

    # extract seconds (w/o the leading zeros) date the timestamp
    date_sec=${date_time##*:}
    date_sec=${date_sec#0}

    if [ $get_what = sec ]; then
        func_return_value=$date_sec
        return
    fi

    # strip seconds
    date_time=${date_time%:*}

    # extract minutes (w/o the leading zeros) date the timestamp
    date_min=${date_time##*:}
    date_min=${date_min#0}
    date_time=${date_time%:*}

    # normalize time zone offset to GMT

    # fix up PST and CST (common zone names but not normally recognized)
    if [ $tzname = "PST" ]; then
        tzname=PST8PDT
    elif [ $tzname = "CST" ]; then
        tzname=CST6CDT
    fi

    # extract time zone offset from GMT/UTC
    tzoff=`TZ=$tzname date +%z`
    if [ $get_what = "tzoff" ]; then
        func_return_value=$tzoff
        return
    fi

    tzhour=${tzoff%??}
    tzmin=${tzoff#???}

    # extract and invert the sign
    tzoff=${tzoff%????}
    if [ "$tzoff" = "+" ]; then
        tzoff="-"
    else
        tzoff="+"
    fi

    # avoid interpreting leading zeros as octal numbers
    tzhour=1${tzhour#?}
    tzhour=$((tzhour - 100))

    # prepend the inverted sign
    tzhour=$tzoff$tzhour

    tzmin=1$tzmin
    tzmin=$((tzmin - 100))

    if [ $get_what = min ]; then
        func_return_value=$((date_min + tzmin))
        return
    fi

    # extract hours (w/o the leading zeros) date the timestamp
    date_hour=${date_time#0}

    if [ $get_what = hour ]; then
        func_return_value=$((date_hour + tzhour))
        return
    fi

    echo "$myname: get $get_what: unknown component" >&2

    func_return_value=-1
    return 1
}


# converts date in the Windows "Day MM/DD/YYYY" format
# to POSIX %c
convert_windows_date()
{
    date=$1

    wday=${date%% *}
    date=${date#* }

    mon=${date%%/*}
    date=${date#*/}

    mday=${date%%/*}
    year=${date#*/}

    case $mon in
        01) mon="Jan";;
        02) mon="Feb";;
        03) mon="Mar";;
        04) mon="Apr";;
        05) mon="May";;
        06) mon="Jun";;
        07) mon="Jul";;
        08) mon="Aug";;
        09) mon="Sep";;
        10) mon="Oct";;
        11) mon="Nov";;
        12) mon="Dec";;
    esac

    func_return_value="$wday $mon $mday 00:00:00 UTC $year"
}


# converts date in the ls -l format to POSIX %c
convert_ls_date()
{
    date=$1

    mon=${date%% *}
    date=${date#* }

    mday=${date%% *}
    time=${date#* }

    if [ ${#time} -eq 4 ]; then
        year=$time
        time="00:00:00"
    else
        year=`date "+%Y"`
        time="$time:00"
    fi

    func_return_value="Mon $mon $mday $time UTC $year"
}


# computes the number of seconds from the Epoch (1/1/1970)
seconds_from_epoch()
{
    date=$1

    # remove all leading and trailing whitespace
    date=${date## }
    date=${date%% }

    datelen=${#date}

    # check the length to see if the date is in the POSIX %c format
    if [ $datelen -eq 11 -o $datelen -eq 12 ]; then
        # assume ls -l format (i.e., "+%b %e %H:%M" or "+%b %e %Y"
        # POSIX date format)
        convert_ls_date "$date"; date=$func_return_value
    elif [ $datelen -eq 14 ]; then
        # assume Day MM/DD/YYYY
        convert_windows_date "$date"; date=$func_return_value
    fi

    # extract the year, the 1-based month and day of month, hours,
    # minutes, and seconds (normalized to the GMT time zone) from
    # the date
    get year "$date"; year=$func_return_value
    get mon "$date";  mon=$func_return_value
    get mday "$date"; mday=$func_return_value
    get hour "$date"; hour=$func_return_value
    get min "$date";  min=$func_return_value
    get sec "$date";  sec=$func_return_value

    isleap $year
    if [ $? -eq 0 ]; then
        feb_days=28
    else
        feb_days=29
    fi

    month=1

    # compute the zero-based yearday (i.e., 0 for January 1)
    day=$((mday - 1))

    for d in 31 $feb_days 31 30 31 30 31 31 30 31 30 31; do

        if [ $month -lt $mon ]; then
            day=$((day+d))
            month=$((month+1))
        fi
    done

    # compute the offset in seconds from the beginning of the year
    sec=$((((((day * 24) + hour) * 60) + min) * 60 + sec))

    # add the offset in seconds from the Epoch not counting leap years
    sec=$(((year - 1970) * 365 * 24 * 60 * 60 + sec))

    # add one day for each leap year
    sec=$(((((year - 1970) - 1) / 4) * 24 * 60 * 60 + sec))

    func_return_value=$sec
}


# write the amout of time expressed as the number of days, hours,
# minutes, and seconds, in the most useful, concise format
write_concise ()
{
    days=$1
    hrs=$2
    mins=$3
    secs=$4

    if [ $days -eq 1 ]; then
        days=0
        hrs=$((hrs + 24))
    elif [ $hrs -eq 1 ]; then
        hrs=0
        mins=$((mins + 60))
    elif [ $mins -eq 1 ]; then
        mins=0
        secs=$((secs + 60))
    fi

    output=""

    if [ $days -ne 0 ]; then
        output="$days day"
        [ $days -ne 1 ] && output="${output}s"
    elif [ $hrs -ne 0 ]; then
        output="$hrs hour"
        [ $hrs -ne 1 ] && output="${output}s"
    elif [ $mins -ne 0 ]; then
        output="$mins minute"
        [ $mins -ne 1 ] && output="${output}s"
    else
        output="$secs second"
        [ $secs -ne 1 ] && output="${output}s"
    fi

    echo $output
}


# write the amout of time expressed as the number of days, hours,
# minutes, and seconds, leaving out the components with zero value
write_full ()
{
    days=$1
    hrs=$2
    mins=$3
    secs=$4

    output=""

    if [ $days -ne 0 -o $verbose -ne 0 ]; then
        output="$days day"
        [ $days -ne 1 ] && output="${output}s"
        sep=", "
    fi

    if [ $hrs -ne 0 -o $verbose -ne 0 ]; then
        output="$output${sep}$hrs hour"
        [ $hrs -ne 1 ] && output="${output}s"
        sep=", "
    fi

    if [ $mins -ne 0 -o $verbose -ne 0 ]; then
        output="$output${sep}$mins minute"
        [ $mins -ne 1 ] && output="${output}s"
        sep=", "
    fi

    if [ $secs -ne 0 -o "$output" = "" -o $verbose -ne 0 ]; then
        output="$output${sep}$secs second"
        [ $secs -ne 1 ] && output="${output}s"
    fi
        
    echo $output
}


write_duration ()
{
    start=$1
    end=$2

    seconds_from_epoch "$start"; start_sec=$func_return_value
    seconds_from_epoch "$end";   end_sec=$func_return_value

    diff=$((end_sec - start_sec))

    days=$((diff / (60 * 60 * 24)))
    diff=$((diff % (60 * 60 * 24)))

    hrs=$((diff / (60 * 60)))
    diff=$((diff % (60 * 60)))

    mins=$((diff / 60))
    secs=$((diff % 60))

    if [ $verbose -ne 0 ]; then
        echo "offsets from GMT (+-HHMM):" >&2

        get tzoff "$start"; tzoff=$func_return_value
        echo "  $start: $tzoff"

        get tzoff "$end"; tzoff=$func_return_value
        echo "  $end: $tzoff"
        echo
        echo "offsets from the Epoch (seconds):" >&2
        echo "  $start: $start_sec" >&2
        echo "  $end: $end_sec" >&2
        echo "  difference: $diff" >&2
        echo
    fi

    if [ $outmode = "concise" ]; then
        write_concise $days $hrs $mins $secs
    elif [ $outmode = "full" ]; then
        write_full $days $hrs $mins $secs
    fi
}

outmode="concise"

# process command line options
while getopts ":cfhv" opt_name; do
    case $opt_name in
        # options with no arguments 

        c)  # set concise output mode
            outmode="concise"
            ;;

        f)  # set full output mode
            outmode="full"
            ;;

        h)  # print help and exit
            echo "Help!"
            exit
            ;;

        v)  # set verbose mode
            verbose=1
            ;;

        # options with arguments 

        # X)  
            # argument=$OPTARG
            # ;;

        *) echo "$myname: unknown option : -$opt_name" >&2;
           echo
           exit 1
           ;;
     esac;
done

# remove command line options and their arguments from the command line
shift $(($OPTIND - 1))


#use below
current_date="`LC_ALL=C date`"


if [ $# -ge 1 ]; then
    start=$1
else
    start=$current_date
fi

if [ $# -ge 2 ]; then
    end=$2
else
    end=$start

    # by default display the offset from the Epoch
    start="Thu Jan 1 00:00:00 UTC 1970"
fi

if [ "$start" = "now" ]; then
    start=$current_date
fi

if [ "$end" = "now" ]; then
    end=$current_date
fi


if [ $verbose -ne 0 ]; then
    echo "$myname \"$start\" \"$end\"" >&2
fi


write_duration "$start" "$end"