#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
#
# $Source: /home/blais/repos/cvsroot/tracktools/bin/timesheet,v $
# $Id: timesheet,v 1.38 2005/10/12 21:45:01 blais Exp $
#
# Copyright (C) 2003-2005, Martin Blais <blais@furius.ca>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#

"""timesheet [<options>] <action>

Parse timesheet and compute some information.

'action' is one of:
  summary:   prints the number of hours completed and salary (default).
  annual:    extrapolate an equivalent annual salary.
  goal:      figure out average hours/day increase with today's additional
             hours.
  verify:    generate some output for manual verification of the script.
  annotate:  generate output that will diff verifications against original
             input.
  tasks:     generate a tally of time per task

For easy cross-checking against your timesheet file, run a command like this::

  timesheet --select-month=2003-11 annotate | xxdiff - $TIMESHEET

"""

doc_file_format = """\
File Format
-----------

The format of each entry in the timesheet file fits the following expression:

- <date> <time> <date>? <time> (, <date>? <time> <date>? <time> ...)

  comments...

Where time matches is of the format HHhMM or HHMM, and date matches YYYY-MM-DD.
The list item char can be any other valid chars for lists in restructuredtext.

The time is considered to be within the last date that was declared on the line.

In the case of multiple ranges, the comments will be attached to both of the
intervals (duplicated).


Examples
--------

- YYYY-MM-DD HHMM HHMM

  some lines for the description ... no special format here, the author usually
  writes a bulleted list of things done within that period.

Also, another format is accepted for straddling days:

- YYYY-MM-DD HHMM YYYY-MM-DD HHMM

You can also leave the stop time blank and it will use 'now' instead; this is
usually what it looks like for me at the top of the file while I'm actively
working:

- YYYY-MM-DD HHMM

For holidays, or days not worked that should not be taken in account for the
hours / weekday average, add an entry like this:

- YYYY-MM-DD off

Note that the order of the entries in the file doesn't matter, since they will
get sorted and filtered with the requested select period after getting parsed.


- YYYY-MM-DD HHMM HHMM, HHMM HHMM

Two intervals in the same day.

- YYYY-MM-DD HHMM HHMM, HHMM YYYY-MM-DD HHMM

Two intervals, with the second straddling a day.


"""

# Ideas
# -----
#
# - parse a :Rate: bibliographic field in the document and offer to run crypt on
#   it to find out the rate.
#
# - check if there are overlapping period of time and barf error if there are.
#

__version__ = "$Revision: 1.38 $"
__author__ = "Martin Blais <blais@furius.ca>"


import sys, os, os.path
import re, math
import optparse
import operator

from datetime import *


# cannot really start work after 5am without it being early (i.e. not late)
begin_of_day = time(05, 00)

max_work_interval = 18


class Interval:
    """
    Represents a single contiguous unit of work.
    """

    def __init__(self, start=None, stop=None,
                 holiday=False):
        self.start = start
        self.stop = stop

        self.delta = self.stop - self.start

        self.holiday = holiday
        self.entry = None

    def __str__(self):
        return '%s -> %s  (%s)' % (self.start.isoformat(' '),
                                    self.stop.isoformat(' '),
                                    self.delta)

    def __cmp__(self, other):
        return cmp(self.start, other.start)



taskre = re.compile('\\[\\s*([a-zA-Z0-9]+)(\\s+([0-9]+)%?)?\\]')

_unknown_task = 'other'

