package slog

import (
	"context"
	"fmt"
	"log/slog"
	"os"
	"runtime"
	"strconv"
	"sync"
	"time"

	"go.unistack.org/micro/v3/logger"
	"go.unistack.org/micro/v3/tracer"
)

var (
	DefaultSourceKey  string = slog.SourceKey
	DefaultTimeKey    string = slog.TimeKey
	DefaultMessageKey string = slog.MessageKey
	DefaultLevelKey   string = slog.LevelKey
)

var (
	traceValue = slog.StringValue("trace")
	debugValue = slog.StringValue("debug")
	infoValue  = slog.StringValue("info")
	warnValue  = slog.StringValue("warn")
	errorValue = slog.StringValue("error")
	fatalValue = slog.StringValue("fatal")
)

func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
	switch a.Key {
	case slog.SourceKey:
		source := a.Value.Any().(*slog.Source)
		a.Value = slog.StringValue(source.File + ":" + strconv.Itoa(source.Line))
		a.Key = s.sourceKey
	case slog.TimeKey:
		a.Key = s.timeKey
	case slog.MessageKey:
		a.Key = s.messageKey
	case slog.LevelKey:
		level := a.Value.Any().(slog.Level)
		lvl := slogToLoggerLevel(level)
		a.Key = s.levelKey
		switch {
		case lvl < logger.DebugLevel:
			a.Value = traceValue
		case lvl < logger.InfoLevel:
			a.Value = debugValue
		case lvl < logger.WarnLevel:
			a.Value = infoValue
		case lvl < logger.ErrorLevel:
			a.Value = warnValue
		case lvl < logger.FatalLevel:
			a.Value = errorValue
		case lvl >= logger.FatalLevel:
			a.Value = fatalValue
		default:
			a.Value = infoValue
		}
	}

	return a
}

type slogLogger struct {
	slog       *slog.Logger
	leveler    *slog.LevelVar
	levelKey   string
	messageKey string
	sourceKey  string
	timeKey    string
	opts       logger.Options
	mu         sync.RWMutex
}

func (s *slogLogger) Clone(opts ...logger.Option) logger.Logger {
	s.mu.RLock()
	options := s.opts

	for _, o := range opts {
		o(&options)
	}

	l := &slogLogger{
		opts:       options,
		levelKey:   s.levelKey,
		messageKey: s.messageKey,
		sourceKey:  s.sourceKey,
		timeKey:    s.timeKey,
	}

	if v, ok := l.opts.Context.Value(levelKey{}).(string); ok && v != "" {
		l.levelKey = v
	}
	if v, ok := l.opts.Context.Value(messageKey{}).(string); ok && v != "" {
		l.messageKey = v
	}
	if v, ok := l.opts.Context.Value(sourceKey{}).(string); ok && v != "" {
		l.sourceKey = v
	}
	if v, ok := l.opts.Context.Value(timeKey{}).(string); ok && v != "" {
		l.timeKey = v
	}

	l.leveler = new(slog.LevelVar)
	handleOpt := &slog.HandlerOptions{
		ReplaceAttr: s.renameAttr,
		Level:       l.leveler,
		AddSource:   true,
	}
	l.leveler.Set(loggerToSlogLevel(l.opts.Level))
	handler := slog.NewJSONHandler(options.Out, handleOpt)
	l.slog = slog.New(handler).With(options.Fields...)

	s.mu.RUnlock()

	return l
}

func (s *slogLogger) V(level logger.Level) bool {
	return s.opts.Level.Enabled(level)
}

func (s *slogLogger) Level(level logger.Level) {
	s.leveler.Set(loggerToSlogLevel(level))
}

func (s *slogLogger) Options() logger.Options {
	return s.opts
}

func (s *slogLogger) Fields(attrs ...interface{}) logger.Logger {
	s.mu.RLock()
	nl := &slogLogger{
		opts:       s.opts,
		levelKey:   s.levelKey,
		messageKey: s.messageKey,
		sourceKey:  s.sourceKey,
		timeKey:    s.timeKey,
	}
	nl.leveler = new(slog.LevelVar)
	nl.leveler.Set(s.leveler.Level())

	handleOpt := &slog.HandlerOptions{
		ReplaceAttr: nl.renameAttr,
		Level:       nl.leveler,
		AddSource:   true,
	}

	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
	nl.slog = slog.New(handler).With(attrs...)

	s.mu.RUnlock()

	return nl
}

func (s *slogLogger) Init(opts ...logger.Option) error {
	s.mu.Lock()
	for _, o := range opts {
		o(&s.opts)
	}

	if v, ok := s.opts.Context.Value(levelKey{}).(string); ok && v != "" {
		s.levelKey = v
	}
	if v, ok := s.opts.Context.Value(messageKey{}).(string); ok && v != "" {
		s.messageKey = v
	}
	if v, ok := s.opts.Context.Value(sourceKey{}).(string); ok && v != "" {
		s.sourceKey = v
	}
	if v, ok := s.opts.Context.Value(timeKey{}).(string); ok && v != "" {
		s.timeKey = v
	}

	s.leveler = new(slog.LevelVar)
	handleOpt := &slog.HandlerOptions{
		ReplaceAttr: s.renameAttr,
		Level:       s.leveler,
		AddSource:   true,
	}
	s.leveler.Set(loggerToSlogLevel(s.opts.Level))
	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
	s.slog = slog.New(handler).With(s.opts.Fields...)

	slog.SetDefault(s.slog)

	s.mu.Unlock()

	return nil
}

