cylogger/main.go

// Package cylogger provides a feature-rich, colored logging library for Go applications.
// It offers structured logging with multiple levels, colored output, goroutine tracking,
// panic recovery, and object dumping capabilities.
//
// Key Features:
//   - Multiple log levels (Error, Warning, Info, Debug, Trace, Dump, Lua)
//   - Colored terminal output with customizable styling
//   - Structured logging with fields and context
//   - Goroutine ID tracking
//   - Panic recovery and safe goroutine execution
//   - Object dumping for debugging and testing
//   - Multiple output destinations (stdout, files)
//   - Thread-safe operations
//
// Basic Usage:
//
//	cylogger.Init(cylogger.LevelInfo)
//	cylogger.Info("Application started")
//	cylogger.WithField("user", "john").Info("User logged in")
//
// Advanced Usage:
//
//	logger := cylogger.New(os.Stdout, "", log.LstdFlags)
//	logger.SetLevel(cylogger.LevelDebug)
//	logger.WithFields(map[string]interface{}{"service": "api", "version": "1.0"}).Info("Service initialized")
package cylogger

import (
	"bytes"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/hexops/valast"
)

// TODO: Enable turning colors on and off maybe even per stream?

var loglevel = flag.String("loglevel", "info", "log level")

// LogLevel defines the severity and type of log messages.
// Lower values indicate higher priority. Messages are only logged if their level
// is less than or equal to the current logger level.
type LogLevel int

const (
	// LevelError is for critical errors that should always be displayed.
	// These represent serious problems that may cause the application to fail.
	LevelError LogLevel = iota

	// LevelWarning is for important warnings that indicate potential issues.
	// These represent situations that are not errors but may require attention.
	LevelWarning

	// LevelInfo is for general informational messages about application flow.
	// These provide context about what the application is doing.
	LevelInfo

	// LevelDebug is for detailed debugging information.
	// These are useful for diagnosing problems during development.
	LevelDebug

	// LevelTrace is for very detailed tracing information.
	// These provide the most verbose output for deep debugging.
	LevelTrace

	// LevelDump is for dumping objects to console for regressive tests.
	// This level is specifically designed for object inspection and testing.
	LevelDump

	// LevelLua is specifically for output from Lua scripts.
	// This level bypasses normal level filtering and is always shown.
	LevelLua

	// LevelPrefix is used internally for styling user prefixes.
	// This is not a logging level but a style identifier.
	LevelPrefix
)

// LevelStyle defines the visual styling configuration for a log level.
// It controls how log messages appear in the terminal with colors and formatting.
type LevelStyle struct {
	// Tag is the text label displayed for this log level (e.g., "ERROR", "INFO")
	Tag string

	// TagColor is the ANSI color code for the tag text
	TagColor string

	// TagBackgroundColor is the ANSI color code for the tag background
	TagBackgroundColor string

	// MessageColor is the ANSI color code for the message text
	MessageColor string

	// MessageBackgroundColor is the ANSI color code for the message background
	MessageBackgroundColor string
}

// levelStyles maps LogLevel to its display style
var levelStyles = map[LogLevel]LevelStyle{
	LevelError: {
		Tag:                    "ERROR",
		TagColor:               BIRed,    // Bold Intense Red
		TagBackgroundColor:     On_White, // White background
		MessageColor:           White,    // Bold White text
		MessageBackgroundColor: On_IRed,  // Intense Red background
	},
	LevelWarning: {
		Tag:                    "WARNING",
		TagColor:               BIOrange,   // Bold Intense Orange
		TagBackgroundColor:     On_White,   // White background
		MessageColor:           White,      // Bold White text
		MessageBackgroundColor: On_IOrange, // Intense Orange background
	},
	LevelInfo: {
		Tag:      "INFO",
		TagColor: BGreen, // Bold Green
	},
	LevelDebug: {
		Tag:      "DEBUG",
		TagColor: BCyan, // Bold Cyan
	},
	LevelTrace: {
		Tag:      "TRACE",
		TagColor: BPurple, // Bold Purple
	},
	LevelDump: {
		Tag:                "DUMP",
		TagColor:           BIMagenta, // Bold Intense Magenta
		TagBackgroundColor: On_White,  // White background
		MessageColor:       IMagenta,  // White text
	},
	LevelLua: {
		Tag:      "LUA",
		TagColor: BBlue, // Bold Blue
	},
	LevelPrefix: {
		Tag:      "PREFIX", // Used for coloring the user prefix
		TagColor: BIGray,   // Bold Gray
	},
}

