#! /usr/bin/perl

# mail-watchers

# -- looks up the repo in the database ;
# -- determines the repo's watchers :
#    $watchlist -> { $watcher } { $path } == is_watcher
#
# -- for each watcher, uses 'SVN::Notify' to notify the watcher,
#    picking the relevant parts (by $path) from the svn-diff ;
#    The longest matching path determines the relevancy.
#
# -- called from every REPO/hooks/post-commit as
#    $prog repo-name revision repo_id

use lib 'lib' ;
use strict ;
use warnings ;

use Repocafe ;
use SVN::Notify ;
use PickDiff ;
use lib::DiffPicker ;

my $prog = substr($0,rindex($0,'/')+1) ;
my $Usage = <<USAGE ;
Usage: $prog [-v] [-q] [-d] path-to-repo rev repo_id
option v : be verbose ; dry-run
option q : be quiet
option d : show debug info
----------------------------------------
- $prog - send commit-mail to watchers.
- $prog is called from 'REPO/hooks/post-commit' as
    $prog REPO REVISION REPO_ID
- It computes the watchers and uses SVN::Notify to notify each watcher ;
  $prog picks the relevant parts from the "svn-diff".
- Normally $prog is not used by admins.
----------------------------------------
USAGE
sub Usage { die "$_[0]$Usage" ; }
sub Error { die "$prog: $_[0]\n" ; }
sub Warn  { warn "$prog: $_[0]\n" ; }

# usage: &GetOptions(ARG,ARG,..) defines $opt_ID as 1 or user spec'ed value
# usage: &GetOptions(\%opt,ARG,ARG,..) defines $opt{ID} as 1 or user value
# ARG = 'ID' | 'ID=SPC' | 'ID:SPC' for no-arg, required-arg or optional-arg
# ID  = perl identifier
# SPC = i|f|s for integer, fixedpoint real or string argument

use Getopt::Long ;
Getopt::Long::config('no_ignore_case') ;
my %opt = () ; Usage('') unless GetOptions
  ( \%opt, qw(v q d c help) ) ;
if ( $opt{help} ) { print $Usage ; exit 0 ; }
Usage("Arg count\n") unless @ARGV == 3 ;

$opt{v} ||= $opt{d} ;

unless ( $opt{v} )
  { close STDOUT ; open STDOUT, ">/dev/null" ;
    close STDERR ; open STDERR, ">/dev/null" ;
  }

my $REPO = shift ;
my $REV  = shift ;
my $RID  = shift ;

my $Cafe = make_cafe ( c => $opt{c} ) ;
my $conf = $Cafe -> conf ;
my $serv = $conf -> www_server ;
my $from = $conf -> mail_from_noreply ;

my $REPO_DIR = $conf -> dir_repos ;
my @PROG = split ' ', $conf -> cmd_commit_email ;
my @OPTS = ( '--from', $from ) ;

# $Cafe -> repos -> dmp ( -incl => [ 'TAB' ] ) if $opt{v} ;
my $repo = $Cafe -> repos -> get ( $RID ) ;

my $name = $repo -> repo_name ;
my $path = $repo -> path ;
my @wats = $repo -> watchers ;
my $list = $repo -> watch_list ;

Error "REPO != path ; $REPO != $path" if $opt{v} and $REPO ne $path ;

my %notify_opts =
  ( repos_path => $REPO
  , revision   => $REV
  , sendmail   => '/usr/sbin/sendmail'
  , from       => $from
  , with_diff  => 1
  , diff_switches   => '--no-diff-added --no-diff-deleted'
  , max_sub_length  => 100
  , max_diff_length => 1024 * 1024
  , filters => [ 'lib::DiffPicker' ]
  , subject_prefix => $name
  ) ;

sub mk_sub_like
  { my $hash = shift ;
    sub
      { my $file = shift ;
        my $res = 0 ;
        for my $path ( sort keys %$hash )
          { $res = $hash -> { $path }
              if $path eq '' or $file =~ m!^$path/! ;
          }
        $res ;
      }
  }

for my $mail ( sort keys %$list )
  { my $paths = $list -> { $mail } ;
    my $N     = lib::DiffPicker -> new ( %notify_opts , to => $mail ) ;
    my $like  = PickDiff -> set_like ( mk_sub_like ( $paths ) ) ;
    my @likes = () ;
    my $prep  = $N -> prepare ;

    if ( $opt{v} )
      { printf "%s :\n%s", $mail, join '',
          map { sprintf "  watching (%s,%s)\n", $_, $paths -> { $_ } || 0 ; }
           sort keys %$paths ;
        printf "repo -> path (%s)\n", $path ;
        printf "user -> mail (%s)\n", $mail ;
        printf "prepare %s\n", $prep ;
      }

    my $files = $N -> files ;
    for my $key ( sort keys %$files )
      { my @names = @{ $files -> { $key } } ;
        my @like  = grep &$like ( $_ ),  @names ;
        $files -> { $key } = [ @like ] ;
        push @likes, @like ;
        if ( $opt{v} )
          { printf "  like %s %s\n", $_, &$like ( $_ ) for @names ; }
      }

    if ( @likes )
      { unless ( $opt{d} )
          { no warnings ;
            my $exec = $N -> execute ;
            printf "execute %s\n", $exec if $opt{v} ;
          }
      }

    if ( $opt{v} )
      { printf "from %s\n", $from ;
        printf "to %s\n", @{ $N -> { to } } ;
        printf "like %d\n[ %s\n]\n", scalar @likes, join "\n, ", @likes ;
      }
  }