package starlog

import "time"

type AsyncMetrics struct {
	Started        bool
	QueueLength    uint64
	QueueCapacity  uint64
	QueueFree      uint64
	Dropped        uint64
	FallbackToSync bool
	HandlerTimeout time.Duration
}

type ErrorMetrics struct {
	WriteErrors     uint64
	RedactionErrors uint64
}

type MetricsSnapshot struct {
	Time           time.Time
	LoggerName     string
	Level          int
	HasWriter      bool
	HasSink        bool
	HasMultiSink   bool
	ArchiveRunning bool
	Pending        PendingStats
	Sampling       SamplingStats
	Dedup          DedupStats
	RateLimit      RateLimitStats
	Async          AsyncMetrics
	Errors         ErrorMetrics
	MultiSink      MultiSinkStats
}

func GetAsyncMetrics() AsyncMetrics {
	stackMu.Lock()
	started := stackStarted
	current := stacks
	stackMu.Unlock()

	snapshot := AsyncMetrics{
		Started:        started,
		Dropped:        GetAsyncDropCount(),
		FallbackToSync: GetAsyncFallbackToSync(),
		HandlerTimeout: GetAsyncHandlerTimeout(),
	}
	if current != nil {
		snapshot.QueueLength = current.Len()
		snapshot.QueueCapacity = current.Cap()
		snapshot.QueueFree = current.Free()
	}
	return snapshot
}

func (logger *StarLogger) GetMetricsSnapshot() MetricsSnapshot {
	snapshot := MetricsSnapshot{
		Time:  time.Now(),
		Async: GetAsyncMetrics(),
		Errors: ErrorMetrics{
			WriteErrors: GetWriteErrorCount(),
		},
	}
	if logger == nil || logger.logcore == nil {
		return snapshot
	}

	snapshot.Pending = logger.GetPendingStats()
	snapshot.Sampling = logger.GetSamplingStats()
	snapshot.Dedup = logger.GetDedupStats()
	snapshot.RateLimit = logger.GetRateLimitStats()
	snapshot.Errors.RedactionErrors = logger.GetRedactErrorCount()
	snapshot.ArchiveRunning = IsArchiveRun(logger)

	logger.logcore.mu.Lock()
	snapshot.LoggerName = logger.logcore.name
	snapshot.Level = logger.logcore.minLevel
	snapshot.HasWriter = logger.logcore.output != nil
	sink := logger.logcore.sink
	snapshot.HasSink = sink != nil
	logger.logcore.mu.Unlock()

	if multi, ok := sink.(*MultiSink); ok && multi != nil {
		snapshot.HasMultiSink = true
		snapshot.MultiSink = multi.GetStats()
	}

	return snapshot
}

func (logger *StarLogger) GetAsyncMetrics() AsyncMetrics {
	_ = logger
	return GetAsyncMetrics()
}