# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# A simple logger for Nit
#
# ## Basic Usage
#
# Create a new `Logger` with a severity level threshold set to `warn_level`:
#
# ~~~
# var logger = new Logger(warn_level)
# ~~~
#
# Messages with a severity equal or higher than `warn_level` will be displayed:
#
# ~~~
# logger.error "Displays an error."
# logger.warn "Displays a warning."
# ~~~
#
# Messages with a lower severity are silenced:
#
# ~~~
# logger.info "Displays nothing."
# ~~~
#
# `FileLogger` can be used to output the messages into a file:
#
# ~~~
# var log_file = "my.log"
#
# logger = new FileLogger(warn_level, log_file, append = false)
# logger.error("An error")
# logger.info("Some info")
# logger.close
#
# assert log_file.to_path.read_all == "An error\n"
# log_file.to_path.delete
# ~~~
#
# ## Severity levels
#
# Each message is associated with a level that indicate its severity.
# Only messages with a severity equal to or higher than the logger `level`
# threshold will be displayed.
#
# Severity levels from the most severe to the least severe:
#
# * `unknown_level`: An unknown message that should always be outputted.
# * `fatal_level`: An unhandleable error that results in a program crash.
# * `error_level`: A handleable error condition.
# * `warn_level`: A warning.
# * `info_level`: Generic (useful) information about system operation.
# * `debug_level`: Low-level information for developpers.
#
# ## Formatting messages
#
# You can create custom formatters by implementing the `Formatter` interface.
#
# ~~~
# class MyFormatter
#	super Formatter
#
#	redef fun format(level, message) do
#		if level < warn_level then return super
#		return "!!!{message}!!!"
#	end
# end
# ~~~
#
# See `DefaultFormatter` for a more advanced implementation example.
#
# Each Logger can be given a default formatter used to format the every messages
# before outputting them:
#
# ~~~
# var formatter = new MyFormatter
# var stderr = new StringWriter
# var logger = new Logger(warn_level, stderr, formatter)
#
# logger.warn("This is a warning.")
# assert stderr.to_s.trim.split("\n").last == "!!!This is a warning.!!!"
# ~~~
#
# Optionally, a `Formatter` can be given to replace the `default_formatter`
# used by default:
#
# ~~~
# # Create a formatter with no default decorator
# logger = new Logger(warn_level, stderr, null)
#
# # Display a message without any formatter
# logger.warn("This is a warning.")
# assert stderr.to_s.trim.split("\n").last == "This is a warning."
#
# # Display a message with a custom formatter
# logger.warn("This is a warning.", formatter)
# assert stderr.to_s.trim.split("\n").last == "!!!This is a warning.!!!"
# ~~~
module logger

import console

# A simple logging utility
#
# `Logger` provides a simple way to output messages from applications.
#
# Each message is associated with a level that indicate its severity.
# Only messages with a severity equal to or higher than the logger `level`
# threshold will be displayed.
#
# ~~~
# var logger = new Logger(warn_level)
# assert logger.unknown("unkown")
# assert logger.fatal("fatal")
# assert logger.error("error")
# assert logger.warn("warn")
# assert not logger.info("info")
# assert not logger.debug("debug")
# ~~~
class Logger

	# Severity threshold
	#
	# Messages with a severity level greater than or equal to `level` will be displayed.
	# Default is `warn_level`.
	#
	# See `unknown_level`, `fatal_level`, error_level``, `warn_level`,
	# `info_level` and `debug_level`.
	var level: Int = warn_level is optional, writable

	# Kind of `Writer` used to output messages
	type OUT: Writer

	# Writer used to output messages
	#
	# Default is `stderr`.
	var out: OUT = stderr is optional

	# Formatter used to format messages before outputting them
	#
	# By default no formatter is used.
	#
	# See `DefaultFormatter`.
	var default_formatter: nullable Formatter = null is optional, writable

	# Output a message with `level` severity
	#
	# Only output messages with `level` severity greater than of equal to `self.level`.
	#
	# ~~~
	# var stderr = new StringWriter
	# var logger = new Logger(warn_level, stderr, null)
	#
	# # This message will be displayed:
	# assert logger.warn("This is a warning.")
	# assert stderr.to_s.trim.split("\n").last == "This is a warning."
	#
	# # This message will not:
	# assert not logger.info("This is some info.")
	# assert stderr.to_s.trim.split("\n").last == "This is a warning."
	# ~~~
	#
	# Each logger can be given a default formatter used to format the messages
	# before outputting them:
	#
	# ~~~
	# var formatter = new DefaultFormatter(no_color = true)
	# logger = new Logger(warn_level, stderr, formatter)
	# logger.warn("This is a warning.")
	# assert stderr.to_s.trim.split("\n").last == "Warning: This is a warning."
	# ~~~
	#
	# Optionally, a `Formatter` can be given to replace the `default_formatter`
	# used by default.
	#
	# ~~~
	# # Create a formatter with no default decorator
	# logger = new Logger(warn_level, stderr, null)
	#
	# # Display a message without any formatter
	# logger.warn("This is a warning.")
	# assert stderr.to_s.trim.split("\n").last == "This is a warning."
	#
	# # Display a message with a custom formatter
	# logger.warn("This is a warning.", formatter)
	# assert stderr.to_s.trim.split("\n").last == "Warning: This is a warning."
	# ~~~
	fun add(level: Int, message: Writable, formatter: nullable Formatter): Bool do
		var format = formatter or else default_formatter
		if format == null then
			return add_raw(level, message)
		end
		return add_raw(level, format.format(level, message))
	end

	# Output a message with `level` severity without formatting it
	#
	# Only output messages with `level` severity greater than of equal to `self.level`.
	#
	# ~~~
	# var stderr = new StringWriter
	# var logger = new Logger(warn_level, stderr, null)
	#
	# # This message will be displayed:
	# assert logger.add_raw(warn_level, "This is a warning.")
	# assert stderr.to_s.trim.split("\n").last == "This is a warning."
	#
	# # This message will not:
	# assert not logger.add_raw(info_level, "This is some info.")
	# assert stderr.to_s.trim.split("\n").last == "This is a warning."
	# ~~~
	fun add_raw(level: Int, message: Writable): Bool do
		if level < self.level then return false
		out.write(message.write_to_string)
		out.write("\n")
		return true
	end

	# Output a message with `unknown_level` severity
	#
	# Unkown severity messages are always outputted.
	fun unknown(message: String, formatter: nullable Formatter): Bool do
		return add(unknown_level, message, formatter)
	end

	# Output a message with `fatal_level` severity
	fun fatal(message: String, formatter: nullable Formatter): Bool do
		return add(fatal_level, message, formatter)
	end

	# Output a message with `error_level` severity
	fun error(message: String, formatter: nullable Formatter): Bool do
		return add(error_level, message, formatter)
	end

	# Output a message with `warn_level` severity
	fun warn(message: String, formatter: nullable Formatter): Bool do
		return add(warn_level, message, formatter)
	end

	# Output a message with `info_level` severity
	fun info(message: String, formatter: nullable Formatter): Bool do
		return add(info_level, message, formatter)
	end

	# Output a message with `debug` severity
	fun debug(message: String, formatter: nullable Formatter): Bool do
		return add(debug_level, message, formatter)
	end
