#! /usr/bin/perl -w

use strict ;
use Repocafe ;

my $prog = substr($0,rindex($0,'/')+1) ;
my $Usage = <<USAGE ;
Usage: $prog [-v] [-q] [-d] [-f] [-l] [-c conf] [ login ... ]
option v  : be verbose
option q  : be quiet
option d  : show debug info
option f  : action ; otherwise dry-run
option l  : list xusers (no updates) ;
option c  : use config <conf>
arguments login ... : restrict to login1, login2, ...
----------------------------------------
- $prog - update the repo_xusers table.
- Table repo_xusers contains repocafe users that can't be found
  in the configured ldap(s) or table repo_guests.
- The repo_xusers table in only used in the statistics page.
- Running "$prog -l -v" gives a detailed listing of all logins
  found as owners, in access-rights or as group members.
- Because running $prog may take some time to complete,
  we suggest to run it daily by cron.
- Cronjob : ( cd <DIR_ADMIN> ; /usr/bin/perl upd_xusers -f )
----------------------------------------
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') ;
our %opt = () ; Usage('') unless GetOptions
  ( \%opt, qw(v q d f l c=s help) ) ;
if ( $opt{help} ) { print $Usage ; exit 0 ; }
# Usage("Arg count\n") unless @ARGV == 0 ;

my $Cafe = make_cafe ( %opt ) ;
my $conf = $Cafe -> conf ;
my $logins = {} ;

sub restrict
  { my $hash = shift ;
    my %res =
      map { $_ => $hash -> { $_ } } grep { exists $hash -> { $_ } } @_ ;
    \%res ;
  }

sub add_xuser
  { my $usr = shift ;
    my $tag = 'WOULD' ;
    my $rec = $Cafe -> xusers -> new_rec ( { pid => $usr } ) ;
    my $err ; die $err if $err = $rec -> _check ;
    if ( $opt{f} ) { $tag = 'DID' ; $rec -> _save ; }
    print "$tag add    xuser $usr\n" unless $opt{q} ;
  }

sub del_xuser
  { my $usr = shift ;
    my $tag = 'WOULD' ;
    my $rec = $Cafe -> xusers -> select1
      ( -where =>  "pid = ?", -args => [ $usr ] ) ;
    if ( $opt{f} )
      { $tag = 'DID' ; $rec -> _delete ; }
    print "$tag delete xuser $usr\n" unless $opt{q} ;
  }

my @repos   = $Cafe -> repos  -> select ;
my @groups  = $Cafe -> groups -> select ;
my @members = $Cafe -> gr_mem -> select ;
my $xusers  = $Cafe -> xusers -> select_hash ( 'pid' ) ;

my $grp4gid = {} ;
for my $group ( @groups )
  { $grp4gid -> { $group -> gid } = $group ;
    my $name = $group -> name ;
    push @{ $logins -> { $group -> ownr } }, "owner  of group $name" ;
  }

for my $repo ( @repos )
  { my $name = $repo -> repo_name ;
    push @{ $logins -> { $repo -> ownr } }, "owner  of repo $name" ;
    for my $Path ( values %{ $repo -> paths } )
      { for my $pid ( keys %{ $Path -> rights } )
          { my $path = $Path -> path ;
            push @{ $logins -> { $pid } }, "rights in repo $name/$path"
              unless $pid =~ /^@/ ; # skip groups
          }
      }
  }

for my $mem ( @members )
  { my $pid = $mem -> pid ;
    my $gid = $mem -> gid ;
    my $nam = $grp4gid -> { $gid } -> name ;
    push @{ $logins -> { $pid } }, "member of $nam"
      unless $pid =~ /^@/ ; # skip groups
  }

if ( @ARGV )
  { $logins = restrict $logins, @ARGV ;
    $xusers = restrict $xusers, @ARGV ;
  }

my $users = $Cafe -> lookups ( sort keys %$logins ) ;
my %users ; for my $user ( @$users )
  { $users { $user -> login } = $user ; }

if ( $opt{l} )
  { if ( $opt{v} )
      { for my $login ( sort keys %$logins )
          { printf "login %s - clas '%s' - name '%s' :\n  %s\n",
              , $login
              , ( exists $users { $login }
                ? $users { $login } -> clas
                : 'unknown user'
                )
              , ( exists $users { $login }
                ? $users { $login } -> name
                : 'unknown user'
                )
              , ( join "\n  ", @{ $logins -> { $login } } )
              ;
          }
      }
    else
      { for my $xuser ( sort keys %$xusers )
          { printf "%s\n", $xuser ; }
      }
    exit 0 ;
  }

for my $login ( sort keys %$logins )
  { add_xuser $login
      unless exists $users { $login } or exists $xusers -> { $login } ;
  }

for my $xuser ( sort keys %$xusers )
  { del_xuser $xuser
      if exists $users { $xuser } or ! exists $logins -> { $xuser } ;
  }