package starlog

import (
	"context"
	"io"
	"os"
	"strings"
	"sync/atomic"
	"time"
)

func (logger *StarLogger) clone() *StarLogger {
	if logger == nil {
		return nil
	}
	return &StarLogger{
		thread:      logger.thread,
		handlerFunc: logger.handlerFunc,
		logcore:     logger.logcore,
		isStd:       logger.isStd,
		fields:      cloneFields(logger.fields),
		logErr:      logger.logErr,
		logCtx:      logger.logCtx,
	}
}

func normalizePendingLimit(limit int) int {
	if limit < 0 {
		return 0
	}
	return limit
}

func normalizeDropPolicy(policy PendingDropPolicy) PendingDropPolicy {
	switch policy {
	case PendingDropOldest, PendingDropNewest, PendingBlock:
		return policy
	default:
		return PendingDropOldest
	}
}

func (logger *starlog) snapshotConfigLocked() Config {
	rateCfg := normalizeRateLimitConfig(DefaultRateLimitConfig())
	if logger.rateLimiter != nil {
		rateCfg = logger.rateLimiter.Config()
	}
	samplingCfg := normalizeSamplingConfig(DefaultSamplingConfig())
	if logger.sampler != nil {
		samplingCfg = logger.sampler.Config()
	}
	dedupCfg := normalizeDedupConfig(DefaultDedupConfig())
	if logger.deduper != nil {
		dedupCfg = logger.deduper.Config()
	}
	return Config{
		Name:                  logger.name,
		Level:                 logger.minLevel,
		StdErrLevel:           logger.errOutputLevel,
		ShowFuncName:          logger.showFuncName,
		ShowFlag:              logger.showThread,
		ShowLevel:             logger.showLevel,
		ShowOriginFile:        logger.showDeatilFile,
		ShowColor:             logger.showColor,
		OnlyColorLevel:        logger.onlyColorLevel,
		ShowStd:               logger.showStd,
		StopWriter:            logger.stopWriter,
		AutoAppendNewline:     logger.autoAppendNewline,
		Switching:             logger.switching,
		LevelColors:           cloneLevelAttrsMap(logger.colorList),
		KeywordColors:         cloneColorMap(logger.keywordColors),
		KeywordMatch:          logger.keywordMatchOptions,
		ShowFieldColor:        logger.showFieldColor,
		FieldKeyColor:         cloneAttrs(logger.fieldKeyColor),
		FieldTypeColors:       cloneColorMap(logger.fieldTypeColors),
		FieldValueColors:      cloneColorMap(logger.fieldValueColors),
		EntryHandler:          logger.entryHandler,
		EntryHandlerTimeout:   logger.entryHandlerTimeout,
		Formatter:             logger.formatter,
		Sink:                  logger.sink,
		Writer:                logger.output,
		PendingWriteLimit:     logger.pendingWriteLimit,
		PendingDropPolicy:     logger.pendingDropPolicy,
		Redactor:              logger.redactor,
		RedactRules:           cloneRedactRules(logger.redactRules),
		RedactFailMode:        logger.redactFailMode,
		RedactMaskToken:       logger.redactMaskToken,
		RateLimit:             rateCfg,
		Sampling:              samplingCfg,
		Dedup:                 dedupCfg,
		ContextFieldExtractor: logger.contextFields,
	}
}

func (logger *starlog) applyPendingLimitLocked(limit int) {
	logger.pendingWriteLimit = normalizePendingLimit(limit)
	if logger.pendingWriteLimit == 0 {
		logger.signalPendingCondLocked()
		return
	}
	if len(logger.pendingWrites) <= logger.pendingWriteLimit {
		logger.signalPendingCondLocked()
		return
	}
	dropped := len(logger.pendingWrites) - logger.pendingWriteLimit
	switch logger.pendingDropPolicy {
	case PendingDropNewest:
		keepEnd := len(logger.pendingWrites) - dropped
		for idx := keepEnd; idx < len(logger.pendingWrites); idx++ {
			reportWriteError(ErrPendingWriteDropped, LogData{
				Name: logger.name,
				Log:  logger.pendingWrites[idx],
			})
		}
		logger.pendingWrites = logger.pendingWrites[:keepEnd]
	default:
		for idx := 0; idx < dropped; idx++ {
			reportWriteError(ErrPendingWriteDropped, LogData{
				Name: logger.name,
				Log:  logger.pendingWrites[idx],
			})
		}
		logger.pendingWrites = logger.pendingWrites[dropped:]
	}
	atomic.AddUint64(&logger.pendingDropCount, uint64(dropped))
	logger.signalPendingCondLocked()
}