// Logger is a thread-safe, feature-rich logger that supports multiple output destinations,
// structured logging, colored output, and various log levels. It can be used both as a
// standalone logger or as part of a structured logging system with context fields.
type Logger struct {
	// mu protects all fields from concurrent access
	mu sync.Mutex

	// out is the list of output destinations for log messages
	out []io.Writer

	// currentLevel determines which log messages are actually written
	currentLevel LogLevel

	// prefix is the standard Go log prefix (timestamp, file, etc.)
	prefix string

	// userPrefix is a custom user-defined prefix for log messages
	userPrefix string

	// flag controls which standard log information is included (timestamp, file, line, etc.)
	flag int

	// useColors determines whether ANSI color codes are included in output
	useColors bool

	// callerOffset adjusts the stack depth for caller information
	callerOffset int

	// defaultFields are key-value pairs included in all log messages from this logger
	defaultFields map[string]interface{}

	// showGoroutine determines whether goroutine ID is included in log messages
	showGoroutine bool
}

var (
	// Default is the global logger instance used by package-level functions.
	// It is automatically initialized when first used if not explicitly set.
	Default *Logger

	// defaultLogLevel is the default log level used when initializing the logger
	defaultLogLevel = LevelInfo

	// initMutex protects the initialization of the Default logger from race conditions
	initMutex sync.Mutex
)

// ParseLevel converts a string representation of a log level to the corresponding LogLevel.
// It accepts case-insensitive strings like "error", "warning", "info", "debug", "trace", "dump", and "lua".
// If the string is not recognized, it returns the default log level (LevelInfo).
func ParseLevel(levelStr string) LogLevel {
	switch strings.ToUpper(levelStr) {
	case "ERROR":
		return LevelError
	case "WARNING", "WARN":
		return LevelWarning
	case "INFO":
		return LevelInfo
	case "DEBUG":
		return LevelDebug
	case "TRACE":
		return LevelTrace
	case "DUMP":
		return LevelDump
	case "LUA":
		return LevelLua
	default:
		return defaultLogLevel
	}
}

// String returns the string representation of the log level.
// It returns the tag name (e.g., "ERROR", "INFO") or a formatted representation for unknown levels.
func (l LogLevel) String() string {
	if name, ok := levelStyles[l]; ok {
		return name.Tag
	}
	return fmt.Sprintf("Level(%d)", l)
}

// New creates a new Logger instance with the specified output destination, prefix, and flags.
// The logger is initialized with default settings: LevelInfo log level, colors enabled,
// goroutine tracking enabled, and no default fields.
func New(out io.Writer, prefix string, flag int) *Logger {
	return &Logger{
		out:           []io.Writer{out},
		currentLevel:  defaultLogLevel,
		prefix:        prefix,
		userPrefix:    "",
		flag:          flag,
		useColors:     true,
		callerOffset:  0,
		defaultFields: make(map[string]interface{}),
		showGoroutine: true,
	}
}

// InitFlag initializes the default logger using the loglevel flag value.
// This library defines a "loglevel" command-line flag that accepts values like "error", "warning", "info", "debug", "trace", "dump", or "lua".
// This function should be called after flag.Parse() to use command-line log level configuration.
// Example usage:
//
//	flag.Parse()
//	cylogger.InitFlag()
//	// Now the logger level is set based on the -loglevel flag
func InitFlag() {
	level := ParseLevel(*loglevel)
	Init(level)
}

// Init initializes the Default logger with the specified log level.
// If the Default logger is already initialized, it only updates the log level.
// This function is thread-safe and can be called multiple times.
func Init(level LogLevel) {
	initMutex.Lock()
	defer initMutex.Unlock()

	if Default == nil {
		Default = New(os.Stdout, "", log.Lmicroseconds|log.Lshortfile)
	}
	Default.SetLevel(level)
}

