###########################################################################
#
# plugin.pm -- functions to handle using plugins
# A component of the Greenstone digital library software
# from the New Zealand Digital Library Project at the 
# University of Waikato, New Zealand.
#
# Copyright (C) 1999 New Zealand Digital Library Project
#
# 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.
#
###########################################################################

package plugin;

require util;
use gsprintf;

my $stats = {'num_processed' => 0,
	     'num_blocked' => 0,
	     'num_not_processed' => 0,
	     'num_archives' => 0
	     };


sub gsprintf
{
    return &gsprintf::gsprintf(@_);
}


sub load_plugins {
    my ($plugin_list) = shift @_;
    ($verbosity, $outhandle, $failhandle) = @_; # globals
    my @plugin_objects = ();

    $verbosity = 2 unless defined $verbosity;
    $outhandle = STDERR unless defined $outhandle;
    $failhandle = STDERR unless defined $failhandle;

    foreach $pluginoptions (@$plugin_list) {
	my $pluginname = shift @$pluginoptions;
	next unless defined $pluginname;

	# find the plugin
	my $colplugname = &util::filename_cat($ENV{'GSDLCOLLECTDIR'},"perllib/plugins", 
					      "${pluginname}.pm");
	my $mainplugname = &util::filename_cat($ENV{'GSDLHOME'},"perllib/plugins", 
					       "${pluginname}.pm");
	if (-e $colplugname) { require $colplugname; }
	elsif (-e $mainplugname) { require $mainplugname; }
	else { &gsprintf(STDERR, "{plugin.could_not_find_plugin}\n", $pluginname) && die "\n";
	       # die "ERROR - couldn't find plugin \"$pluginname\"\n";
	   }

	# create a plugin object
	my ($plugobj);
	map { $_ = "\"$_\""; } @$pluginoptions;
	my $options = join (",", @$pluginoptions);
	$options =~ s/\$/\\\$/g;
	eval ("\$plugobj = new \$pluginname($options)");
	die "$@" if $@;
	
	# initialize plugin
	$plugobj->init($verbosity, $outhandle, $failhandle);

	# add this object to the list
	push (@plugin_objects, $plugobj);
    }

    return \@plugin_objects;
}


sub begin {
    my ($pluginfo, $base_dir, $processor, $maxdocs) = @_;

    map { $_->begin($pluginfo, $base_dir, $processor, $maxdocs); } @$pluginfo;
}

sub read {
    my ($pluginfo, $base_dir, $file, $metadata, $processor, $maxdocs, $aux) = @_;

    $maxdocs = -1 unless defined $maxdocs && $maxdocs =~ /\d/;
    my $rv = 0;

    # the .kill file is a handy (if not very elegant) way of aborting 
    # an import.pl or buildcol.pl process
    if (-e &util::filename_cat ($ENV{'GSDLCOLLECTDIR'}, ".kill")) {
	&gsprintf($outhandle, "{plugin.kill_file}\n");
	# print $outhandle "Process killed by .kill file\n";
	die "\n";
    }
    
    # pass this file by each of the plugins in turn until one
    # is found which will process it
    foreach $plugobj (@$pluginfo) {
	$rv = $plugobj->read($pluginfo, $base_dir, $file, 
			     $metadata, $processor, $maxdocs, $aux);
	return $rv if defined $rv;
    }

    if ($verbosity >= 2) {
	&gsprintf($outhandle, "{plugin.no_plugin_could_process}\n", $file);
	# print $outhandle "WARNING - no plugin could process $file\n";
    }
    
    $file =~ s/.*?([^\\\/]+)$/$1/;
    &gsprintf($failhandle, "$file: {plugin.no_plugin_could_process_this_file}\n");
    # print $failhandle "$file: no plugin could process this file\n";
    $stats->{'num_not_processed'} ++;

    return 0;
}

# write out some general stats that the plugins have compiled - note that
# the buildcol.pl process doesn't currently call this process so the stats
# are only output after import.pl -
sub write_stats {
    my ($pluginfo, $statshandle, $faillog) = @_;

    foreach $plugobj (@$pluginfo) {
	$plugobj->compile_stats($stats);
    }

    my $total = $stats->{'num_processed'} + $stats->{'num_blocked'} + 
	$stats->{'num_not_processed'};

    if ($total == 1) {
	&gsprintf($statshandle, "* {plugin.one_considered}\n");
	# print $statshandle "* 1 document was considered for processing\n";
    } else {
	&gsprintf($statshandle, "* {plugin.n_considered}\n", $total);
	# print $statshandle "* $total documents were considered for processing\n";
    }
    if ($stats->{'num_archives'}) {
	# print $statshandle "   (including the contents of " . $stats->{'num_archives'} .
	#     " ZIP/TAR archive";
	if ($stats->{'num_archives'} == 1) {
	    &gsprintf($statshandle, "   ({plugin.including_archive})\n");
	    # print $statshandle ")\n";}
	}
	else {
	    &gsprintf($statshandle, "   ({plugin.including_archives})\n", $stats->{'num_archives'});
	    # print $statshandle "s)\n";}
	}
    }
    if ($stats->{'num_processed'} == 1) {
	&gsprintf($statshandle, "* {plugin.one_included}\n");
	# print $statshandle "* 1 was processed and included in the collection\n";
    } else {
	&gsprintf($statshandle, "* {plugin.n_included}\n", $stats->{'num_processed'});
	# print $statshandle "* " . $stats->{'num_processed'} . " were processed and included in the collection\n";
    }
    if ($stats->{'num_not_processed'}) {
	if ($stats->{'num_not_processed'} == 1) {
	    &gsprintf($statshandle, "* {plugin.one_rejected}\n");
	    # print $statshandle "* 1 was rejected.";
	} else {
	    &gsprintf($statshandle, "* {plugin.n_rejected}\n", $stats->{'num_not_processed'});
	    # print $statshandle "* " . $stats->{'num_not_processed'} . " were rejected.";
	}
	&gsprintf($statshandle, " {plugin.see_faillog}\n", $faillog);
	# print $statshandle " See $faillog for a list of rejected documents\n";
    }
}

sub end {
    my ($pluginfo, $processor) = @_;
    map { $_->end($processor); } @$pluginfo;
}

1;