clock

#!/usr/bin/perl

use Getopt::Long;
use IO::All;
use Date::Format;
use Date::Parse;
use TryCatch;
use feature ':5.10';
use Pod::Usage;

# general syntax
#    todo.sh clock in <num>   -- start tracking time on item <num>
#    todo.sh clock out        -- stop tracking time (clock out of item <num>)
#    todo.sh clock what       -- print the current 'active' task, shortcut 'wh'
#    todo.sh report [--groupingss=groupingss] [filters...] -- report time with optionally specified groupings

my $verbose = 0;
my @groupings = ( 'indate', 'project' );  # default
my $res = GetOptions(
    'verbose|v' => sub { $verbose++ },
    'groupings=s' => sub { @groupings = split (/,/, $_[1] ) }
    );

say "GROUPINGS ARE ".join(", ",@groupings) if $verbose;

my $tododir = $ENV{'TODO_DIR'} || die "TODOTXT_DIR must be specified on in the environment";

my $cmdname = shift @ARGV || die 'Invalid program state: cmdname not specified';

# make sure we're called correctly
my @aliases = ( 'clock', 'cl', 'do' );
(grep { $cmdname eq $_ } @aliases) || die "Invalid program state: command:'$cmdname' is not one of (".join(", ", @aliases).")";

# get all the clock data
my $clockf = io("$tododir/clock.dat");

my @clock = slurp_data(io($clockf));
my $active = get_active_task(@clock);

# if the alias is do, we want to override so we can clock out and then pass it on
if ( $cmdname eq 'do' ) {
    # allow us to do multiple tasks
    foreach my $dotask ( @ARGV ) {
        # find matching task in @todo
        my $doline = get_todo_line( $dotask );

        if ( ( defined( $doline ) && defined( $active ) ) 
             && $active->{detail} eq $doline->{detail} ) {
            clockout( $active );
        }
    }
    # call the original
    my $cmd = "$ENV{'TODO_SH'} command do ".join(' ',map { "'$_'" } @ARGV);
    say $cmd if $verbose;
    system( $cmd );
    exit( 0 );
}


my $cmd = shift @ARGV     || pod2usage(1);

if ( $cmd eq 'in' ) {
    # todo.sh clock in <linenum>

    my $linenum = shift @ARGV || pod2usage(1);

    my $line;
    try {
        $line = get_todo_line($linenum);

        if ( not $active ) {
            # if we're not active, simply append a new entry
            clockin( $line );

        } else {
            # we're active

            if ( $active->{todotxtline} eq $line->{todotxtline} ) {
                # already doing requested
                warn "You are already clocked in to $line->{todotxtline}";
                
            } else {
                # clock out of active and clock in to $line
                clockout( $active );
                clockin( $line );
            }
        }

    } catch ( $err ) {
        say "Caught exception punching in line $linenum:\n\t$err";
        exit(1);
    }

} elsif ( $cmd eq 'out' ) {
    # todo.sh clock out

    # see if there's anything amiss
    if ( @ARGV ) {
        say "Gibberish at the end of the command: '".join(' ',@ARGV)."'";
        say "Stopping processing...";
        pod2usage(1);
    }

    try {
        clockout( $active );
    } catch ( $err ) {
        say "Caught exception punching out:\n\t$err";
        exit(1);
    }
} elsif ( $cmd =~ /(what|wh)/ ) {

    if ( $active ) {
        say "The active task for ".spent_time($active)." minutes is:\n\t $active->{todotxtline}";
    } else {
        say "No current task is active";
    }
} elsif ( $cmd =~ /(report|rep)/ ) {
    # generate a report, optionally using groupings

    # apply the cany filters from the command line
    my @filters = @ARGV;
    my @subclock =         
        grep { my $d = $_->{todotxtline};
               if ( not @filters ) { 1; }
               else { 
                   grep { $d =~ /$_/i } @filters;
               } 
    } @clock;

    # loop over @clock, grouping first by date, then by activity
    my $groups = {};
    foreach my $c ( @clock ) {
        my $targ = $groups;
        foreach my $grp ( @groupings ) {
            if ( $grp eq 'indate' ) { 
                my ($date) = $c->{clockin} =~ /^(\d{8})T\d{6}$/;
                die "Couldn't identify clock-in date for '$c->{todotxtline}'" if not $date;
                $targ->{$date} = {} if ( not defined $targ->{$date} );
                $targ = $targ->{$date};

            } elsif ( $grp eq 'project' ) {
                my ($prj) = grep { $_ =~ /(\+p\/[^\s]+)/i } @{$c->{proj}};
                $prj = '<unknown>' if ( not defined $prj );

                $prj = lc($prj);
                
                $targ->{$prj} = {} if ( not defined $targ->{$prj} );
                $targ = $targ->{$prj};
            }

        }
        push @{$targ->{$c->{todotxtline}}}, $c;
    }

    say_group_sums( $groups );

    1;
}

sub get_active_task(@) {
#    return undef if not @clock;  # nothing in the clock file
    my @clock = @_;

    return undef if not @clock;

    return $clock[-1] if not defined( $clock[-1]->{clockout} );

    return undef;  # not doing anything
}

sub slurp_data {
    my ( $file, @filters ) = @_;

    die "You must pass an io::file to slurp" if not defined $file;

    # read all lines, removing blanks, and return as a list
    my $cnt = 0;
    my @data =
        map { 
            my $line = $_;
            say "PARSING TASK LINE: $line" if $verbose>1;
            parse_task( $line, ++$cnt );
    }
        grep { my $d = $_;
               if ( not @filters ) { 1; }
               else { 
                   grep { $d =~ /$_/i } @filters;
               }
        } grep { not /^\s*$/ } 
        $file->chomp->slurp;
    return @data;
}

