# Copyright 2016 Koha-Suomi Oy

use Scalar::Util qw(blessed);

    $self->_checkLoggerOverloads();

=head2 setConsoleVerbosity

    Koha::Logger->setConsoleVerbosity($verbosity);

Sets all Koha::Loggers to use also the console for logging and adjusts their verbosity by the given verbosity.

=USAGE

Do deploy verbose mode in a commandline script, add the following code:

    use C4::Context;

    use Koha::Logger;

    C4::Context->setCommandlineEnvironment();

    Koha::Logger->setConsoleVerbosity( 1 || -3 || 'WARN' || ... );

=PARAMS

@param {String or Signed Integer} $verbosity,

                if $verbosity is 0, no adjustment is made,

                If $verbosity is > 1, log level is decremented by that many steps towards TRACE

                If $verbosity is < 0, log level is incremented by that many steps towards FATAL

                If $verbosity is one of log levels, log level is set to that level.

=cut

sub setConsoleVerbosity {

    if ($_[0] eq __PACKAGE__ || blessed($_[0]) && $_[0]->isa('Koha::Logger') ) {

        shift(@_); #Compensate for erratic calling styles.

    }

    my ($verbosity) = @_;

    if (defined($verbosity)) { #Tell all Koha::Loggers to use a console logger as well

        unless ($verbosity =~ /^-?\d+$/ ||

                $verbosity =~ /^(?:FATAL|ERROR|WARN|INFO|DEBUG|TRACE)$/) {

            my @cc = caller(0);

            die $cc[3]."($verbosity):> \$verbosity must be a positive or negative digit, or a valid Log::Log4perl log level, eg. FATAL, ERROR, WARN, ...";

        }

        $ENV{LOG4PERL_TO_CONSOLE} = 1;

        $ENV{LOG4PERL_VERBOSITY_CHANGE} = $verbosity if defined($verbosity);

    }

}

=head2 _checkLoggerOverloads

Checks if there are Environment variables that should overload configured behaviour

=cut

# Define a stdout appender. I wonder how can I load a PatternedLayout from log4perl.conf here?

my $commandlineScreen =  Log::Log4perl::Appender->new(

                             "Log::Log4perl::Appender::Screen",

                             name      => "commandlineScreen",

                             stderr    => 0);

my $commandlineLayout = Log::Log4perl::Layout::PatternLayout->new( #I want this to be defined in log4perl.conf instead :(

                   "%d (%F:%L)> %m %n");

$commandlineScreen->layout($commandlineLayout);

sub _checkLoggerOverloads {

    my ($self) = @_;

    return unless blessed($self->{logger}) && $self->{logger}->isa('Log::Log4perl::Logger');

    if ($ENV{LOG4PERL_TO_CONSOLE}) {

        $self->{logger}->add_appender($commandlineScreen);

    }

    if ($ENV{LOG4PERL_VERBOSITY_CHANGE}) {

        if ($ENV{LOG4PERL_VERBOSITY_CHANGE} =~ /^-?(\d)$/) {

            if ($ENV{LOG4PERL_VERBOSITY_CHANGE} > 0) {

                $self->{logger}->dec_level( $1 );

            }

            elsif ($ENV{LOG4PERL_VERBOSITY_CHANGE} < 0) {

                $self->{logger}->inc_level( $1 );

            }

        }

        else {

            $self->{logger}->level( $ENV{LOG4PERL_VERBOSITY_CHANGE} );

        }

    }

}

Olli-Antti Kivilahti, E<lt>olli-antti.kivilahti@jns.fiE<gt>

sub getLogfile {

    return $logfile;

}

use Scalar::Util qw(blessed);

use Try::Tiny;

###############################################################################################

#### KD976 - Koha::Logger overload configuration for command line scripts verbosity levels ####

subtest "Overload Logger configurations", \&overloadLoggerConfigurations;

