package log

import (
	"fmt"
	"runtime/debug"
)

type Logger interface {
	Info(args ...interface{})
	Infof(format string, args ...interface{})
	Infow(msg string, keysAndValues ...interface{})

	Warn(args ...interface{})
	Warnf(format string, args ...interface{})
	Warnw(msg string, keysAndValues ...interface{})

	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Errorw(msg string, keysAndValues ...interface{})

	Debug(args ...interface{})
	Debugf(format string, args ...interface{})
	Debugw(msg string, keysAndValues ...interface{})

	Panic(args ...interface{})
	Panicf(format string, args ...interface{})
	Panicw(msg string, keysAndValues ...interface{})

	Fatal(args ...interface{})
	Fatalf(format string, args ...interface{})
	Fatalw(msg string, keysAndValues ...interface{})
}

// CustomLogger 包装了一个 Logger 实例
type CustomLogger struct {
	logger Logger
	Close  func()
}

var (
	logger *CustomLogger
)

func InitCustomLogger(appName string, isDisplayToConsole bool) *CustomLogger {
	filePath := fmt.Sprintf("../logs/%s", appName)
	log, w := InitLogger(filePath, isDisplayToConsole)

	close := func() {
		log.Sync()
		close(w.entryChan)
		w.wg.Wait()
	}

	l := new(CustomLogger)
	l.logger = log
	l.Close = close
	logger = l
	return l
}

func L() *CustomLogger {
	return logger
}

// Info 记录一条信息级别的日志
func (c *CustomLogger) Info(args ...interface{}) {
	c.logger.Info(args...)
}

// Infof 格式化记录一条信息级别的日志
func (c *CustomLogger) Infof(format string, args ...interface{}) {
	c.logger.Infof(format, args...)
}

// Infoln 记录一条信息级别的日志，并在末尾添加换行符
func (c *CustomLogger) Infow(msg string, keysAndValues ...interface{}) {
	c.logger.Infow(msg, keysAndValues...)
}

// Warn 记录一条警告级别的日志
func (c *CustomLogger) Warn(args ...interface{}) {
	c.logger.Warn(args...)
}

// Warnf 格式化记录一条警告级别的日志
func (c *CustomLogger) Warnf(format string, args ...interface{}) {
	c.logger.Warnf(format, args...)
}

// Warnln 记录一条警告级别的日志，并在末尾添加换行符
func (c *CustomLogger) Warnw(msg string, keysAndValues ...interface{}) {
	c.logger.Warnw(msg, keysAndValues...)
}

// Error 记录一条错误级别的日志
func (c *CustomLogger) Error(args ...interface{}) {
	c.logger.Error(args...)
}

// Errorf 格式化记录一条错误级别的日志
func (c *CustomLogger) Errorf(format string, args ...interface{}) {
	c.logger.Errorf(format, args...)
}

// Errorln 记录一条错误级别的日志，并在末尾添加换行符
func (c *CustomLogger) Errorw(msg string, keysAndValues ...interface{}) {
	c.logger.Errorw(msg, keysAndValues...)
}

// Debug 记录一条调试级别的日志
func (c *CustomLogger) Debug(args ...interface{}) {
	c.logger.Debug(args...)
}

// Debugf 格式化记录一条调试级别的日志
func (c *CustomLogger) Debugf(format string, args ...interface{}) {
	c.logger.Debugf(format, args...)
}

// Debugln 记录一条调试级别的日志，并在末尾添加换行符
func (c *CustomLogger) Debugw(msg string, keysAndValues ...interface{}) {
	c.logger.Debugw(msg, keysAndValues...)
}

// Panic 记录一条致命级别的日志并触发 panic
func (c *CustomLogger) Panic(args ...interface{}) {
	c.logger.Error(args...)
	c.logger.Panic(string(debug.Stack()))
}

// Panicf 格式化记录一条致命级别的日志并触发 panic
func (c *CustomLogger) Panicf(format string, args ...interface{}) {
	c.logger.Errorf(format, args...)
	c.logger.Panic(string(debug.Stack()))
}

// Panicln 记录一条致命级别的日志并触发 panic，并在末尾添加换行符
func (c *CustomLogger) Panicw(msg string, keysAndValues ...interface{}) {
	c.logger.Errorw(msg, keysAndValues...)
	c.logger.Panic(string(debug.Stack()))
}