sub parse_task() {
    my ( $task, $id ) = @_;

    die "Must specify task (string) to parse" if not defined( $task );

    my ( $todotxtline,
         $oDone, $oDonetag, $done, $oEnd, $end,
         $oPri, $pri,
         $oStart, $start,
         $detail,
         $oClockin, $clockin,
         $oClockout, $clockout
        ) =
        $task =~ m/^
                   (
                   (((x)\s)\s*((\d{4}-\d{2}-\d{2})\s)?)?  # opt done, with or without date
                   (\(([A-Z])\)\s)?                  # opt priority
                   ((\d{4}-\d{2}-\d{2})\s)?          # opt start date
                   (.*?)                             # detail
                   )
                   (\t(\d{4}\d{2}\d{2}T\d{2}\d{2}\d{2}))? # opt clock in
                   (\s(\d{4}\d{2}\d{2}T\d{2}\d{2}\d{2}))? # opt clock out
                  $/x;
    my $tasko = {
        todotxtline => $todotxtline,
        line => $task,
        detail => $detail };
    $tasko->{id}   = $id if $id;
    $tasko->{done} = $done if $done;
    $tasko->{start} = $start if $start;
    $tasko->{end}   = $end if $end;
    $tasko->{pri}   = $pri if $pri;
    $tasko->{clockin} = $clockin if $clockin;
    $tasko->{clockout} = $clockout if $clockout;

    push @{$tasko->{proj}}, $detail =~ /(\+[^\s]+)/g;
    push @{$tasko->{context}}, $detail =~ /(\@[^\s]+)/g;

    return $tasko;
}

my $todo = undef;
sub get_todo_line {
    my ( $linenum ) = @_;

    # verify conditions
    die "No line number passed to get_todo_line"
        if ( not defined $linenum );

    if ( not defined $todo ) {
        my @t = slurp_data(io("$tododir/todo.txt"));
        $todo = \@t;
    }

    my $lineidx = $linenum - 1;
    die "Specified line number $linenum is out of range [1..".scalar(@{$todo})."]"
        if ( $lineidx < 0 || $lineidx >= scalar( @{$todo} ) );
    
    return $todo->[$lineidx];
}

sub clockout($) {
    my ( $activeline ) = shift;
    
    die "Not currently clocked into any task" if not $activeline;
    
    say "Clocking out of '$active->{todotxtline}'";
    
    $clockf << "\t".time2str("%Y%m%dT%H%M%S", time);
}

sub clockin {
    my ( $line ) = shift;
    
    say "Clocking into '$line->{todotxtline}'";
    
    "\n$line->{line}\t".time2str("%Y%m%dT%H%M%S", time) >> $clockf;
}

sub spent_time( $ ) {
    my ( $task ) = shift;

    die "Can't compute spent time without a clock in" if not $task->{clockin};

    my $clockint  = str2time( $task->{clockin} );
    my $clockoutt = str2time( $task->{clockout} || time2str( "%c", time ) );

    return int(($clockoutt - $clockint)/60);  # minutes
}

sub say_group_sums {
    my ( $o, $level ) = ( shift, shift || 0 );
    #my $thisindent = $indent . '   ';
    my $indent;
    foreach my $l ( 1..$level ) { $indent .= '   ' };
    my $thisindent = $indent . '   ';


    die "Groups to summarize not stored as hash" if ref $o ne 'HASH';

    my $sumtotal = 0;
    my $total = 0;
    foreach my $gk ( sort { $a <=> $b } keys %{$o} ) {
        my $oo = $o->{$gk};
#        print STDERR "PROCESSING KEY $gk\n";
        if ( ref $oo eq 'ARRAY' ) {
            # A list of matching tasks for this group...
            $total = 0;
            foreach my $t ( @{$oo} ) {
                $total += spent_time( $t );
                #say sprintf "$thisindent%5d: $t->{todotxtline}", $total;
            }
            say sprintf "$thisindent%3d:%2.2d - $gk", $total/60,$total%60;            
            $sumtotal += $total;

        } elsif ( ref $oo eq 'HASH' ) {
            # we have a subgrouping
            say "\n$indent$gk:";
            my $bigtotal = say_group_sums($oo, $level + 1 );
            say sprintf "$thisindent   -----";
            say sprintf "$thisindent   %3d:%2.2d - total $gk", $bigtotal/60,$bigtotal%60;
        }
    }
    return $sumtotal;
}    

1;


=head1 NAME

todo.sh clock - Using the clock add-on for todo.sh

=head1 SYNOPSIS

todo.sh clock [command [command options] [command arguments]]

 Global Options:
   -v		  verbose

 Commands:

   in <linenum>	  Clock in to the task associated with 
                      <linenum>.  Clocking out of the active
                      task if necessary.
   out            Clock out of the current task (if any)
   what|wh        Show what the current task is (if any)
   report|rep [--groupings=[indate],[project]]
                  Report time recorded for each task in the clock.dat file

=head1 GLOBAL OPTIONS

=over 8

=item B<-v>

Show what is being done.

=back

=head1 DESCRIPTION

The B<clock> add-on for B<todo.sh> will keep track of the time spent in
performing each task.

=cut