package logger2

import (
	cfg "MeterService/core/config"
	"io"
	"log"
	"time"

	rotatelogs "github.com/lestrrat-go/file-rotatelogs"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

var Logger *zap.Logger

func InitLogger() {
	config := zapcore.EncoderConfig{
		TimeKey:    "ts",
		LevelKey:   "level",
		MessageKey: "msg",
		//CallerKey:   "file",
		EncodeLevel: zapcore.CapitalLevelEncoder,
		EncodeTime: func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
			enc.AppendString(t.Format("2006-01-02 15:04:05"))
		},
		EncodeDuration: func(duration time.Duration, encoder zapcore.PrimitiveArrayEncoder) {
			encoder.AppendInt64(int64(duration) / 100000000) // nano -> milli
		},
		EncodeCaller: zapcore.ShortCallerEncoder,
	}
	encoder := zapcore.NewConsoleEncoder(config)
	if cfg.C.Logger.LogType == "json" {
		encoder = zapcore.NewJSONEncoder(config)
	}
	fileFormat, saveType, logLevelStr := "%Y%m%d", "one", "info"
	if cfg.C.Logger.FileFormat != "" {
		fileFormat = cfg.C.Logger.FileFormat
	}
	if cfg.C.Logger.Level != "" {
		logLevelStr = cfg.C.Logger.Level
	}
	if cfg.C.Logger.FileType != "" {
		saveType = cfg.C.Logger.FileType
	}
	logLevel := zap.DebugLevel
	switch logLevelStr {
	case "debug":
		logLevel = zap.DebugLevel
	case "info":
		logLevel = zap.InfoLevel
	case "error":
		logLevel = zap.ErrorLevel
	}

	switch saveType {
	case "level":
		Logger = getLevelLogger(encoder, logLevel, fileFormat)
	default:
		Logger = getOneLogger(encoder, logLevel, fileFormat)
	}
}

func getLevelLogger(encoder zapcore.Encoder, logLevel zapcore.Level, fileFormat string) *zap.Logger {
	debugLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl >= logLevel && lvl == zap.DebugLevel
	})
	infoLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl >= logLevel && lvl == zap.InfoLevel
	})
	errorLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl >= logLevel && lvl == zap.ErrorLevel
	})

	core := zapcore.NewTee(
		zapcore.NewCore(encoder, zapcore.AddSync(getLoggerWriter("debug", fileFormat)), debugLevel),
		zapcore.NewCore(encoder, zapcore.AddSync(getLoggerWriter("info", fileFormat)), infoLevel),
		zapcore.NewCore(encoder, zapcore.AddSync(getLoggerWriter("error", fileFormat)), errorLevel),
	)
	return zap.New(core, zap.AddCaller(), zap.AddStacktrace(zap.WarnLevel))
}

func getOneLogger(encoder zapcore.Encoder, logLevel zapcore.Level, fileFormat string) *zap.Logger {
	core := zapcore.NewCore(encoder, zapcore.AddSync(getLoggerWriter("all", fileFormat)), logLevel)
	return zap.New(core, zap.AddCaller(), zap.AddStacktrace(zap.WarnLevel))
}

func getLoggerWriter(filename, fileFormat string) io.Writer {
	filePath, saveDay := "./logs", 30
	if cfg.C.Logger.FilePath != "" {
		filePath = cfg.C.Logger.FilePath
	}
	if cfg.C.Logger.MaxSaveDays > 0 {
		saveDay = cfg.C.Logger.MaxSaveDays
	}
	filename = filePath + "/" + filename
	hook, err := rotatelogs.New(filename+"/"+fileFormat+".log",
		rotatelogs.WithLinkName(filename),
		rotatelogs.WithMaxAge(time.Duration(saveDay)*24*time.Hour),
		rotatelogs.WithRotationTime(24*time.Hour),
	)
	if err != nil {
		log.Println("日志启动异常")
		panic(err)
	}
	return hook
}

func Debug(format string, v ...interface{}) {
	if cfg.C.Vber.Mode == "debug" {
		if v == nil {
			Logger.Sugar().Debug(format)
		} else {
			Logger.Sugar().Debugf(format, v...)
		}
	}
}

func Info(format string, v ...interface{}) {
	if v == nil {
		Logger.Sugar().Info(format)
	} else {
		Logger.Sugar().Infof(format, v...)
	}
}

func Error(format string, v ...interface{}) {
	if v == nil {
		Logger.Sugar().Error(format)
	} else {
		Logger.Sugar().Errorf(format, v...)
	}
}