class Entry:
    """
    Represents a single entry in a file, that has associated comments.
    """
    def __init__(self, intervals, origline, origno):
        self.origline = origline
        """Original line in the input file."""

        self.origno = origno
        """Original line no in the input file."""

        self.intervals = intervals
        """Intervals that correspond to this entry."""

        self.comments = []
        """Comments associated with the entry."""

        self.taskperc = {}
        """Dict of the tasks accomplished. keys are the task labels, and the
        values are percentages (0-100)."""

        # Create links between entry and intervals.
        for i in intervals:
            i.entry = self

    def total(self):
        """
        Returns the total time consumed by this entry.
        """
        return reduce(operator.add, (i.delta for i in self.intervals))

    def compute_tasks(self):
        """
        Extract the task completion from the comments.
        """
        tp = {}
        totacc = 0
        numopen = 0
        for l in self.comments:
            for mo in list(taskre.finditer(l)):
                name, perc = mo.group(1,2)
                if perc is not None:
                    perc = int(perc)
                    totacc += perc
                else:
                    numopen += 1
                tp.setdefault(name, []).append(perc)

        if numopen > 0:
            pperopen = (100 - totacc) / float(numopen)

        for k, l in tp.iteritems():
            tot = 0
            for v in l:
                if v is None:
                    tot += pperopen
                else:
                    tot += v
            self.taskperc[k] = tot
        
        # Make sure that the sum does not go above 100%.
        totperc = math.floor(sum(self.taskperc.values()))
        if totperc > 100:
            raise Error("Percentage too high (%d%%)" % totperc, self.origno)
        if totperc < 100:
            self.taskperc[_unknown_task] = 100 - totperc



class Error(SystemExit):
    """
    File parsing error.
    """
    def __init__(self, msg, lineno):
        Exception.__init__(self, 'Error (%s): %s' % (lineno, msg))

    def warn(self, msg, lineno):
        sys.stdout.write('Warning (%s): %s\n' % (lineno, msg))

    warn = staticmethod(warn)



days = '(\d\d\d\d)-(\d\d)-(\d\d)'
dayre = re.compile(days)
hours = '(\d\d)[h:]?(\d\d)'
hourre = re.compile(hours)
hour2re = re.compile('%s\-%s' % (hours, hours))
endre = re.compile('^.*END\\s*$')

entryoffre = re.compile(days + '\s+off\s*$', re.IGNORECASE)

def parse_entry_line(entry_line, lineno):
    """
    Parse a single entry line.
    """
    intervals = []

    # check if it's a day off
    mo2 = entryoffre.match(entry_line)
    if mo2:
        # add a holiday / day off entry
        try:
            t = apply(datetime, map(int, mo2.groups()))
        except ValueError, e:
            raise Error('Converting date (%s)' % e, lineno)

        intervals.append(Interval(t, t, holiday=True))
    else:
        # split the line in various ranges
        ranges = [x.strip() for x in entry_line.split(',')]
        lastdate = None

        for rng in ranges:
            words = [x.strip() for x in rng.split()]

            times = []
            for w in words:
                # try to match a day
                mo = dayre.match(w)
                if mo:
                    try:
                        d = apply(date, map(int, mo.groups()))
                        if lastdate and d < lastdate:
                            raise Error('Date ordering.', lineno)
                        lastdate = d
                    except ValueError, e:
                        raise Error('Converting date (%s)' % e, lineno)
                    continue

                # else, try to match a pair of times, separated by a dash
                mo = hour2re.match(w)
                if mo:
                    if lastdate is None:
                        raise Error("Time without preceding date.", lineno)
                    try:
                        # add new times
                        times.append( datetime.combine(
                            lastdate, apply(time, map(int, mo.group(1, 2)))))
                        times.append( datetime.combine(
                            lastdate, apply(time, map(int, mo.group(3, 4)))))
                    except ValueError, e:
                        raise Error('Converting time: %s' % e, lineno)
                    continue

                # else, try to match a time
                mo = hourre.match(w)
                if mo:
                    if lastdate is None:
                        raise Error("Time without preceding date.", lineno)
                    try:
                        # add new date/time
                        times.append( datetime.combine(
                            lastdate, apply(time, map(int, mo.groups()))))
                    except ValueError, e:
                        raise Error('Converting time: %s' % e, lineno)
                    continue

                # else...
                raise Error('Internal error.', lineno)

            # if time is missing, fill in with current date/time
            if len(times) == 1:
                times.append(datetime.now())

            # check that the range consists in two datetimes
            if len(times) != 2:
                raise Error("You need to specify exactly two times.", lineno)

            t1, t2 = times[0], times[1]
            if t1 >= t2:
                raise Error('Ordering error.', lineno)

            e = Interval(t1, t2)
            if e.delta > timedelta(hours=max_work_interval):
                raise Error('interval too long.', lineno)

            intervals.append(e)

    return intervals