func (logger *starlog) applyConfigLocked(cfg Config) {
	logger.name = cfg.Name
	logger.minLevel = cfg.Level
	logger.errOutputLevel = cfg.StdErrLevel
	logger.showFuncName = cfg.ShowFuncName
	logger.showThread = cfg.ShowFlag
	logger.showLevel = cfg.ShowLevel
	logger.showDeatilFile = cfg.ShowOriginFile
	logger.showColor = cfg.ShowColor
	logger.onlyColorLevel = cfg.OnlyColorLevel
	logger.showStd = cfg.ShowStd
	logger.stopWriter = cfg.StopWriter
	logger.autoAppendNewline = cfg.AutoAppendNewline
	logger.colorList = cloneLevelAttrsMap(cfg.LevelColors)
	logger.colorMe = cloneLevelColorMap(logger.colorList)
	logger.keywordColors = cloneColorMap(cfg.KeywordColors)
	logger.rebuildKeywordCachesLocked()
	logger.keywordMatchOptions = cfg.KeywordMatch
	logger.showFieldColor = cfg.ShowFieldColor
	logger.fieldKeyColor = cloneAttrs(cfg.FieldKeyColor)
	logger.fieldTypeColors = cloneColorMap(cfg.FieldTypeColors)
	logger.fieldValueColors = cloneColorMap(cfg.FieldValueColors)
	logger.entryHandler = cfg.EntryHandler
	if cfg.EntryHandlerTimeout < 0 {
		cfg.EntryHandlerTimeout = 0
	}
	logger.entryHandlerTimeout = cfg.EntryHandlerTimeout
	logger.formatter = cfg.Formatter
	logger.sink = cfg.Sink
	logger.output = cfg.Writer
	logger.pendingDropPolicy = normalizeDropPolicy(cfg.PendingDropPolicy)
	logger.applyPendingLimitLocked(cfg.PendingWriteLimit)
	logger.redactor = cfg.Redactor
	logger.redactRules = cloneRedactRules(cfg.RedactRules)
	switch cfg.RedactFailMode {
	case RedactFailMaskAll, RedactFailOpen, RedactFailDrop:
		logger.redactFailMode = cfg.RedactFailMode
	default:
		logger.redactFailMode = RedactFailMaskAll
	}
	logger.redactMaskToken = normalizeRedactMask(cfg.RedactMaskToken)
	if logger.rateLimiter == nil {
		logger.rateLimiter = newRateLimiter()
	}
	logger.rateLimiter.SetConfig(cfg.RateLimit)
	if logger.sampler == nil {
		logger.sampler = newSampler()
	}
	logger.sampler.SetConfig(cfg.Sampling)
	if logger.deduper == nil {
		logger.deduper = newDeduper()
	}
	logger.deduper.SetConfig(cfg.Dedup)
	logger.contextFields = cfg.ContextFieldExtractor
	logger.switching = cfg.Switching
	if !logger.switching {
		logger.writePendingLocked()
		return
	}
	logger.signalPendingCondLocked()
}

func (logger *StarLogger) GetConfig() Config {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.snapshotConfigLocked()
}

func (logger *StarLogger) ApplyConfig(cfg Config) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.applyConfigLocked(cfg)
}

func (logger *StarLogger) UpdateConfig(update func(*Config)) {
	if update == nil {
		return
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	cfg := logger.logcore.snapshotConfigLocked()
	update(&cfg)
	logger.logcore.applyConfigLocked(cfg)
}

func DefaultConfig() Config {
	core := newLogCore(nil)
	return core.snapshotConfigLocked()
}

func (logger *StarLogger) WithField(key string, value interface{}) *StarLogger {
	key = strings.TrimSpace(key)
	if key == "" {
		return logger
	}
	cloned := logger.clone()
	if cloned.fields == nil {
		cloned.fields = make(Fields)
	}
	cloned.fields[key] = value
	return cloned
}

func (logger *StarLogger) WithFields(fields Fields) *StarLogger {
	if len(fields) == 0 {
		return logger
	}
	cloned := logger.clone()
	if cloned.fields == nil {
		cloned.fields = make(Fields)
	}
	for key, value := range fields {
		key = strings.TrimSpace(key)
		if key == "" {
			continue
		}
		cloned.fields[key] = value
	}
	return cloned
}

func (logger *StarLogger) WithError(err error) *StarLogger {
	cloned := logger.clone()
	cloned.logErr = err
	return cloned
}

func (logger *StarLogger) WithContext(ctx context.Context) *StarLogger {
	cloned := logger.clone()
	cloned.logCtx = ctx
	return cloned
}

func (logger *StarLogger) SetContextFieldExtractor(extractor func(context.Context) Fields) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.contextFields = extractor
}