func (s *slogLogger) Log(ctx context.Context, lvl logger.Level, attrs ...interface{}) {
	if !s.V(lvl) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), loggerToSlogLevel(lvl), fmt.Sprintf("%s", attrs[0]), pcs[0])
	// r.Add(attrs[1:]...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Logf(ctx context.Context, lvl logger.Level, msg string, attrs ...interface{}) {
	if !s.V(lvl) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), loggerToSlogLevel(lvl), fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Info(ctx context.Context, attrs ...interface{}) {
	if !s.V(logger.InfoLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf("%s", attrs[0]), pcs[0])
	// r.Add(attrs[1:]...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Infof(ctx context.Context, msg string, attrs ...interface{}) {
	if !s.V(logger.InfoLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Debug(ctx context.Context, attrs ...interface{}) {
	if !s.V(logger.DebugLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelDebug, fmt.Sprintf("%s", attrs[0]), pcs[0])
	// r.Add(attrs[1:]...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Debugf(ctx context.Context, msg string, attrs ...interface{}) {
	if !s.V(logger.DebugLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelDebug, fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Trace(ctx context.Context, attrs ...interface{}) {
	if !s.V(logger.TraceLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelDebug-1, fmt.Sprintf("%s", attrs[0]), pcs[0])
	// r.Add(attrs[1:]...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Tracef(ctx context.Context, msg string, attrs ...interface{}) {
	if !s.V(logger.TraceLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelDebug-1, fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Error(ctx context.Context, attrs ...interface{}) {
	if !s.V(logger.ErrorLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelError, fmt.Sprintf("%s", attrs[0]), pcs[0])
	//	r.Add(attrs[1:]...)
	r.Attrs(func(a slog.Attr) bool {
		if a.Key == "error" {
			if span, ok := tracer.SpanFromContext(ctx); ok {
				span.SetStatus(tracer.SpanStatusError, a.Value.String())
				return false
			}
		}
		return true
	})
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Errorf(ctx context.Context, msg string, attrs ...interface{}) {
	if !s.V(logger.ErrorLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelError, fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	r.Attrs(func(a slog.Attr) bool {
		if a.Key == "error" {
			if span, ok := tracer.SpanFromContext(ctx); ok {
				span.SetStatus(tracer.SpanStatusError, a.Value.String())
				return false
			}
		}
		return true
	})
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Fatal(ctx context.Context, attrs ...interface{}) {
	if !s.V(logger.FatalLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelError+1, fmt.Sprintf("%s", attrs[0]), pcs[0])
	// r.Add(attrs[1:]...)
	_ = s.slog.Handler().Handle(ctx, r)
	os.Exit(1)
}

func (s *slogLogger) Fatalf(ctx context.Context, msg string, attrs ...interface{}) {
	if !s.V(logger.FatalLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelError+1, fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	_ = s.slog.Handler().Handle(ctx, r)
	os.Exit(1)
}

func (s *slogLogger) Warn(ctx context.Context, attrs ...interface{}) {
	if !s.V(logger.WarnLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelWarn, fmt.Sprintf("%s", attrs[0]), pcs[0])
	// r.Add(attrs[1:]...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Warnf(ctx context.Context, msg string, attrs ...interface{}) {
	if !s.V(logger.WarnLevel) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelWarn, fmt.Sprintf(msg, attrs...), pcs[0])
	// r.Add(attrs...)
	_ = s.slog.Handler().Handle(ctx, r)
}

func (s *slogLogger) Name() string {
	return s.opts.Name
}

func (s *slogLogger) String() string {
	return "slog"
}

func NewLogger(opts ...logger.Option) logger.Logger {
	s := &slogLogger{
		opts:       logger.NewOptions(opts...),
		sourceKey:  DefaultSourceKey,
		timeKey:    DefaultTimeKey,
		messageKey: DefaultMessageKey,
		levelKey:   DefaultLevelKey,
	}
	if v, ok := s.opts.Context.Value(levelKey{}).(string); ok && v != "" {
		s.levelKey = v
	}
	if v, ok := s.opts.Context.Value(messageKey{}).(string); ok && v != "" {
		s.messageKey = v
	}
	if v, ok := s.opts.Context.Value(sourceKey{}).(string); ok && v != "" {
		s.sourceKey = v
	}
	if v, ok := s.opts.Context.Value(timeKey{}).(string); ok && v != "" {
		s.timeKey = v
	}
	return s
}

func loggerToSlogLevel(level logger.Level) slog.Level {
	switch level {
	case logger.DebugLevel:
		return slog.LevelDebug
	case logger.WarnLevel:
		return slog.LevelWarn
	case logger.ErrorLevel:
		return slog.LevelError
	case logger.TraceLevel:
		return slog.LevelDebug - 1
	case logger.FatalLevel:
		return slog.LevelError + 1
	default:
		return slog.LevelInfo
	}
}

func slogToLoggerLevel(level slog.Level) logger.Level {
	switch level {
	case slog.LevelDebug:
		return logger.DebugLevel
	case slog.LevelWarn:
		return logger.WarnLevel
	case slog.LevelError:
		return logger.ErrorLevel
	case slog.LevelDebug - 1:
		return logger.TraceLevel
	case slog.LevelError + 1:
		return logger.FatalLevel
	default:
		return logger.InfoLevel
	}
}