entryre = re.compile('^[-*]\\s+(%s|%s|%s-%s|,|\\s+|off)+$' %
                     (days, hours, hours, hours))

loose_entryre = re.compile('^[-*]\\s+(.*)')

ratere = re.compile('^:Rate: (.*)')

def parse_file_mitaine(f):
    """
    Parse timesheet file and return a list of Interval objects.
    The parsing is performed by hand.
    """
    entries, intervals = [], []
    e = None
    lineno = 0
    while True:
        # read a line
        l = f.readline()
        lineno += 1
        if not l:
            break
        l = l.rstrip()

        # Stop if the ender line is reacehed.
        if endre.match(l):
            break

        # check if it's a rate
        mo = ratere.match(l)
        if mo:
            raise Error(
                "Error: FIXME rate parsing is not implemented yet", lineno)

        # check if it's an entry line; if not, add line contents as comment
        mo_loose = loose_entryre.match(l)
        if not mo_loose:
            # add comments if we're within an entry only.
            if e is not None:
                e.comments.append(l)
            continue

        mo_strict = entryre.match(l)
        if not mo_strict:
            if opts.loose:
                Error.warn("Possible error.", lineno)
            else:
                raise Error("Invalid range.", lineno)
            continue

        # Parse the entry line.
        ivals = parse_entry_line(mo_loose.group(1), lineno)
        e = Entry(ivals, mo_loose.group(1), lineno)

        intervals.extend(ivals)
        entries.append(e)

    # Extract the tasks from the comments.
    for e in entries:
        e.compute_tasks()

    return entries, intervals



class Day:
    """
    Container for all the intervals of a single day.
    """
    def __init__(self, date, intervals):
        self.date = date
        """Date of the given day."""
        
        self.intervals = intervals
        """List of intervals for a day."""

        self.intervals.sort()


def map_to_days(intervals):
    """
    Group intervals into a map by day, where key = start date and value = list
    of interval objects.  Returns a list of the days, sorted by date.
    """
    stime = begin_of_day
    imap = {}
    for i in intervals:
        d = i.start.date()
        if not i.holiday and i.start.time() < stime:
            d -= timedelta(1)
        imap.setdefault(d, []).append(i)

    days = map(lambda x: Day(*x), imap.iteritems())
    days.sort(key=lambda x: x.date)

    return days



def get_hours(interval):
    """
    Return the number of hours for the given time interval, as a floating point
    value.
    """
    # It is only unfortunate that the standard module does not provide this
    # functionality.
    return interval.seconds / 3600.0 + interval.days * 24.0

def get_hourmin(interval):
    """
    Return the number of hours and minutes for the given time interval, as a
    tuple, truncated.
    """
    m = interval.seconds / 60.0 + 0 + interval.days * 24 * 60
    h = m / 60
    m -= h * 60
    return h, m



def read_files(files):
    """
    Read in and parse the files.
    """
    # Read entries.
    entries, intervals = [], []
    for fn in files:
        try:
            if fn == '-':
                f = sys.stdin
            else:
                f = open(fn, 'r')
            lentries, lintervals = parse_file_mitaine(f)
            entries.extend(lentries)
            intervals.extend(lintervals)
            f.close()
        except IOError, e:
            raise SystemExit("Error: reading file '%s'" % fn + str(e))
    return entries, intervals



def check_overlap(intervals):
    """
    Make sure that there aren't any overlaps between any of the intervals.
    """
    if intervals:
        intervals.sort()
        laststop = intervals[0].start
        laste = None
        for e in intervals:
            if laststop > e.start:
                raise SystemExit(
                    "Error: time overlap between periods\n '%s' and \n '%s'" % \
                    (laste, e))
            laststop = e.stop
            laste = e