func (logger *StarLogger) SetRedactor(redactor Redactor) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.redactor = redactor
}

func (logger *StarLogger) GetRedactor() Redactor {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.redactor
}

func (logger *StarLogger) AddRedactRule(rule RedactRule) {
	if rule == nil {
		return
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.redactRules = append(logger.logcore.redactRules, rule)
}

func (logger *StarLogger) SetRedactRules(rules []RedactRule) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.redactRules = cloneRedactRules(rules)
}

func (logger *StarLogger) ClearRedactRules() {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.redactRules = nil
}

func (logger *StarLogger) GetRedactRuleCount() int {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return len(logger.logcore.redactRules)
}

func (logger *StarLogger) SetRedactFailMode(mode RedactFailMode) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	switch mode {
	case RedactFailMaskAll, RedactFailOpen, RedactFailDrop:
	default:
		mode = RedactFailMaskAll
	}
	logger.logcore.redactFailMode = mode
}

func (logger *StarLogger) GetRedactFailMode() RedactFailMode {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.redactFailMode
}

func (logger *StarLogger) SetRedactMaskToken(mask string) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.redactMaskToken = normalizeRedactMask(mask)
}

func (logger *StarLogger) GetRedactMaskToken() string {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.redactMaskToken
}

func (logger *StarLogger) GetRedactErrorCount() uint64 {
	return atomic.LoadUint64(&logger.logcore.redactErrorCount)
}

func (logger *StarLogger) emit(level int, isShow bool, message string) {
	logger.logcore.mu.Lock()
	handler := logger.handlerFunc
	logger.logcore.mu.Unlock()
	logger.logcore.build(logger.thread, logger.isStd, isShow, handler, level, message, cloneFields(logger.fields), logger.logErr, logger.logCtx)
}

func (logger *StarLogger) SetShowColor(val bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showColor = val
}

func (logger *StarLogger) GetShowColor() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showColor
}

func (logger *StarLogger) SetLevelColor(level int, color []Attr) {
	cloned := make([]Attr, len(color))
	copy(cloned, color)
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.colorList[level] = cloned
	logger.logcore.colorMe[level] = NewColor(cloned...)
}

func (logger *StarLogger) GetLevelColor(level int) []Attr {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	if logger.logcore.colorList[level] == nil {
		return nil
	}
	cloned := make([]Attr, len(logger.logcore.colorList[level]))
	copy(cloned, logger.logcore.colorList[level])
	return cloned
}

func (logger *StarLogger) SetLevel(level int) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.minLevel = level
}

func (logger *StarLogger) GetLevel() int {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.minLevel
}

func (logger *StarLogger) IsLevelEnabled(level int) bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return level >= logger.logcore.minLevel
}

func (logger *StarLogger) SetWriter(wr io.Writer) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.output = wr
	logger.logcore.sink = nil
	if !logger.logcore.switching {
		logger.logcore.writePendingLocked()
	}
}
func (logger *StarLogger) GetWriter() io.Writer {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.output
}

func (logger *StarLogger) SetSink(sink Sink) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.sink = sink
	if !logger.logcore.switching {
		logger.logcore.writePendingLocked()
	}
}

func (logger *StarLogger) SetSinks(sinks ...Sink) {
	logger.SetSink(NewMultiSink(sinks...))
}

func (logger *StarLogger) GetSink() Sink {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.sink
}

func (logger *StarLogger) SetFormatter(formatter Formatter) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.formatter = formatter
}

func (logger *StarLogger) GetFormatter() Formatter {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.formatter
}

func (logger *StarLogger) SetEntryHandler(handler Handler) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.entryHandler = handler
}