// SetLevel sets the current log level for the logger.
// Only messages with a level less than or equal to this level will be logged.
// This method is thread-safe.
func (l *Logger) SetLevel(level LogLevel) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.currentLevel = level
}

// GetLevel returns the current log level of the logger.
// This method is thread-safe.
func (l *Logger) GetLevel() LogLevel {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.currentLevel
}

// SetCallerOffset sets the caller offset for correct file and line reporting.
// This is useful when the logger is wrapped in helper functions to ensure
// the correct caller information is displayed.
func (l *Logger) SetCallerOffset(offset int) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.callerOffset = offset
}

// SetShowGoroutine sets whether to include goroutine ID in log messages.
// This is useful for debugging concurrent applications where you need to track
// which goroutine generated each log message.
func (l *Logger) SetShowGoroutine(show bool) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.showGoroutine = show
}

// ShowGoroutine returns whether goroutine ID is included in log messages.
// This method is thread-safe.
func (l *Logger) ShowGoroutine() bool {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.showGoroutine
}

// WithField creates a new logger instance with an additional field in its context.
// The field will be included in all log messages from the returned logger, appearing as key=value pairs appended to the message.
// This is useful for structured logging where you want to add context to a group of log messages.
// Example:
//
//	logger := cylogger.WithField("user", "john")
//	logger.Info("User logged in")  // Output: "User logged in user=john"
//	logger.Error("Login failed")    // Output: "Login failed user=john"
//
// This is particularly useful for scoped logging in functions or loops where you want to track context
// without continuously logging an ID or identifier.
func (l *Logger) WithField(key string, value interface{}) *Logger {
	newLogger := &Logger{
		out:           append([]io.Writer(nil), l.out...),
		currentLevel:  l.currentLevel,
		prefix:        l.prefix,
		userPrefix:    l.userPrefix,
		flag:          l.flag,
		useColors:     l.useColors,
		callerOffset:  l.callerOffset,
		defaultFields: make(map[string]interface{}),
		showGoroutine: l.showGoroutine,
	}

	// Copy existing fields
	for k, v := range l.defaultFields {
		newLogger.defaultFields[k] = v
	}

	// Add new field
	newLogger.defaultFields[key] = value
	return newLogger
}

// WithFields creates a new logger instance with multiple additional fields in its context.
// All fields will be included in all log messages from the returned logger, appearing as key=value pairs appended to the message.
// This is useful for structured logging where you want to add multiple context fields.
// Example:
//
//	fields := map[string]interface{}{"user": "john", "role": "admin", "session": "abc123"}
//	logger := cylogger.WithFields(fields)
//	logger.Info("Processing request")  // Output: "Processing request user=john role=admin session=abc123"
//
// This is particularly useful for scoped logging where you need to track multiple pieces of context
// without repeatedly logging them in each message.
func (l *Logger) WithFields(fields map[string]interface{}) *Logger {
	newLogger := &Logger{
		out:           append([]io.Writer(nil), l.out...),
		currentLevel:  l.currentLevel,
		prefix:        l.prefix,
		userPrefix:    l.userPrefix,
		flag:          l.flag,
		useColors:     l.useColors,
		callerOffset:  l.callerOffset,
		defaultFields: make(map[string]interface{}),
		showGoroutine: l.showGoroutine,
	}

	// Copy existing fields
	for k, v := range l.defaultFields {
		newLogger.defaultFields[k] = v
	}

	// Add new fields
	for k, v := range fields {
		newLogger.defaultFields[k] = v
	}
	return newLogger
}

