package logsdk

import (
	"os"
	"sync"
	"sync/atomic"
)

// New 返回初始未经过参数调整的 Logger
func New() *Logger {
	logger := &Logger{}
	logger.entry.logger = logger
	logger.Reset()
	return logger
}

// entry 仅被用来嵌入 Logger
type entry = Entry

// Logger 中保存了日志所需的全局配置,
// 使用 Logger 处理日志.
type Logger struct {
	exit            func(code int)   // protected by lock
	beforeExit      []func(code int) // protected by lock
	levelProcessors levelProcessors  // protected by lock
	entry
	lock             sync.RWMutex
	level            atomic.Int32
	reportStackLevel atomic.Int32
	callerSkip       atomic.Int32
	reportCaller     atomic.Bool
	reportStack      atomic.Bool
}

// AddProcessor 把日志处理器增加到 Logger
func (logger *Logger) AddProcessor(levels []Level, processor EntryProcessor) {
	logger.lock.Lock()
	for _, level := range levels {
		logger.levelProcessors[level+LevelOffset] = append(logger.levelProcessors[level+LevelOffset], processor)
	}
	logger.lock.Unlock()
}

// GetLevel 返回日志系统的等级, 严重程度低于返回等级的日志不会被处理.
func (logger *Logger) GetLevel() Level {
	return Level(logger.level.Load())
}

// SetLevel 设置日志系统的等级
func (logger *Logger) SetLevel(level Level) {
	logger.level.Store(int32(level))
}

// GetCallerSkip 获取调用 [runtime.Callers] 时的 skip 参数,
// skip 已经被偏移到从调用 Logger 相关方法处获取调用信息.
// 0 表示从调用 Logger 相关方法处获取调用信息.
func (logger *Logger) GetCallerSkip() int {
	return int(logger.callerSkip.Load())
}

// SetCallerSkip 设置调用 [runtime.Callers] 时的 skip 参数,
// skip 已经被偏移到从调用 Logger 相关方法处获取调用信息.
// 0 表示从调用 Logger 相关方法处获取调用信息.
func (logger *Logger) SetCallerSkip(callerSkip int) {
	logger.callerSkip.Store(int32(callerSkip))
}

// GetReportCaller 返回是否收集调用信息
func (logger *Logger) GetReportCaller() bool {
	return logger.reportCaller.Load()
}

// SetReportCaller 设置是否收集调用信息
func (logger *Logger) SetReportCaller(reportCaller bool) {
	logger.reportCaller.Store(reportCaller)
}

// GetReportStack 返回是否收集调用栈信息
func (logger *Logger) GetReportStack() bool {
	return logger.reportStack.Load()
}

// SetReportStack 设置是否收集调用栈信息
func (logger *Logger) SetReportStack(reportStack bool) {
	logger.reportStack.Store(reportStack)
}

// GetReportStackLevel 获取自动添加调用栈对应的日志等级
func (logger *Logger) GetReportStackLevel() Level {
	return Level(logger.reportStackLevel.Load())
}

// SetReportStackLevel 设置日志等级小于等于 level 时自动添加调用栈
func (logger *Logger) SetReportStackLevel(level Level) {
	logger.reportStackLevel.Store(int32(level))
}

// Reset 把 Logger 重置到初始状态
func (logger *Logger) Reset() {
	logger.lock.Lock()
	logger.exit = nil
	logger.beforeExit = nil
	logger.levelProcessors = levelProcessors{}
	logger.lock.Unlock()

	logger.SetLevel(LevelInfo)
	logger.SetReportStackLevel(LevelWarn)
	logger.SetCallerSkip(0)
	logger.SetReportCaller(false)
	logger.SetReportStack(false)
}

// Exit 退出程序, 执行的具体过程可以通过 SetExit 指定
func (logger *Logger) Exit(code int) {
	logger.lock.RLock()
	exit := logger.exit
	beforeExit := make([]func(int), len(logger.beforeExit))
	copy(beforeExit, logger.beforeExit)
	logger.lock.RUnlock()
	for i := len(beforeExit) - 1; i >= 0; i-- {
		beforeExit[i](code)
	}
	if exit == nil {
		exit = os.Exit
	}
	exit(code)
}

// SetExit 指定退出程序时执行的函数
func (logger *Logger) SetExit(fn func(code int)) {
	logger.lock.Lock()
	logger.exit = fn
	logger.lock.Unlock()
}

// AddBeforeExit 增加 Exit 在调用 SetExit 指定的函数前执行的函数,
// 先增加的后执行.
func (logger *Logger) AddBeforeExit(fn ...func(code int)) {
	logger.lock.Lock()
	logger.beforeExit = append(logger.beforeExit, fn...)
	logger.lock.Unlock()
}

func (logger *Logger) getLevelProcessors(level Level) []EntryProcessor {
	logger.lock.RLock()
	defer logger.lock.RUnlock()
	return logger.levelProcessors[level+LevelOffset]
}

func (logger *Logger) newEntry() Entry {
	return Entry{
		logger:       logger,
		callerSkip:   logger.GetCallerSkip() + entrySkipOffset,
		reportCaller: logger.GetReportCaller(),
		reportStack:  logger.GetReportStack(),
		initialized:  true,
	}
}