def filter_by_time(entries, intervals, opts):
    """
    Calculate this week/month and apply time-based filters.
    """
    now = datetime.now()
    if opts.select_today:
        cdater = (datetime.combine(now.date(), time(0)),
                  datetime.combine(now.date(), time(23, 59, 59)))
        new_intervals = filter(lambda e: e.start >= cdater[0] and
                               e.start <= cdater[1], intervals)
        sels = '%s' % cdater[0]
    elif opts.select_this_week:
        cdater = [ now.date() - timedelta(now.weekday()) ]
        cdater += [ cdater[0] + timedelta(7) ]
        new_intervals = filter(lambda e: e.start.date() >= cdater[0] and
                               e.start.date() <= cdater[1], intervals)
        sels = '%s .. %s' % tuple(cdater)
    elif opts.select_this_month or opts.select_month:
        if opts.select_this_month:
            month, year = now.month, now.year
        else: # opts.select_month
            assert opts.select_month
            year, month = opts.select_month

        import calendar
        cdater = [ date(year, month, 1) ]
        cdater += [ cdater[0] + timedelta(\
            days=(calendar.monthrange(year, month)[1] - 1)) ]
        new_intervals = filter(lambda e: e.start.date() >= cdater[0] and
                               e.start.date() <= cdater[1], intervals)
        sels = '%s .. %s' % tuple(cdater)
    else:
        new_intervals = intervals
        sels = 'all days'

    # Get the new list of entries.
    new_entries = []
    eset = set()
    for i in new_intervals:
        if i.entry not in eset:
            eset.add(i.entry)
            new_entries.append(i.entry)

    return new_entries, new_intervals, sels