func (logger *StarLogger) GetEntryHandler() Handler {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.entryHandler
}

func (logger *StarLogger) AppendEntryHandler(handler Handler) {
	if handler == nil {
		return
	}
	logger.logcore.mu.Lock()
	current := logger.logcore.entryHandler
	logger.logcore.mu.Unlock()
	logger.SetEntryHandler(ChainHandler(current, handler))
}

func (logger *StarLogger) SetHandler(f func(LogData)) {
	if f != nil {
		StartStacks()
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.handlerFunc = f
}
func (logger *StarLogger) GetHandler() func(LogData) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.handlerFunc
}
func (logger *StarLogger) SetSwitching(sw bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.switching = sw
	if !sw {
		logger.logcore.writePendingLocked()
		return
	}
	logger.logcore.signalPendingCondLocked()
}

func (logger *StarLogger) SetAsyncErrorHandler(alert func(error, LogData)) {
	SetAsyncErrorHandler(alert)
}

func (logger *StarLogger) GetAsyncDropCount() uint64 {
	return GetAsyncDropCount()
}

func (logger *StarLogger) SetAsyncFallbackToSync(enable bool) {
	SetAsyncFallbackToSync(enable)
}

func (logger *StarLogger) GetAsyncFallbackToSync() bool {
	return GetAsyncFallbackToSync()
}

func (logger *StarLogger) SetAsyncHandlerTimeout(timeout time.Duration) {
	SetAsyncHandlerTimeout(timeout)
}

func (logger *StarLogger) GetAsyncHandlerTimeout() time.Duration {
	return GetAsyncHandlerTimeout()
}

func (logger *StarLogger) SetWriteErrorHandler(alert func(error, LogData)) {
	SetWriteErrorHandler(alert)
}

func (logger *StarLogger) GetWriteErrorCount() uint64 {
	return GetWriteErrorCount()
}

func (logger *StarLogger) SetOnlyColorLevel(ocl bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.onlyColorLevel = ocl
}
func (logger *StarLogger) GetOnlyColorLevel() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.onlyColorLevel
}

func (logger *StarLogger) SetColorMode(mode ColorMode) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	switch mode {
	case ColorModeOff:
		logger.logcore.showColor = false
		logger.logcore.onlyColorLevel = false
	case ColorModeLevelOnly:
		logger.logcore.showColor = true
		logger.logcore.onlyColorLevel = true
	default:
		logger.logcore.showColor = true
		logger.logcore.onlyColorLevel = false
	}
}

func (logger *StarLogger) GetColorMode() ColorMode {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	if !logger.logcore.showColor {
		return ColorModeOff
	}
	if logger.logcore.onlyColorLevel {
		return ColorModeLevelOnly
	}
	return ColorModeFullLine
}

func (logger *StarLogger) SetKeywordColor(keyword string, color []Attr) {
	keyword = strings.TrimSpace(keyword)
	if keyword == "" {
		return
	}
	cloned := make([]Attr, len(color))
	copy(cloned, color)
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.keywordColors[keyword] = cloned
	logger.logcore.rebuildKeywordCachesLocked()
}

func cloneAttrs(color []Attr) []Attr {
	cloned := make([]Attr, len(color))
	copy(cloned, color)
	return cloned
}

func cloneColorMap(source map[string][]Attr) map[string][]Attr {
	if len(source) == 0 {
		return map[string][]Attr{}
	}
	cloned := make(map[string][]Attr, len(source))
	for key, attrs := range source {
		cloned[key] = cloneAttrs(attrs)
	}
	return cloned
}

