package logger

import (
	"fmt"
	"io"
	"log"
	"os"
	"sync"
)

// Level represents the severity level of a log message
type Level int

const (
	// DEBUG level for detailed troubleshooting information
	DEBUG Level = iota
	// INFO level for general operational information
	INFO
	// WARN level for warning conditions
	WARN
	// ERROR level for error conditions
	ERROR
	// FATAL level for critical errors that cause the program to exit
	FATAL
)

var levelNames = map[Level]string{
	DEBUG: "DEBUG",
	INFO:  "INFO",
	WARN:  "WARN",
	ERROR: "ERROR",
	FATAL: "FATAL",
}

// String returns the string representation of the log level
func (l Level) String() string {
	if name, ok := levelNames[l]; ok {
		return name
	}
	return fmt.Sprintf("LEVEL(%d)", l)
}

// Logger is the interface that defines the logging methods
type Logger interface {
	Debug(v ...interface{})
	Debugf(format string, v ...interface{})
	Info(v ...interface{})
	Infof(format string, v ...interface{})
	Warn(v ...interface{})
	Warnf(format string, v ...interface{})
	Error(v ...interface{})
	Errorf(format string, v ...interface{})
	Fatal(v ...interface{})
	Fatalf(format string, v ...interface{})
	SetLevel(level Level)
	GetLevel() Level
	SetOutput(w io.Writer)
}

// DefaultLogger is the standard implementation of the Logger interface
type DefaultLogger struct {
	mu     sync.Mutex
	logger *log.Logger
	level  Level
}

// NewDefaultLogger creates a new DefaultLogger with the specified level
func NewDefaultLogger(level Level) *DefaultLogger {
	return &DefaultLogger{
		logger: log.New(os.Stdout, "", log.LstdFlags),
		level:  level,
	}
}

// SetOutput sets the output destination for the logger
func (l *DefaultLogger) SetOutput(w io.Writer) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.logger.SetOutput(w)
}

// SetLevel sets the minimum log level that will be output
func (l *DefaultLogger) SetLevel(level Level) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.level = level
}

// GetLevel returns the current log level
func (l *DefaultLogger) GetLevel() Level {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.level
}

// log logs a message at the specified level
func (l *DefaultLogger) log(level Level, v ...interface{}) {
	if level < l.level {
		return
	}
	l.mu.Lock()
	defer l.mu.Unlock()
	l.logger.Print(fmt.Sprintf("[%s] ", level), fmt.Sprint(v...))
}

// logf logs a formatted message at the specified level
func (l *DefaultLogger) logf(level Level, format string, v ...interface{}) {
	if level < l.level {
		return
	}
	l.mu.Lock()
	defer l.mu.Unlock()
	l.logger.Print(fmt.Sprintf("[%s] %s", level, fmt.Sprintf(format, v...)))
}

// Debug logs a message at DEBUG level
func (l *DefaultLogger) Debug(v ...interface{}) {
	l.log(DEBUG, v...)
}

// Debugf logs a formatted message at DEBUG level
func (l *DefaultLogger) Debugf(format string, v ...interface{}) {
	l.logf(DEBUG, format, v...)
}

// Info logs a message at INFO level
func (l *DefaultLogger) Info(v ...interface{}) {
	l.log(INFO, v...)
}

// Infof logs a formatted message at INFO level
func (l *DefaultLogger) Infof(format string, v ...interface{}) {
	l.logf(INFO, format, v...)
}

// Warn logs a message at WARN level
func (l *DefaultLogger) Warn(v ...interface{}) {
	l.log(WARN, v...)
}

// Warnf logs a formatted message at WARN level
func (l *DefaultLogger) Warnf(format string, v ...interface{}) {
	l.logf(WARN, format, v...)
}

// Error logs a message at ERROR level
func (l *DefaultLogger) Error(v ...interface{}) {
	l.log(ERROR, v...)
}

// Errorf logs a formatted message at ERROR level
func (l *DefaultLogger) Errorf(format string, v ...interface{}) {
	l.logf(ERROR, format, v...)
}

// Fatal logs a message at FATAL level and then exits the program
func (l *DefaultLogger) Fatal(v ...interface{}) {
	l.log(FATAL, v...)
	os.Exit(1)
}

// Fatalf logs a formatted message at FATAL level and then exits the program
func (l *DefaultLogger) Fatalf(format string, v ...interface{}) {
	l.logf(FATAL, format, v...)
	os.Exit(1)
}

// Global logger instance
var (
	defaultLogger Logger = NewDefaultLogger(INFO)
)

// SetDefaultLogger sets the global default logger
func SetDefaultLogger(logger Logger) {
	defaultLogger = logger
}

// GetDefaultLogger returns the global default logger
func GetDefaultLogger() Logger {
	return defaultLogger
}

// SetLevel sets the log level for the default logger
func SetLevel(level Level) {
	defaultLogger.SetLevel(level)
}

// Debug logs a message at DEBUG level using the default logger
func Debug(v ...interface{}) {
	defaultLogger.Debug(v...)
}

// Debugf logs a formatted message at DEBUG level using the default logger
func Debugf(format string, v ...interface{}) {
	defaultLogger.Debugf(format, v...)
}

// Info logs a message at INFO level using the default logger
func Info(v ...interface{}) {
	defaultLogger.Info(v...)
}

// Infof logs a formatted message at INFO level using the default logger
func Infof(format string, v ...interface{}) {
	defaultLogger.Infof(format, v...)
}

// Warn logs a message at WARN level using the default logger
func Warn(v ...interface{}) {
	defaultLogger.Warn(v...)
}

// Warnf logs a formatted message at WARN level using the default logger
func Warnf(format string, v ...interface{}) {
	defaultLogger.Warnf(format, v...)
}

// Error logs a message at ERROR level using the default logger
func Error(v ...interface{}) {
	defaultLogger.Error(v...)
}

// Errorf logs a formatted message at ERROR level using the default logger
func Errorf(format string, v ...interface{}) {
	defaultLogger.Errorf(format, v...)
}

// Fatal logs a message at FATAL level using the default logger and then exits
func Fatal(v ...interface{}) {
	defaultLogger.Fatal(v...)
}

// Fatalf logs a formatted message at FATAL level using the default logger and then exits
func Fatalf(format string, v ...interface{}) {
	defaultLogger.Fatalf(format, v...)
}