// WithPrefix creates a new logger instance with an additional user prefix.
// The prefix will be displayed in all log messages from the returned logger, appearing as [prefix] before the message.
// This is useful for adding context or module identification to log messages.
// Example:
//
//	logger := cylogger.WithPrefix("AUTH")
//	logger.Info("User authenticated")  // Output: "[AUTH] User authenticated"
//	logger.Error("Login failed")     // Output: "[AUTH] Login failed"
//
// This is particularly useful for scoped logging in functions, loops, or modules where you want to know
// what the log line refers to without continuously logging an ID or identifier.
// Unlike WithField which appends fields to the end, WithPrefix prepends the prefix to the beginning.
func (l *Logger) WithPrefix(prefix string) *Logger {
	if Default == nil {
		Init(defaultLogLevel)
	}
	if l == nil {
		l = Default
	}
	newLogger := &Logger{
		out:           append([]io.Writer(nil), l.out...),
		currentLevel:  l.currentLevel,
		prefix:        l.prefix,
		userPrefix:    strings.TrimSpace(l.userPrefix + " " + prefix),
		flag:          l.flag,
		useColors:     l.useColors,
		callerOffset:  l.callerOffset,
		defaultFields: make(map[string]interface{}),
		showGoroutine: l.showGoroutine,
	}

	// Copy existing fields
	for k, v := range l.defaultFields {
		newLogger.defaultFields[k] = v
	}
	return newLogger
}

// ToFile creates a new logger instance that writes to both the original outputs and a file.
// The file is opened in append mode and will be created if it doesn't exist.
// This is useful for logging to both console and file simultaneously.
// Example:
//
//	logger := cylogger.New(os.Stdout, "", log.LstdFlags)
//	fileLogger := logger.ToFile("app.log")
//	fileLogger.Info("This will appear in both console and app.log")
//
// The file is opened with os.O_CREATE|os.O_WRONLY|os.O_APPEND flags, so it will be created if it doesn't exist
// and new log entries will be appended to the end of the file.
func (l *Logger) ToFile(filename string) *Logger {
	file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		log.Fatal(err)
	}
	if Default == nil {
		Init(defaultLogLevel)
	}
	if l == nil {
		l = Default
	}
	newLogger := &Logger{
		out:           append([]io.Writer(nil), l.out...),
		currentLevel:  l.currentLevel,
		prefix:        l.prefix,
		userPrefix:    l.userPrefix,
		flag:          l.flag,
		useColors:     l.useColors,
		callerOffset:  l.callerOffset,
		defaultFields: make(map[string]interface{}),
		showGoroutine: l.showGoroutine,
	}
	// Copy existing fields
	for k, v := range l.defaultFields {
		newLogger.defaultFields[k] = v
	}
	// Append the new file writer
	newLogger.out = append(newLogger.out, file)
	return newLogger
}

// GetGoroutineID extracts the current goroutine ID from the runtime stack.
// This is used internally by the logger to include goroutine information in log messages.
func GetGoroutineID() string {
	buf := make([]byte, 64)
	n := runtime.Stack(buf, false)
	// Format of first line is "goroutine N [state]:"
	// We only need the N part
	buf = buf[:n]
	idField := bytes.Fields(bytes.Split(buf, []byte{':'})[0])[1]
	return string(idField)
}