func (logger *StarLogger) RemoveKeywordColor(keyword string) {
	keyword = strings.TrimSpace(keyword)
	if keyword == "" {
		return
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	delete(logger.logcore.keywordColors, keyword)
	logger.logcore.rebuildKeywordCachesLocked()
}

func (logger *StarLogger) ClearKeywordColors() {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.keywordColors = make(map[string][]Attr)
	logger.logcore.rebuildKeywordCachesLocked()
}

func (logger *StarLogger) SetKeywordColors(colors map[string][]Attr) {
	cloned := make(map[string][]Attr, len(colors))
	for keyword, attrs := range colors {
		keyword = strings.TrimSpace(keyword)
		if keyword == "" {
			continue
		}
		attrCopy := make([]Attr, len(attrs))
		copy(attrCopy, attrs)
		cloned[keyword] = attrCopy
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.keywordColors = cloned
	logger.logcore.rebuildKeywordCachesLocked()
}

func (logger *StarLogger) GetKeywordColors() map[string][]Attr {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	cloned := make(map[string][]Attr, len(logger.logcore.keywordColors))
	for keyword, attrs := range logger.logcore.keywordColors {
		attrCopy := make([]Attr, len(attrs))
		copy(attrCopy, attrs)
		cloned[keyword] = attrCopy
	}
	return cloned
}

func (logger *StarLogger) SetKeywordMatchOptions(opts KeywordMatchOptions) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.keywordMatchOptions = opts
}

func (logger *StarLogger) GetKeywordMatchOptions() KeywordMatchOptions {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.keywordMatchOptions
}

func (logger *StarLogger) SetKeywordIgnoreCase(enable bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.keywordMatchOptions.IgnoreCase = enable
}

func (logger *StarLogger) GetKeywordIgnoreCase() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.keywordMatchOptions.IgnoreCase
}

func (logger *StarLogger) SetKeywordWholeWord(enable bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.keywordMatchOptions.WholeWord = enable
}

func (logger *StarLogger) GetKeywordWholeWord() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.keywordMatchOptions.WholeWord
}

func (logger *StarLogger) SetShowFieldColor(show bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showFieldColor = show
}

func (logger *StarLogger) GetShowFieldColor() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showFieldColor
}

func (logger *StarLogger) SetFieldKeyColor(color []Attr) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.fieldKeyColor = cloneAttrs(color)
}

func (logger *StarLogger) GetFieldKeyColor() []Attr {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return cloneAttrs(logger.logcore.fieldKeyColor)
}

func (logger *StarLogger) SetFieldTypeColor(fieldType string, color []Attr) {
	fieldType = strings.TrimSpace(strings.ToLower(fieldType))
	if fieldType == "" {
		return
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	if logger.logcore.fieldTypeColors == nil {
		logger.logcore.fieldTypeColors = make(map[string][]Attr)
	}
	logger.logcore.fieldTypeColors[fieldType] = cloneAttrs(color)
}

func (logger *StarLogger) GetFieldTypeColors() map[string][]Attr {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return cloneColorMap(logger.logcore.fieldTypeColors)
}

func (logger *StarLogger) SetFieldValueColor(field string, color []Attr) {
	field = strings.TrimSpace(field)
	if field == "" {
		return
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	if logger.logcore.fieldValueColors == nil {
		logger.logcore.fieldValueColors = make(map[string][]Attr)
	}
	logger.logcore.fieldValueColors[field] = cloneAttrs(color)
}

func (logger *StarLogger) RemoveFieldValueColor(field string) {
	field = strings.TrimSpace(field)
	if field == "" {
		return
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	delete(logger.logcore.fieldValueColors, field)
}

func (logger *StarLogger) ClearFieldValueColors() {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.fieldValueColors = make(map[string][]Attr)
}

func (logger *StarLogger) GetFieldValueColors() map[string][]Attr {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return cloneColorMap(logger.logcore.fieldValueColors)
}

func (logger *StarLogger) SetPendingWriteLimit(limit int) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.applyPendingLimitLocked(limit)
}

func (logger *StarLogger) GetPendingWriteLimit() int {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.pendingWriteLimit
}

func (logger *StarLogger) SetPendingDropPolicy(policy PendingDropPolicy) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.pendingDropPolicy = normalizeDropPolicy(policy)
	logger.logcore.signalPendingCondLocked()
}

func (logger *StarLogger) GetPendingDropPolicy() PendingDropPolicy {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.pendingDropPolicy
}

func (logger *StarLogger) GetPendingDropCount() uint64 {
	return atomic.LoadUint64(&logger.logcore.pendingDropCount)
}

func (logger *StarLogger) GetPendingBlockCount() uint64 {
	return atomic.LoadUint64(&logger.logcore.pendingBlockCount)
}

func (logger *StarLogger) GetPendingPeakLength() int {
	return int(atomic.LoadUint64(&logger.logcore.pendingPeakLen))
}

func (logger *StarLogger) GetPendingStats() PendingStats {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return PendingStats{
		Limit:      logger.logcore.pendingWriteLimit,
		Length:     len(logger.logcore.pendingWrites),
		PeakLength: int(atomic.LoadUint64(&logger.logcore.pendingPeakLen)),
		DropCount:  atomic.LoadUint64(&logger.logcore.pendingDropCount),
		BlockCount: atomic.LoadUint64(&logger.logcore.pendingBlockCount),
		Policy:     logger.logcore.pendingDropPolicy,
		Switching:  logger.logcore.switching,
	}
}

func (logger *StarLogger) SetEntryHandlerTimeout(timeout time.Duration) {
	if timeout < 0 {
		timeout = 0
	}
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.entryHandlerTimeout = timeout
}

func (logger *StarLogger) GetEntryHandlerTimeout() time.Duration {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.entryHandlerTimeout
}

func (logger *StarLogger) SetShowOriginFile(val bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showDeatilFile = val
}

func (logger *StarLogger) GetShowOriginFile() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showDeatilFile
}

