use v6.c;

use Log::Any::Pipeline;
use Log::Any::Filter;
use Log::Any::Formatter;
use Log::Any::Definitions;



head

class Log::Any {
	my $instance;

	has %!pipelines = { '_default' => Log::Any::Pipeline.new };

	has %!severities = %Log::Any::Definitions::SEVERITIES;

	method new {
		unless $instance {
			$instance = Log::Any.bless;
		}
		return $instance;
	}

	# Log::Any.add
	multi method add( Log::Any:U: Log::Any::Adapter $a, Str :$pipeline = '_default', :$filter, :$formatter = Nil, :$continue-on-match ) {
		return self.new.add( $a, :$pipeline, :$filter, :$formatter, :$continue-on-match );
	}

	# Log::Any.new.add
	multi method add( Log::Any:D: Log::Any::Adapter $a, Str :$pipeline = '_default', :$filter, :$formatter = Nil, :$continue-on-match ) {
		my Log::Any::Filter $local-filter;
		my Log::Any::Formatter $local-formatter;

		given $filter {
			when Array {
				$local-filter = Log::Any::FilterBuiltIN.new( checks => @$filter );
			}
			when Log::Any::Filter {
				$local-filter = $filter;
			}
		}

		given $formatter {
			when Str {
				$local-formatter = Log::Any::FormatterBuiltIN.new( :format( $formatter ) );
			}
			when Log::Any::Formatter {
				$local-formatter = $formatter;
			}
			when Nil {
				# No formatter specified
			}
			default {
				die 'Unable to use formatter ' ~ $formatter.gist;
			}
		}

		unless %!pipelines{$pipeline} {
			# note "Adding adapter to pipeline $pipeline";
			%!pipelines{$pipeline} = Log::Any::Pipeline.new;
		}
		%!pipelines{$pipeline}.add( $a, :filter( $local-filter ), :formatter( $local-formatter ), :$continue-on-match );
	}

	multi method add( Log::Any:U:  Str :$pipeline = '_default', :$filter ) {
		return self.new.add( :$pipeline, :$filter );
	}

	multi method add( Log::Any:D:  Str :$pipeline = '_default', :$filter ) {
		my Log::Any::Filter $local-filter;
		given $filter {
			when Array {
				$local-filter = Log::Any::FilterBuiltIN.new( checks => @$filter );
			}
			when Log::Any::Filter {
				$local-filter = $filter;
			}
		}

		unless %!pipelines{$pipeline} {
			# note "Adding adapter to pipeline $pipeline";
			%!pipelines{$pipeline} = Log::Any::Pipeline.new;
		}

		%!pipelines{$pipeline}.add( Log::Any::Adapter::BlackHole.new, :filter( $local-filter ) );
	}

	# Add a pipeline object
	multi method add( Log::Any:U: Log::Any::Pipeline $p, Str:D :$pipeline = '_default', :$overwrite = False ) {
		Log::Any.new.add( $p, :$pipeline, :$overwrite );
	}

	multi method add( Log::Any:D: Log::Any::Pipeline $p, Str:D :$pipeline = '_default', :$overwrite = False ) {
		if %!pipelines{$pipeline} && ! $overwrite {
			die "Cannot overwrite existing pipeline ($pipeline).";
		}
		%!pipelines{$pipeline} = $p;
	}

	proto method log( Log::Any: :$msg!, :$severity!, :$category is copy, :$pipeline = '_default', :%extra-fields --> Bool ) {*}

	multi method log( Log::Any:U: :$msg!, :$severity!, :$category is copy, :$pipeline = '_default', :%extra-fields --> Bool ) {
		return Log::Any.new.log( :$msg, :$severity, :$category, :$pipeline, :%extra-fields);
	}