def main():
    """
    Main program.
    """
    from copy import copy
    import optparse

    def check_month(option, opt, value):
        mo = re.match('^(\d\d\d\d)-(\d\d)$', value)
        if not mo:
            raise optparse.OptionValueError(
                "option %s: invalid month value: %r" % (opt, value))
        return (int(mo.group(1)), int(mo.group(2)))

    class ExtOption(optparse.Option):
        TYPES = optparse.Option.TYPES + ("month",)
        TYPE_CHECKER = copy(optparse.Option.TYPE_CHECKER)
        TYPE_CHECKER["month"] = check_month

    parser = optparse.OptionParser(__doc__.strip(), version=__version__[1:-1],
                                   option_class=ExtOption)
    parser.add_option('--help-format', action='store_true',
                      help='print help on file format')

    parser.add_option('-l', '--loose', '--loose-parsing', action='store_true',
                      default=False,
                      help="Allow non-entry list items on column 0.")

    parser.add_option('-f', '--file', action='append',
                      help='Specify a file to process (default: TIMESHEET)')
    parser.add_option('-r', '--rate', action='store',
                      type='float',
                      help='Specify hourly rate')
    parser.add_option('-x', '--no-tax', action='store_true',
                      help='Disable taxes (works with the rate only).')
    parser.add_option('-H', '--holidays',
                      type='int', action='store', default=30,
                      help='Specify number of holiday days off for annual ' + \
                      'guesstimate (default: 30)')

    group = optparse.OptionGroup(parser, "Period selection actions",
                                 "These options select the time period.")
    group.add_option('-t', '--select-today', action='store_true',
                     help='today only')
    group.add_option('-w', '--select-this-week', action='store_true',
                     help='this week (default)')
    group.add_option('-m', '--select-this-month', action='store_true',
                     help='this month only')
    group.add_option('-a', '--select-all', action='store_true',
                     help='all entries')

    group.add_option('-M', '--select-month', action='store', type='month',
                     help='any specific month, format is YYYY-MM')

    parser.add_option_group(group)

    global opts
    opts, args = parser.parse_args()

    if opts.help_format:
        print doc_file_format
        sys.exit(0)

    selopts = map(lambda x: x.dest, group.option_list)
    nsel = len(filter(None, map(lambda x: getattr(opts, x), selopts)))

    if nsel == 0:
        opts.select_this_week = 1
    elif nsel > 1:
        raise SystemExit('Error: please specify at most one selector.')

    if not opts.file:
        try:
            opts.file = [ os.environ['TIMESHEET'] ]
        except KeyError, e:
            raise SystemExit('Error: specify file or set env var TIMESHEET')

    # Read the inputs.
    entries, intervals = read_files(opts.file)

    # Check for overlap in time periods, should not be allowed, signals error in
    # file.
    check_overlap(intervals)

    # Calculate this week/month and apply filters.
    entries, intervals, selected_str = filter_by_time(entries, intervals, opts)

    # for e in intervals: print e
    alldays = map_to_days(intervals)

    # Compute intervals for every day and total hours.
    total_intervals = timedelta()
    holidays = []
    for d in alldays:
        i = d.intervals

        if i[0].holiday and d.date.weekday() < 5:
            holidays.append(d)
            continue

        tot = timedelta()
        for e in i:
            tot += e.delta
        m = tot.seconds / 60
        h = m / 60
        m -= h * 60
        assert(tot.days == 0)

        d.total = tot
        d.hourmin = h, m

        total_intervals += tot

    # Count weekdays.
    if intervals:
        oneday = timedelta(1)
        d = alldays[0].date
        weekdays = 0
        while d <= alldays[-1].date:
            if d.weekday() < 5:
                weekdays += 1
            d += oneday
    else:
        weekdays = 0

    # Remove all holidays from consideration.
    for i in holidays:
        alldays.remove(i)

    weekdays -= len(holidays);

    daysworked = len(alldays)

    actions = ['summary', 'annual', 'goal', 'verify', 'annotate', 'tasks', 'help']
    if len(args) > 1:
        raise SystemExit("Error: specify at most one action.")
    action = None
    if not args:
        action = actions[0]
    else:
        for a in actions:
            if a.startswith(args[0]):
                action = a
                break
    if not action:
        raise SystemExit('Error: unknown action')

    if alldays: # And weekdays:
        periods = '%s .. %s' % (alldays[0].date, alldays[-1].date)
        hh = get_hours(total_intervals)
        ##hpd = hh / len(alldays)
        if weekdays:
            hpdw = hh / weekdays
        else:
            hpdw = 0
    else:
        periods = 'NO ENTRIES'
        hh = 0
        hpdw = 0

    #---------------------------------------------------------------------------
    if action == 'summary':
        print 'Summary (%s)' % selected_str
        print '=================================================='
        print 'Actual Period:', periods
        print
        for d in alldays:
            print d.date, d.date.strftime('(%a)    '), '%02d:%02d hours' % d.hourmin
        print '--------------------------------------'
        print 'Total:                 %7.2f hours' % hh
        ##print 'Average hours/alldays: %7.2f hours' % hpd
        print 'Average hours/weekday: %7.2f hours' % hpdw
        print '--------------------------------------'

        if opts.rate:
            gstrate = 0.07
            pstrate = 0.075
            amt_beftax = (hh * opts.rate)
            amt_gst = amt_beftax * gstrate
            amt_pst = (amt_beftax + amt_gst) * pstrate
            amt_total = amt_beftax * (1 + gstrate) * (1 + pstrate)
            amt_total2 = amt_beftax + amt_gst + amt_pst
            assert abs(amt_total - amt_total2) < 0.01

            if not opts.no_tax:
                print 'Invoice:     % 10.2f$' % amt_beftax
                print 'GST (%4.2f%%): % 10.2f$' % (gstrate * 100, amt_gst)
                print 'PST (%4.2f%%): % 10.2f$' % (pstrate * 100, amt_pst)
                print '              ------------'
                print 'Total:       % 10.2f$' % amt_total
                print '--------------------------------'
            else:
                print 'Total:       % 10.2f$' % amt_beftax
                print '--------------------------------'

    #---------------------------------------------------------------------------
    elif action == 'verify':
        print 'Summary (%s)' % selected_str
        print '=================================================='
        print 'Actual Period:', periods
        print
        for d in alldays:
            print d.date, d.date.strftime('(%a)    '), '%02d:%02d hours' % d.hourmin

            for i in d.intervals:
                if i.stop.date() != d.date: sss = '***'
                else: sss = ''
                print '  ', i, sss
            print

    #---------------------------------------------------------------------------
    elif action == 'annotate':
        print 'Summary (%s)' % selected_str
        print '=================================================='
        print 'Actual Period:', periods
        print
        ent2 = list(entries)
        ent2.sort(lambda x, y: cmp(x.origline, y.origline))
        total = timedelta()
        for e in ent2:
            print e.origline,

            etotal = e.total()
            print '  ==>', etotal

            total += etotal
            print os.linesep.join(e.comments)

        print 'Total Hours:', get_hours(total)

    #---------------------------------------------------------------------------
    elif action == 'goal':
        print 'Goal (%s)' % selected_str
        print '=================================================='
        print 'Actual Period:', periods
        print

        now = datetime.now()

        goal = 8 # per day
        totgoal = goal * weekdays
        dt = timedelta(hours=totgoal - hh)
        print 'Time needed to obtain %d hour/day: %s' % (goal, dt)
        print 'Departure time:  %s' % (now + dt).strftime('%H:%M')

        print
        for h in xrange(0, 12):
            ahpd = (hh + h) / weekdays
            print 'Average hours/day (%+2d): %7.2f hours' % (h, ahpd)

        print
        rmin = (now.minute / 15 + 1) * 15
        next = datetime(now.year, now.month, now.day, now.hour) + \
               timedelta(minutes=rmin)
        hh += (rmin - now.minute) / 60.

        for hq in xrange(0, 300, 15):
            ahpd = (hh + hq / 60.) / weekdays
            t = next + timedelta(minutes=hq)
            print 'Average hours/day (leave at %s): %7.2f hours' % \
                  (t.strftime('%H:%M'), ahpd)
        print

    #---------------------------------------------------------------------------
    elif action == 'annual':

        if not opts.rate:
            raise SystemExit("Error: you must specify a rate for this command.")

        mulw = mula = 0
        if not alldays:
            print >> sys.stderr, 'Error: cannot extrapolate, no active days.'
        # compute equivalent annual salary
        ttot = alldays[-1].date - alldays[0].date + oneday

        # count all days
        mula = (365.0 - opts.holidays) / ttot.days

        # count weekdays only
        mulw = (365.0 * (5.0/7) - opts.holidays) / weekdays

        hhr = hh * opts.rate

        totdays = ttot.days

        print 'Extrapolation (%s)' % selected_str
        print '=================================================='
        print '(total revenues * year work days / actual period)'
        print
        print 'Actual Period:', periods
        fmt = '%4d days   %10.2f$ /year'
        print 'Equiv salary (weekdays compens):', fmt % (weekdays, hhr * mulw)
        print 'Equiv salary (work all days):   ', fmt % (totdays, hhr * mula)

    #---------------------------------------------------------------------------
    elif action == 'tasks':
        # Compute the sum of percentages for all intervals.
        tasks = {}
        for d in alldays:
            for i in d.intervals:
                ihours = get_hours(i.delta)
                for name, perc in i.entry.taskperc.iteritems():
                    tasks.setdefault(name, 0.)
                    tasks[name] += perc * ihours

        tothours = reduce(operator.add, tasks.itervalues())

        print 'Tasks (%s)' % selected_str
        print '=================================================='

        fmt = ('  %%-%ds : %%5.2f%%%%  (%%10.2f hours)' %
               max(len(x) for x in tasks.iterkeys()))
        for name, hours in tasks.iteritems():
            print fmt % (name, 100*hours/tothours, hours)

        print '=================================================='

    #---------------------------------------------------------------------------
    elif action == 'help':
        parser.print_help()

    #---------------------------------------------------------------------------
    else:
        raise StandardError('Internal error with action=' + action)

    #---------------------------------------------------------------------------

if __name__ == '__main__':
    main()