// formatMessage formats a log message with level, time, file, and line information
func (l *Logger) formatMessage(level LogLevel, format string, args ...interface{}) string {
	var msg string
	if len(args) > 0 {
		msg = fmt.Sprintf(format, args...)
	} else {
		msg = format
	}

	// Format default fields if any
	var fields string
	if len(l.defaultFields) > 0 {
		var pairs []string
		for k, v := range l.defaultFields {
			pairs = append(pairs, fmt.Sprintf("%s=%v", k, v))
		}
		fields = " " + strings.Join(pairs, " ")
	}

	var tagFgColor, tagBgColor, messageBgColor string
	useSpecialFormatting := false // Flag for levels with custom message background/foreground
	if l.useColors {
		// Check if a message background color is defined for this level style
		if levelStyles[level].MessageBackgroundColor != "" {
			useSpecialFormatting = true
			// Retrieve all style components from the map
			tagFgColor = levelStyles[level].TagColor // Assign directly
			tagBgColor = levelStyles[level].TagBackgroundColor
			// messageFgColor = levelStyles[level].MessageColor
			messageBgColor = levelStyles[level].MessageBackgroundColor
		} else {
			// For other levels (INFO, DEBUG, etc.), only TagColor is guaranteed
			tagFgColor = levelStyles[level].TagColor // Use the defined tag color
			// tagBgColor, messageFgColor, messageBgColor remain empty (use terminal defaults)
		}
	}

	var caller string
	if l.flag&log.Lshortfile != 0 || l.flag&log.Llongfile != 0 {
		var file string
		var line int
		var ok bool
		// Start at a reasonable depth and scan up to 10 frames
		for depth := 4; depth < 15; depth++ {
			_, file, line, ok = runtime.Caller(depth)
			if !ok {
				break
			}
			// Check if the caller is within this logger package itself
			if !strings.Contains(file, "main.go") && !strings.Contains(file, "colors.go") {
				break
			}
		}
		if !ok {
			file = "???"
			line = 0
		}
		if l.flag&log.Lshortfile != 0 {
			file = filepath.Base(file)
		}
		// Caller string - no background color applied here
		caller = fmt.Sprintf("%-25s ", file+":"+strconv.Itoa(line))
	}

	// Format the timestamp with fixed width - no background color applied here
	var timeStr string
	if l.flag&(log.Ldate|log.Ltime|log.Lmicroseconds) != 0 {
		t := time.Now()
		if l.flag&log.Ldate != 0 {
			timeStr += fmt.Sprintf("%04d/%02d/%02d ", t.Year(), t.Month(), t.Day())
		}
		if l.flag&(log.Ltime|log.Lmicroseconds) != 0 {
			timeStr += fmt.Sprintf("%02d:%02d:%02d", t.Hour(), t.Minute(), t.Second())
			if l.flag&log.Lmicroseconds != 0 {
				timeStr += fmt.Sprintf(".%06d", t.Nanosecond()/1000)
			}
		}
		timeStr = fmt.Sprintf("%-15s ", timeStr)
	}

	// Add goroutine ID if enabled, with fixed width - no background color applied here
	var goroutineStr string
	if l.showGoroutine {
		goroutineID := GetGoroutineID()
		goroutineStr = fmt.Sprintf("[g:%-4s] ", goroutineID)
	}

	// --- Level Tag Formatting and Padding ---
	levelStr := levelStyles[level].Tag
	visibleTagContent := fmt.Sprintf("[%s]", levelStr)
	visibleTagLen := len(visibleTagContent)
	paddingWidth := 10 // Target width for the level column (tag + padding)
	numSpaces := paddingWidth - visibleTagLen
	if numSpaces < 0 {
		numSpaces = 1 // Ensure at least one space
	}
	padding := strings.Repeat(" ", numSpaces)

	var levelTagFormatted string
	if useSpecialFormatting {
		// ERROR/WARNING: Tag has specific background and foreground
		levelTagFormatted = fmt.Sprintf("%s%s%s%s", tagBgColor, tagFgColor, visibleTagContent, Reset)
	} else {
		// Other levels: Tag has standard foreground color only
		levelTagFormatted = fmt.Sprintf("%s%s%s", tagFgColor, visibleTagContent, Reset)
	}
	levelColumn := levelTagFormatted + padding // Combine formatted tag and padding

	// --- User Prefix Formatting (part of message content for coloring purposes) ---
	userPrefixStr := ""
	if l.userPrefix != "" {
		// Format the string part here, colors applied later if needed
		userPrefixStr = fmt.Sprintf("[%s] ", l.userPrefix)
	}

	// --- Message Content ---
	messageContent := fmt.Sprintf("%s%s", msg, fields)

	// --- Assemble Final String ---
	var finalMsg strings.Builder

	// Part 1: Timestamp, Caller, Goroutine ID (always default colors)
	finalMsg.WriteString(l.prefix)
	finalMsg.WriteString(timeStr)
	finalMsg.WriteString(caller)
	finalMsg.WriteString(goroutineStr)

	// Part 2: Level Column (already formatted with tag colors and padding)
	finalMsg.WriteString(levelColumn)

	// Part 3: User Prefix + Message Content (apply special formatting if needed)
	if useSpecialFormatting {
		// ERROR/WARNING: Apply message background and foreground to User Prefix + Message
		finalMsg.WriteString(messageBgColor)
		// finalMsg.WriteString(messageFgColor) // This doesn't work...? For some reason?
		finalMsg.WriteString(userPrefixStr) // Write user prefix inside the colored block
		finalMsg.WriteString(messageContent)
		finalMsg.WriteString(Reset)
	} else {
		// Other levels: User Prefix and Message content use default colors
		// Apply specific color to user prefix if it exists
		if l.userPrefix != "" {
			prefixColor := levelStyles[LevelPrefix].TagColor
			finalMsg.WriteString(fmt.Sprintf("%s%s%s", prefixColor, userPrefixStr, Reset))
		} // No else needed, if userPrefix is empty, userPrefixStr is "" anyway
		finalMsg.WriteString(messageContent) // Append message with default colors
	}

	return finalMsg.String()
}