	multi method log(Log::Any:D: :$msg!, :$severity!, :$category is copy, :$pipeline is copy, :%extra-fields --> Bool ) {
		# Check if the severity is handled
		die "Unknown severity $severity" unless %!severities{$severity};

		# Search the package name of caller if $category is not set
		# Can be null (Any) (no caller package)
		unless $category {
			# Search the package name of the caller
			for Backtrace.new -> $b {
				if $b.code ~~ Routine {
					if $b.code.package.^name ~~ /^ 'Log::Any' | ^ 'Backtrace' / {
						next;
					}
					$category = $b.code.package.^name;
					last;
				}
			}
			$category //= '';
		}

		# Capture the date as soon as possible
		my $date-time = DateTime.new( now );

		# Use the specified pipeline, or the default one
		$pipeline //= '_default';
		# note "Logging using pipeline $pipeline";
		my $pipeline-instance = %!pipelines{ $pipeline } // %!pipelines{'_default'};
		$pipeline-instance.dispatch( :$date-time, :$msg, :$severity, :$category, :%extra-fields, );

		return True;
	}


	# Check if the filter will be accepted with the specified attributes
	multi method will-log( Log::Any:U: :$severity!, :$category is copy, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return Log::Any.new.will-log( :$severity, :$category, :$pipeline );
	}

	multi method will-log( Log::Any:D: :$severity!, :$category is copy, :$pipeline = '_default', :%extra-fields ) returns Bool {

		# Check if the severity is handled
		die "Unknown severity $severity" unless %!severities{$severity};

		# Search the package name of caller if $category is not set
		# Can be null (Any) (no caller package)
		unless $category {
			# Search the package name of the caller
			for Backtrace.new -> $b {
				if $b.code ~~ Routine {
					if $b.code.package.^name ~~ /^ 'Log::Any' | ^ 'Backtrace' / {
						next;
					}
					$category = $b.code.package.^name;
					last;
				}
			}
			$category //= '';
		}

		# Use the specified pipeline, or the default one
		$pipeline //= '_default';
		# note "Logging using pipeline $pipeline";
		my $pipeline-instance = %!pipelines{ $pipeline } // %!pipelines{'_default'};

		return $pipeline-instance.will-dispatch( :$severity, :$category, :%extra-fields );
	}


	method emergency( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'emergency' ), :$category, :$pipeline, :%extra-fields );
	}

	method alert( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'alert' ), :$category, :$pipeline, :%extra-fields );
	}

	method critical( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'critical' ), :$category, :$pipeline, :%extra-fields );
	}

	method error( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'error' ), :$category, :$pipeline, :%extra-fields );
	}

	method warning( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'warning' ), :$category, :$pipeline, :%extra-fields );
	}

	method info( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'info' ), :$category, :%extra-fields, :$pipeline, :%extra-fields );
	}

	method notice( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'notice' ), :$category, :$pipeline, :%extra-fields );
	}

	method debug( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'debug' ), :$category, :$pipeline, :%extra-fields );
	}

	method trace( $msg, :$category, :$pipeline, :%extra-fields --> Bool ) {
		self.log( :$msg, :severity( 'trace' ), :$category, :$pipeline, :%extra-fields );
	}


	method will-emergency( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('emergency'), :$category, :$pipeline, :%extra-fields );
	}

	method will-alert( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('alert'), :$category, :$pipeline, :%extra-fields );
	}

	method will-critical( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('critical'), :$category, :$pipeline, :%extra-fields );
	}

	method will-error( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('error'), :$category, :$pipeline, :%extra-fields );
	}

	method will-warning( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('warning'), :$category, :$pipeline, :%extra-fields );
	}

	method will-info( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('info'), :$category, :$pipeline, :%extra-fields );
	}

	method will-notice( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('notice'), :$category, :$pipeline, :%extra-fields );
	}

	method will-debug( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('debug'), :$category, :$pipeline, :%extra-fields );
	}

	method will-trace( :$category, :$pipeline = '_default', :%extra-fields ) returns Bool {
		return self.will-log( :severity('trace'), :$category, :$pipeline, :%extra-fields );
	}

	# Dump Log::Any pipelines
	multi method gist( Log::Any:D: ) {
		return 'Log::Any.new(pipelines => ' ~ %!pipelines.gist ~ ', severities => ' ~ %!severities.gist ~ ')';
	}

	multi method gist( Log::Any:U: ) {
		return Log::Any.new.gist;
	}
}


root

Adapter

todo

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Any

Log::Any

method log

Parameters

Exceptions Dies if severity is unknown.