func (logger *StarLogger) SetShowFuncName(val bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showFuncName = val
}

func (logger *StarLogger) GetShowFuncName() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showFuncName
}

func (logger *StarLogger) SetShowLevel(val bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showLevel = val
}

func (logger *StarLogger) GetShowLevel() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showLevel
}

func (logger *StarLogger) SetShowFlag(val bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showThread = val
}

func (logger *StarLogger) GetShowFlag() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showThread
}

func (logger *StarLogger) SetShowStd(val bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.showStd = val
}

func (logger *StarLogger) GetShowStd() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.showStd
}

func (logger *StarLogger) SetAutoAppendNewline(enable bool) {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.autoAppendNewline = enable
}

func (logger *StarLogger) GetAutoAppendNewline() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.autoAppendNewline
}

func (logger *StarLogger) StopWrite() {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.stopWriter = true
}

func (logger *StarLogger) EnableWrite() {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	logger.logcore.stopWriter = false
}

func (logger *StarLogger) IsWriteStopped() bool {
	logger.logcore.mu.Lock()
	defer logger.logcore.mu.Unlock()
	return logger.logcore.stopWriter
}

// Deprecated: use EnableWrite.
func (logger *StarLogger) EnbaleWrite() {
	logger.EnableWrite()
}

// Deprecated: use IsWriteStopped.
func (logger *StarLogger) IsWriteStoed() bool {
	return logger.IsWriteStopped()
}

func (logger *StarLogger) Debug(str ...interface{}) {
	logger.emit(LvDebug, logger.GetShowStd(), logger.logcore.print(str...))
}