// log logs a message at the specified level
func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
	// Always show LUA level logs regardless of the current log level
	if level != LevelLua && level > l.currentLevel {
		return
	}

	l.mu.Lock()
	defer l.mu.Unlock()

	// Get formatted message with potential background color
	msg := l.formatMessage(level, format, args...)
	for _, w := range l.out {
		fmt.Fprintln(w, msg)
	}
}

// Error logs an error message at LevelError.
// Error messages are always displayed regardless of the current log level.
func (l *Logger) Error(format string, args ...interface{}) {
	l.log(LevelError, format, args...)
}

// Warning logs a warning message at LevelWarning.
// Warning messages indicate potential issues that should be noted.
func (l *Logger) Warning(format string, args ...interface{}) {
	l.log(LevelWarning, format, args...)
}

// Info logs an informational message at LevelInfo.
// Info messages provide general information about application flow.
func (l *Logger) Info(format string, args ...interface{}) {
	l.log(LevelInfo, format, args...)
}

// Debug logs a debug message at LevelDebug.
// Debug messages provide detailed information useful for diagnosing problems.
func (l *Logger) Debug(format string, args ...interface{}) {
	l.log(LevelDebug, format, args...)
}

// Trace logs a trace message at LevelTrace.
// Trace messages provide the most detailed information for deep debugging.
func (l *Logger) Trace(format string, args ...interface{}) {
	l.log(LevelTrace, format, args...)
}

// Dump logs objects using valast for regressive tests at LevelDump.
// This is useful for debugging and testing where you need to inspect object state.
// The objects are formatted using valast for readable output.
// Example:
//
//	type User struct { Name string; Age int }
//	user := User{Name: "John", Age: 30}
//	logger.Dump("User data", user)
//	// Output: "User data:\nUser{Name: \"John\", Age: 30}"
//
// This is particularly useful for regressive testing where you need to capture
// the exact state of objects for comparison or debugging purposes.
func (l *Logger) Dump(message string, objects ...interface{}) {
	if len(objects) == 0 {
		l.log(LevelDump, message)
		return
	}

	var dumpContent strings.Builder
	dumpContent.WriteString(message)
	dumpContent.WriteString(":\n")

	for i, obj := range objects {
		if i > 0 {
			dumpContent.WriteString("\n")
		}
		dumpContent.WriteString(valast.String(obj))
	}

	l.log(LevelDump, dumpContent.String())
}

// Lua logs a Lua message at LevelLua.
// Lua messages are always displayed regardless of the current log level.
// This is specifically designed for output from Lua scripts.
func (l *Logger) Lua(format string, args ...interface{}) {
	l.log(LevelLua, format, args...)
}

// Global log functions that use DefaultLogger

// Error logs an error message using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Error(format string, args ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Error(format, args...)
}

// Warning logs a warning message using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Warning(format string, args ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Warning(format, args...)
}

// Info logs an informational message using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Info(format string, args ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Info(format, args...)
}

// Debug logs a debug message using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Debug(format string, args ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Debug(format, args...)
}

// Trace logs a trace message using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Trace(format string, args ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Trace(format, args...)
}

// Dump logs objects using valast for regressive tests using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Dump(message string, objects ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Dump(message, objects...)
}

// Lua logs a Lua message using the default logger.
// This is a convenience function that uses the global Default logger instance.
func Lua(format string, args ...interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.Lua(format, args...)
}

// LogPanic logs a panic error and its stack trace using the default logger.
// This is useful for logging panics that have been recovered elsewhere.
// The function logs the panic value and full stack trace.
func LogPanic(r interface{}) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	stack := make([]byte, 4096)
	n := runtime.Stack(stack, false)
	Default.Error("PANIC: %v\n%s", r, stack[:n])
}

