package logger

import (
	"fmt"
	"os"
)

type Level int8

const (
	// TraceLevel 指定比“调试”更细粒度的信息性事件。
	TraceLevel Level = iota - 2
	// DebugLevel 通常仅在调试时启用。非常详细的日志记录。
	DebugLevel
	// InfoLevel 默认的日志记录优先级
	// 应用程序内部发生的事情的一般操作记录。
	InfoLevel
	// WarnLevel 值得关注的非关键记录.
	WarnLevel
	// ErrorLevel 明确应注意的错误。
	ErrorLevel
	// FatalLevel 记录，然后调用 `logger.Exit(1)`。 最高级别的严重性。
	FatalLevel
)

func (l Level) String() string {
	switch l {
	case TraceLevel:
		return "trace"
	case DebugLevel:
		return "debug"
	case InfoLevel:
		return "info"
	case WarnLevel:
		return "warn"
	case ErrorLevel:
		return "error"
	case FatalLevel:
		return "fatal"
	}
	return ""
}

// LevelForGorm 转换成gorm日志级别
func (l Level) LevelForGorm() int {
	switch l {
	case FatalLevel, ErrorLevel:
		return 2
	case WarnLevel:
		return 3
	case InfoLevel, DebugLevel, TraceLevel:
		return 4
	default:
		return 1
	}
}

// Enabled returns true if the given level is at or above this level.
func (l Level) Enabled(lvl Level) bool {
	return lvl >= l
}

// GetLevel 将级别字符串转换为记录器级别值。
// 如果输入字符串与已知值不匹配，则返回错误。
func GetLevel(levelStr string) (Level, error) {
	switch levelStr {
	case TraceLevel.String():
		return TraceLevel, nil
	case DebugLevel.String():
		return DebugLevel, nil
	case InfoLevel.String():
		return InfoLevel, nil
	case WarnLevel.String():
		return WarnLevel, nil
	case ErrorLevel.String():
		return ErrorLevel, nil
	case FatalLevel.String():
		return FatalLevel, nil
	}
	return InfoLevel, fmt.Errorf("Unknown Level String: '%s', defaulting to InfoLevel", levelStr)
}

func Info(args ...interface{}) {
	if len(args) > 1 {
		Infof(args[0].(string), args[1:])
	} else {
		DefaultLogger.Log(InfoLevel, args...)
	}
}

func Infof(template string, args ...interface{}) {
	DefaultLogger.Logf(InfoLevel, template, args...)
}

func Trace(args ...interface{}) {
	if len(args) > 1 {
		Infof(args[0].(string), args[1:])
	} else {
		DefaultLogger.Log(TraceLevel, args...)
	}
}

func Tracef(template string, args ...interface{}) {
	DefaultLogger.Logf(TraceLevel, template, args...)
}

func Debug(args ...interface{}) {
	DefaultLogger.Log(DebugLevel, args...)
}

func Debugf(template string, args ...interface{}) {
	DefaultLogger.Logf(DebugLevel, template, args...)
}

func Warn(args ...interface{}) {
	if len(args) > 1 {
		Debugf(args[0].(string), args[1:])
	} else {
		DefaultLogger.Log(WarnLevel, args...)
	}
}

func Warnf(template string, args ...interface{}) {
	DefaultLogger.Logf(WarnLevel, template, args...)
}

func Error(args ...interface{}) {
	if len(args) > 1 {
		Debugf(args[0].(string), args[1:])
	} else {
		DefaultLogger.Log(ErrorLevel, args...)
	}
}

func Errorf(template string, args ...interface{}) {
	DefaultLogger.Logf(ErrorLevel, template, args...)
}

func Fatal(args ...interface{}) {
	if len(args) > 1 {
		Debugf(args[0].(string), args[1:])
	} else {
		DefaultLogger.Log(FatalLevel, args...)
	}
	os.Exit(1)
}

func Fatalf(template string, args ...interface{}) {
	DefaultLogger.Logf(FatalLevel, template, args...)
	os.Exit(1)
}

// V 如果给定级别等于或低于当前记录器级别，则返回true
func V(lvl Level, log Logger) bool {
	l := DefaultLogger
	if log != nil {
		l = log
	}
	return l.Options().Level <= lvl
}