func (logger *StarLogger) Debugf(format string, str ...interface{}) {
	logger.emit(LvDebug, logger.GetShowStd(), logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Debugln(str ...interface{}) {
	logger.emit(LvDebug, logger.GetShowStd(), logger.logcore.println(str...))
}

func (logger *StarLogger) Info(str ...interface{}) {
	logger.emit(LvInfo, logger.GetShowStd(), logger.logcore.print(str...))
}

func (logger *StarLogger) Infof(format string, str ...interface{}) {
	logger.emit(LvInfo, logger.GetShowStd(), logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Infoln(str ...interface{}) {
	logger.emit(LvInfo, logger.GetShowStd(), logger.logcore.println(str...))
}

func (logger *StarLogger) Notice(str ...interface{}) {
	logger.emit(LvNotice, logger.GetShowStd(), logger.logcore.print(str...))
}

func (logger *StarLogger) Noticef(format string, str ...interface{}) {
	logger.emit(LvNotice, logger.GetShowStd(), logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Noticeln(str ...interface{}) {
	logger.emit(LvNotice, logger.GetShowStd(), logger.logcore.println(str...))
}

func (logger *StarLogger) Warning(str ...interface{}) {
	logger.emit(LvWarning, logger.GetShowStd(), logger.logcore.print(str...))
}

func (logger *StarLogger) Warningf(format string, str ...interface{}) {
	logger.emit(LvWarning, logger.GetShowStd(), logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Warningln(str ...interface{}) {
	logger.emit(LvWarning, logger.GetShowStd(), logger.logcore.println(str...))
}

func (logger *StarLogger) Error(str ...interface{}) {
	logger.emit(LvError, logger.GetShowStd(), logger.logcore.print(str...))
}

func (logger *StarLogger) Errorf(format string, str ...interface{}) {
	logger.emit(LvError, logger.GetShowStd(), logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Errorln(str ...interface{}) {
	logger.emit(LvError, logger.GetShowStd(), logger.logcore.println(str...))
}

func (logger *StarLogger) Critical(str ...interface{}) {
	logger.emit(LvCritical, logger.GetShowStd(), logger.logcore.print(str...))
}

func (logger *StarLogger) Criticalf(format string, str ...interface{}) {
	logger.emit(LvCritical, logger.GetShowStd(), logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Criticalln(str ...interface{}) {
	logger.emit(LvCritical, logger.GetShowStd(), logger.logcore.println(str...))
}

func (logger *StarLogger) Fatal(str ...interface{}) {
	logger.emit(LvFatal, logger.GetShowStd(), logger.logcore.print(str...))
	_ = logger.Shutdown(context.Background())
	os.Exit(9)
}

func (logger *StarLogger) Fatalf(format string, str ...interface{}) {
	logger.emit(LvFatal, logger.GetShowStd(), logger.logcore.printf(format, str...))
	_ = logger.Shutdown(context.Background())
	os.Exit(9)
}

func (logger *StarLogger) Fatalln(str ...interface{}) {
	logger.emit(LvFatal, logger.GetShowStd(), logger.logcore.println(str...))
	_ = logger.Shutdown(context.Background())
	os.Exit(9)
}

func (logger *StarLogger) Panic(str ...interface{}) {
	msg := logger.logcore.print(str...)
	logger.emit(LvPanic, logger.GetShowStd(), msg)
	panic(str)
}

func (logger *StarLogger) Panicf(format string, str ...interface{}) {
	msg := logger.logcore.printf(format, str...)
	logger.emit(LvPanic, logger.GetShowStd(), msg)
	panic(msg)
}

func (logger *StarLogger) Panicln(str ...interface{}) {
	msg := logger.logcore.println(str...)
	logger.emit(LvPanic, logger.GetShowStd(), msg)
	panic(msg)
}

func (logger *StarLogger) Print(str ...interface{}) {
	logger.logcore.Print(logger.thread, logger.isStd, logger.GetShowStd(), logger.handlerFunc, str...)
}

func (logger *StarLogger) Printf(format string, str ...interface{}) {
	logger.logcore.Printf(logger.thread, logger.isStd, logger.GetShowStd(), logger.handlerFunc, format, str...)
}

func (logger *StarLogger) Println(str ...interface{}) {
	logger.logcore.Println(logger.thread, logger.isStd, logger.GetShowStd(), logger.handlerFunc, str...)
}

func (logger *StarLogger) Log(showLog bool, level int, str ...interface{}) {
	logger.emit(level, showLog, logger.logcore.print(str...))
}

func (logger *StarLogger) LogContext(ctx context.Context, showLog bool, level int, str ...interface{}) {
	logger.WithContext(ctx).Log(showLog, level, str...)
}

func (logger *StarLogger) Logf(showLog bool, level int, format string, str ...interface{}) {
	logger.emit(level, showLog, logger.logcore.printf(format, str...))
}

func (logger *StarLogger) Logln(showLog bool, level int, str ...interface{}) {
	logger.emit(level, showLog, logger.logcore.println(str...))
}

func (logger *StarLogger) Write(str ...interface{}) {
	logger.logcore.Write(str...)
}

func (logger *StarLogger) Writef(format string, str ...interface{}) {
	logger.logcore.Writef(format, str...)
}

func (logger *StarLogger) Writeln(str ...interface{}) {
	logger.logcore.Writeln(str...)
}

func (logger *StarLogger) DebugContext(ctx context.Context, str ...interface{}) {
	logger.WithContext(ctx).Debug(str...)
}

func (logger *StarLogger) InfoContext(ctx context.Context, str ...interface{}) {
	logger.WithContext(ctx).Info(str...)
}

func (logger *StarLogger) NoticeContext(ctx context.Context, str ...interface{}) {
	logger.WithContext(ctx).Notice(str...)
}

func (logger *StarLogger) WarningContext(ctx context.Context, str ...interface{}) {
	logger.WithContext(ctx).Warning(str...)
}

func (logger *StarLogger) ErrorContext(ctx context.Context, str ...interface{}) {
	logger.WithContext(ctx).Error(str...)
}

func (logger *StarLogger) CriticalContext(ctx context.Context, str ...interface{}) {
	logger.WithContext(ctx).Critical(str...)
}