// SetLevel sets the log level for the default logger.
// This is a convenience function that uses the global Default logger instance.
func SetLevel(level LogLevel) {
	if Default == nil {
		Init(level)
		return
	}
	Default.SetLevel(level)
}

// GetLevel gets the log level for the default logger.
// This is a convenience function that uses the global Default logger instance.
func GetLevel() LogLevel {
	if Default == nil {
		Init(defaultLogLevel)
	}
	return Default.GetLevel()
}

// WithField returns a new logger with the field added to the default logger's context.
// This is a convenience function that uses the global Default logger instance.
func WithField(key string, value interface{}) *Logger {
	if Default == nil {
		Init(defaultLogLevel)
	}
	return Default.WithField(key, value)
}

// WithFields returns a new logger with the fields added to the default logger's context.
// This is a convenience function that uses the global Default logger instance.
func WithFields(fields map[string]interface{}) *Logger {
	if Default == nil {
		Init(defaultLogLevel)
	}
	return Default.WithFields(fields)
}

// SetShowGoroutine enables or disables goroutine ID display in the default logger.
// This is a convenience function that uses the global Default logger instance.
func SetShowGoroutine(show bool) {
	if Default == nil {
		Init(defaultLogLevel)
	}
	Default.SetShowGoroutine(show)
}

// ShowGoroutine returns whether goroutine ID is included in default logger's messages.
// This is a convenience function that uses the global Default logger instance.
func ShowGoroutine() bool {
	if Default == nil {
		Init(defaultLogLevel)
	}
	return Default.ShowGoroutine()
}

// NoStdout creates a new logger instance that excludes stdout from its output destinations.
// This is useful when you want to log only to files or other destinations, not to the console.
// The original logger's stdout output is filtered out while keeping all other output destinations.
func (l *Logger) NoStdout() *Logger {
	if Default == nil {
		Init(defaultLogLevel)
	}
	if l == nil {
		l = Default
	}
	newLogger := &Logger{
		out:           nil,
		currentLevel:  l.currentLevel,
		prefix:        l.prefix,
		userPrefix:    l.userPrefix,
		flag:          l.flag,
		useColors:     l.useColors,
		callerOffset:  l.callerOffset,
		defaultFields: make(map[string]interface{}),
		showGoroutine: l.showGoroutine,
	}
	// Copy existing fields
	for k, v := range l.defaultFields {
		newLogger.defaultFields[k] = v
	}
	// Keep all writers except stdout
	for _, w := range l.out {
		if w == os.Stdout {
			continue
		}
		newLogger.out = append(newLogger.out, w)
	}
	return newLogger
}

func main() {
	Init(LevelDebug)

	// Test basic logging
	Debug("This is a debug message")
	Info("This is an info message")
	Warning("This is a warning message")
	Error("This is an error message")

	// Test logging with fields
	logger := WithField("user", "testuser")
	logger.Info("User logged in")

	// Test logging with multiple fields
	fields := map[string]interface{}{
		"user": "testuser",
		"role": "admin",
		"id":   12345,
	}
	WithFields(fields).Info("User details")

	// Test error logging with fields
	WithField("error", "connection failed").Error("Database error")

	logger.WithPrefix("CUSTOM").Info("This is a message with a custom prefix")

	// Test goroutine ID display
	SetShowGoroutine(true)
	Info("This message should show goroutine ID")

	// Test different log levels
	SetLevel(LevelInfo)
	Debug("This debug message should not appear")
	Info("This info message should appear")

	// Test with custom prefix
	WithField("prefix", "custom").Info("Message with custom prefix")
	Lua("This is a Lua message")

	// Test Dump functionality
	SetLevel(LevelDump) // Set level to show dump messages

	type ProjectData struct {
		Title   string
		Name    string
		Data    string
		Commits string
	}

	type Project struct {
		Id   int64
		Data *ProjectData
	}

	p := Project{
		Id: 1,
		Data: &ProjectData{
			Title:   "Test",
			Name:    "Mihai",
			Data:    "Some data",
			Commits: "Test Message",
		},
	}

	// Test single object dump
	Dump("FooBar called", p)

	// Test multiple object dump
	Dump("Multiple objects", p, fields, "string value", 42)
}