sub overloadLoggerConfigurations {

    my ($logger, $log, $LOGFILEOUT, $stdoutLogHandle, $stdoutLogPtr, @stdoutLog);

    $stdoutLogPtr = \$stdoutLogHandle;

    #Test increasing log verbosity

    ($LOGFILEOUT, $stdoutLogPtr) = _reopenStdoutScalarHandle($LOGFILEOUT, $stdoutLogPtr);

    Koha::Logger->setConsoleVerbosity(1);

    $logger = Koha::Logger->get({category => "test-is-fun-1"});

    _loggerBlarbAllLevels($logger);

    $log = t::Koha::Logger::slurpLog('wantArray');

    @stdoutLog = split("\n", $stdoutLogHandle);

    ok($log->[0]     =~ /info/,  'Increment by 1. file   - info ok');

    ok($stdoutLog[0] =~ /info/,  'Increment by 1. stdout - info ok');

    ok($log->[1]     =~ /warn/,  'Increment by 1. file   - warn ok');

    ok($stdoutLog[1] =~ /warn/,  'Increment by 1. stdout - warn ok');

    ok($log->[2]     =~ /error/, 'Increment by 1. file   - error ok');

    ok($stdoutLog[2] =~ /error/, 'Increment by 1. stdout - error ok');

    ok($log->[3]     =~ /fatal/, 'Increment by 1. file   - fatal ok');

    ok($stdoutLog[3] =~ /fatal/, 'Increment by 1. stdout - fatal ok');

    t::Koha::Logger::clearLog();

    #Test decreasing log verbosity

    ($LOGFILEOUT, $stdoutLogPtr) = _reopenStdoutScalarHandle($LOGFILEOUT, $stdoutLogPtr);

    Koha::Logger->setConsoleVerbosity(-1);

    $logger = Koha::Logger->get({category => "test-is-fun-2"});

    _loggerBlarbAllLevels($logger);

    $log = t::Koha::Logger::slurpLog('wantArray');

    @stdoutLog = split("\n", $stdoutLogHandle);

    ok($log->[0]     =~ /error/, 'Decrement by 1. file   - error ok');

    ok($stdoutLog[0] =~ /error/, 'Decrement by 1. stdout - error ok');

    ok($log->[1]     =~ /fatal/, 'Decrement by 1. file   - fatal ok');

    ok($stdoutLog[1] =~ /fatal/, 'Decrement by 1. stdout - fatal ok');

    t::Koha::Logger::clearLog();

    #Test increasing log verbosity multiple levels

    ($LOGFILEOUT, $stdoutLogPtr) = _reopenStdoutScalarHandle($LOGFILEOUT, $stdoutLogPtr);

    Koha::Logger->setConsoleVerbosity(2);

    $logger = Koha::Logger->get({category => "test-is-fun-3"});

    _loggerBlarbAllLevels($logger);

    $log = t::Koha::Logger::slurpLog('wantArray');

    @stdoutLog = split("\n", $stdoutLogHandle);

    ok($log->[0]     =~ /debug/, 'Increment by 1. file   - debug ok');

    ok($stdoutLog[0] =~ /debug/, 'Increment by 1. stdout - debug ok');

    ok($log->[1]     =~ /info/,  'Increment by 1. file   - info ok');

    ok($stdoutLog[1] =~ /info/,  'Increment by 1. stdout - info ok');

    ok($log->[2]     =~ /warn/,  'Increment by 1. file   - warn ok');

    ok($stdoutLog[2] =~ /warn/,  'Increment by 1. stdout - warn ok');

    ok($log->[3]     =~ /error/, 'Increment by 1. file   - error ok');

    ok($stdoutLog[3] =~ /error/, 'Increment by 1. stdout - error ok');

    ok($log->[4]     =~ /fatal/, 'Increment by 1. file   - fatal ok');

    ok($stdoutLog[4] =~ /fatal/, 'Increment by 1. stdout - fatal ok');

    t::Koha::Logger::clearLog();

    #Test decreasing log verbosity beyond FATAL, this results to no output

    ($LOGFILEOUT, $stdoutLogPtr) = _reopenStdoutScalarHandle($LOGFILEOUT, $stdoutLogPtr);

    Koha::Logger->setConsoleVerbosity(-3);

    $logger = Koha::Logger->get({category => "test-is-fun-4"});

    _loggerBlarbAllLevels($logger);

    $log = t::Koha::Logger::slurpLog('wantArray');

    @stdoutLog = split("\n", $stdoutLogHandle);

    is(scalar(@$log), 0,         'Decrement overboard. no logging');

    t::Koha::Logger::clearLog();

    #Test static log level

    ($LOGFILEOUT, $stdoutLogPtr) = _reopenStdoutScalarHandle($LOGFILEOUT, $stdoutLogPtr);

    Koha::Logger->setConsoleVerbosity('FATAL');

    $logger = Koha::Logger->get({category => "test-is-fun-5"});

    _loggerBlarbAllLevels($logger);

    $log = t::Koha::Logger::slurpLog('wantArray');

    @stdoutLog = split("\n", $stdoutLogHandle);

    ok($log->[0]     =~ /fatal/, 'Static log level. file   - fatal ok');

    ok($stdoutLog[0] =~ /fatal/, 'Static log level. stdout - fatal ok');

    t::Koha::Logger::clearLog();

    #Test bad log level, then continue using the default config unhindered

    ($LOGFILEOUT, $stdoutLogPtr) = _reopenStdoutScalarHandle($LOGFILEOUT, $stdoutLogPtr);

    try {

        Koha::Logger->setConsoleVerbosity('WARNNNG');

        die "We should have died";

    } catch {

        ok($_ =~ /verbosity must be a positive or negative digit/, "Bad \$verbosiness, but got instructions on how to properly give \$verbosiness");

    };

    $logger = Koha::Logger->get({category => "test-is-fun-6"});

    _loggerBlarbAllLevels($logger);

    $log = t::Koha::Logger::slurpLog('wantArray');

    @stdoutLog = split("\n", $stdoutLogHandle);

    ok($log->[0]     =~ /fatal/, 'Bad config, defaulting. file   - fatal ok');

    ok($stdoutLog[0] =~ /fatal/, 'Bad config, defaulting. stdout - fatal ok');

    t::Koha::Logger::clearLog();

    close($LOGFILEOUT);

}

#### END OF Test for KD976 - Koha::Logger overload configuration for command line scripts verbosity levels ####

###############################################################################################################

sub _loggerBlarbAllLevels {

    my ($logger) = @_;

    $logger->trace('trace');

    $logger->debug('debug');

    $logger->info('info');

    $logger->warn('warn');

    $logger->error('error');

    $logger->fatal('fatal');

}

sub _reopenStdoutScalarHandle {

    my ($LOGFILEOUT, $pointerToScalar) = @_;

    $$pointerToScalar = '';

    close($LOGFILEOUT) if $LOGFILEOUT;

    open($LOGFILEOUT, '>', $pointerToScalar) or die $!;

    $LOGFILEOUT->autoflush ( 1 );

    select $LOGFILEOUT; #Use this as the default print target, so Console appender is redirected to this logfile

    return ($LOGFILEOUT, $pointerToScalar);

}