// Package logger define log struct of modelRT project
package logger

import (
	"os"
	"sync"

	"modelRT/config"
	"modelRT/constants"

	"github.com/natefinch/lumberjack"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

var (
	once            sync.Once
	_globalLoggerMu sync.RWMutex
	_globalLogger   *zap.Logger
)

// getEncoder responsible for setting the log format for encoding
func getEncoder() zapcore.Encoder {
	encoderConfig := zap.NewProductionEncoderConfig()
	// serialization time eg:2006-01-02 15:04:05
	encoderConfig.EncodeTime = zapcore.TimeEncoderOfLayout("2006-01-02 15:04:05")
	encoderConfig.TimeKey = "time"
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
	encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
	return zapcore.NewJSONEncoder(encoderConfig)
}

// getLogWriter responsible for setting the location of log storage
func getLogWriter(mode, filename string, maxsize, maxBackup, maxAge int, compress bool) zapcore.WriteSyncer {
	lumberJackLogger := &lumberjack.Logger{
		Filename:   filename,  // log file position
		MaxSize:    maxsize,   // log file maxsize
		MaxAge:     maxAge,    // maximum number of day files retained
		MaxBackups: maxBackup, // maximum number of old files retained
		Compress:   compress,  // whether to compress
	}

	syncConsole := zapcore.AddSync(os.Stderr)
	if mode == constants.DevelopmentLogMode {
		return syncConsole
	}

	syncFile := zapcore.AddSync(lumberJackLogger)
	return zapcore.NewMultiWriteSyncer(syncFile, syncConsole)
}

// initLogger return successfully initialized zap logger
func initLogger(lCfg config.LoggerConfig) *zap.Logger {
	writeSyncer := getLogWriter(lCfg.Mode, lCfg.FilePath, lCfg.MaxSize, lCfg.MaxBackups, lCfg.MaxAge, lCfg.Compress)
	encoder := getEncoder()

	l := new(zapcore.Level)
	err := l.UnmarshalText([]byte(lCfg.Level))
	if err != nil {
		panic(err)
	}

	core := zapcore.NewCore(encoder, writeSyncer, l)
	logger := zap.New(core, zap.AddCaller())

	// 替换全局日志实例
	zap.ReplaceGlobals(logger)
	return logger
}

// InitLoggerInstance define func of return instance of zap logger
func InitLoggerInstance(lCfg config.LoggerConfig) {
	once.Do(func() {
		_globalLogger = initLogger(lCfg)
	})
	defer _globalLogger.Sync()
}

// GetLoggerInstance define func of returns the global logger instance It's safe for concurrent use.
func GetLoggerInstance() *zap.Logger {
	_globalLoggerMu.RLock()
	logger := _globalLogger
	_globalLoggerMu.RUnlock()
	return logger
}