// Fatal 记录一条致命级别的日志并调用 os.Exit(1)
func (c *CustomLogger) Fatal(args ...interface{}) {
	c.logger.Error(args...)
	c.logger.Fatal(string(debug.Stack()))
}

// Fatalf 格式化记录一条致命级别的日志并调用 os.Exit(1)
func (c *CustomLogger) Fatalf(format string, args ...interface{}) {
	c.logger.Errorf(format, args...)
	c.logger.Fatal(string(debug.Stack()))
}

// Fatalln 记录一条致命级别的日志并调用 os.Exit(1)，并在末尾添加换行符
func (c *CustomLogger) Fatalw(msg string, keysAndValues ...interface{}) {
	c.logger.Errorw(msg, keysAndValues...)
	c.logger.Fatal(string(debug.Stack()))
}

// ////////////////

func Info(args ...interface{}) {
	logger.Info(args...)
}

func Infoln(args ...interface{}) {
	logger.Info(args...)
}

// Infof 格式化记录一条信息级别的日志
func Infof(format string, args ...interface{}) {
	logger.Infof(format, args...)
}

// Infow 记录一条信息级别的日志，并在末尾添加换行符
func Infow(msg string, keysAndValues ...interface{}) {
	logger.Infow(msg, keysAndValues...)
}

// Warn 记录一条警告级别的日志
func Warn(args ...interface{}) {
	logger.Warn(args...)
}

func Warnln(args ...interface{}) {
	logger.Warn(args...)
}

// Warnf 格式化记录一条警告级别的日志
func Warnf(format string, args ...interface{}) {
	logger.Warnf(format, args...)
}

// Warnln 记录一条警告级别的日志，并在末尾添加换行符
func Warnw(msg string, keysAndValues ...interface{}) {
	logger.Warnw(msg, keysAndValues...)
}

// Error 记录一条错误级别的日志
func Error(args ...interface{}) {
	logger.Error(args...)
}
func Errorln(args ...interface{}) {
	logger.Error(args...)
}

// Errorf 格式化记录一条错误级别的日志
func Errorf(format string, args ...interface{}) {
	logger.Errorf(format, args...)
}

// Errorln 记录一条错误级别的日志，并在末尾添加换行符
func Errorw(msg string, keysAndValues ...interface{}) {
	logger.Errorw(msg, keysAndValues...)
}

// Debug 记录一条调试级别的日志
func Debug(args ...interface{}) {
	logger.Debug(args...)
}

func Debugln(args ...interface{}) {
	logger.Debug(args...)
}

// Debugf 格式化记录一条调试级别的日志
func Debugf(format string, args ...interface{}) {
	logger.Debugf(format, args...)
}

// Debugln 记录一条调试级别的日志，并在末尾添加换行符
func Debugw(msg string, keysAndValues ...interface{}) {
	logger.Debugw(msg, keysAndValues...)
}

// Panic 记录一条致命级别的日志并触发 panic
func Panic(args ...interface{}) {
	logger.Panic(args...)
}

func Panicln(args ...interface{}) {
	logger.Panic(args...)
}

// Panicf 格式化记录一条致命级别的日志并触发 panic
func Panicf(format string, args ...interface{}) {
	logger.Panicf(format, args...)
}

// Panicln 记录一条致命级别的日志并触发 panic，并在末尾添加换行符
func Panicw(msg string, keysAndValues ...interface{}) {
	logger.Panicw(msg, keysAndValues...)
}

// Fatal 记录一条致命级别的日志并调用 os.Exit(1)
func Fatal(args ...interface{}) {
	logger.Fatal(args...)
}

func Fatalln(args ...interface{}) {
	logger.Fatal(args...)
}

// Fatalf 格式化记录一条致命级别的日志并调用 os.Exit(1)
func Fatalf(format string, args ...interface{}) {
	logger.Fatalf(format, args...)
}

// Fatalln 记录一条致命级别的日志并调用 os.Exit(1)，并在末尾添加换行符
func Fatalw(msg string, keysAndValues ...interface{}) {
	logger.Fatalw(msg, keysAndValues...)
}