end

# Log messages to a file
#
# ~~~
# var log_file = "my_file.log"
# var logger = new FileLogger(warn_level, log_file, append = false)
# logger.error("An error")
# logger.info("Some info")
# logger.close
# assert log_file.to_path.read_all == "An error\n"
#
# logger = new FileLogger(warn_level, log_file, append = true)
# logger.error("Another error")
# logger.close
# assert log_file.to_path.read_all == "An error\nAnother error\n"
#
# log_file.to_path.delete
# ~~~
class FileLogger
	super Logger
	autoinit level, file, append, default_formatter

	redef type OUT: FileWriter

	# File where messages will be written
	var file: String

	# Append messages to `file`
	#
	# If `append` is `false`, the `file` will be overwritten.
	var append: Bool = true is optional

	init do
		var old = null
		if append then
			old = file.to_path.read_all
		end
		out = new FileWriter.open(file)
		out.set_buffering_mode(0, buffer_mode_line)
		if old != null then
			out.write(old)
		end
	end

	# Close the logger and its `file`
	fun close do out.close
end

# Format messages before outputing them
#
# A `Logger` can use a `Formatter` to format the messages before outputting them.
#
# See `DefaultFormatter`.
interface Formatter

	# Format `message` depending of its severity `level`
	fun format(level: Int, message: Writable): Writable do return message
end

# Default `Logger` formatter
#
# The default formatter decorates the messages with severity labels and colors.
class DefaultFormatter
	super Formatter

	# Do not decorate messages with colors
	#
	# ~~~
	# var formatter = new DefaultFormatter(no_color = true)
	# assert formatter.format(error_level, "My message.") == "Error: My message."
	# ~~~
	var no_color = false is optional, writable

	redef fun format(level, message) do
		var string = message.write_to_string

		if level == fatal_level then
			string = "Fatal: {string}"
		else if level == error_level then
			string = "Error: {string}"
		else if level == warn_level then
			string = "Warning: {string}"
		else if level == info_level then
			string = "Info: {string}"
		else if level == debug_level then
			string = "Debug: {string}"
		end

		if no_color then return string

		if level == fatal_level then
			return string.red
		else if level == error_level then
			return string.red
		else if level == warn_level then
			return string.yellow
		else if level == info_level then
			return string.purple
		else if level == debug_level then
			return string.blue
		end

		return string
	end
end

redef class Sys

	# Unknown severity level
	#
	# These messages are always displayed.
	#
	# See `Logger`.
	var unknown_level = 5

	# Fatal severity level
	#
	# See `Logger`.
	var fatal_level = 4

	# Error severity level
	#
	# See `Logger`.
	var error_level = 3

	# Warning severity level
	#
	# See `Logger`.
	var warn_level = 2

	# Info severity level
	#
	# See `Logger`.
	var info_level = 1

	# Debug severity level
	#
	# See `Logger`.
	var debug_level = 0
end