class Console::Filter

def self.[] **levels
	klass = Class.new(self)
	
	klass.instance_exec do
		const_set(:LEVELS, levels)
		const_set(:MINIMUM_LEVEL, levels.values.min)
		const_set(:MAXIMUM_LEVEL, levels.values.max)
		
		levels.each do |name, level|
			const_set(name.to_s.upcase, level)
			
			define_method(name) do |subject = nil, *arguments, **options, &block|
				if self.enabled?(subject, level)
					self.call(subject, *arguments, severity: name, **options, **@options, &block)
				end
			end
			
			define_method("#{name}!") do
				@level = level
			end
			
			define_method("#{name}?") do
				@level >= level
			end
		end
	end
	
	return klass
end

def all!
	@level = -1
end

def call(*arguments, **options, &block)
	@output.call(*arguments, **options, &block)
end

def disable(subject)
	unless subject.is_a? Class
		subject = subject.class
	end
	
	@subjects.delete(subject)
end

def enable(subject, level = self.class::MINIMUM_LEVEL)
	unless subject.is_a?(Class)
		subject = subject.class
	end
	
	@subjects[subject] = level
end

def enabled?(subject, level = self.class::MINIMUM_LEVEL)
	if specific_level = @subjects[subject.class]
		return level >= specific_level
	end
	
	if level >= @level
		return true
	end
end

def initialize(output, verbose: true, level: self.class::DEFAULT_LEVEL, enabled: nil, **options)
	@output = output
	@verbose = verbose
	@level = level
	
	@subjects = {}
	
	@options = options
	
	if enabled
		enabled.each{|name| enable(name)}
	end
end

def level= level
	if level.is_a? Symbol
		@level = self.class::LEVELS[level]
	else
		@level = level
	end
end

def off!
	@level = self.class::MAXIMUM_LEVEL + 1
end

def verbose!(value = true)
	@verbose = value
	@output.verbose!(value)
end

def with(level: @level, verbose: @verbose, **options)
	dup.tap do |logger|
		logger.level = level
		logger.verbose! if verbose
		logger.options = @options.merge(options)
	end
end