package wglog

import "golang.zx2c4.com/wireguard/device"

// Async will call the underlying logger methods in a goroutine.
// If a field in logger is nil, it will not spawn a goroutine.
func Async(logger *device.Logger) *device.Logger {
        return &device.Logger{
                Verbosef: async(logger.Verbosef),
                Errorf:   async(logger.Errorf),
        }
}

func async(fn FmtFn) (r func(string, ...any)) {
        if fn == nil {
                return noopFn
        }
        return func(s string, a ...any) { go fn(s, a...) }
}

package wglog

import "golang.zx2c4.com/wireguard/device"

// FmtFn is a function capable of outputting a printf style string.
type FmtFn func(string, ...any)

// Multi will emit a logged message on all given loggers.
func Multi(loggers ...*device.Logger) *device.Logger {
        verbosef, errorf := collectFns(loggers)
        return &device.Logger{Verbosef: multi(verbosef), Errorf: multi(errorf)}
}

func collectFns(loggers []*device.Logger) (verbosef, errorf []FmtFn) {
        for _, l := range loggers {
                verbosef = append(verbosef, elseDefault(l.Verbosef, noopFn))
                errorf = append(errorf, elseDefault(l.Errorf, noopFn))
        }
        return
}

func multi(fns []FmtFn) func(string, ...any) {
        return func(s string, a ...any) {
                for _, fn := range fns {
                        fn(s, a...)
                }
        }
}

package wglog

import (
        "golang.zx2c4.com/wireguard/device"
)

var noopFn FmtFn = func(string, ...any) {}

// Noop is a logger that does not output anything.
// The logger and both of its funcs are not nil.
func Noop() *device.Logger {
        return &device.Logger{
                Verbosef: noopFn,
                Errorf:   noopFn,
        }
}

package wglog

import (
        "fmt"
        "golang.zx2c4.com/wireguard/device"
        "log/slog"
        "reflect"
        "slices"
)

// Slog creates a [device.Logger] instance that is backed by a specified [slog.Logger].
// No args are passed to the slog logger, instead the message is created from the format string and args passed to the [device.Logger].Verbosef and [device.Logger].Errorf funcs.
// Verbose messages are logged at the Debug level, while errors are logged at the Error level.
func Slog(logger *slog.Logger) *device.Logger {
        logger = elseDefault(logger, slog.Default())
        return &device.Logger{
                Verbosef: func(format string, args ...any) { logger.Debug(fmt.Sprintf(format, args...)) },
                Errorf:   func(format string, args ...any) { logger.Error(fmt.Sprintf(format, args...)) },
        }
}

// validNil is a set of [reflect.Kind] that will not panic on [reflect.Value.IsNil] if [reflect.Value] is valid.
var validNil = []reflect.Kind{reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice}

func elseDefault[T any](v, def T) T {
        if vv := reflect.ValueOf(v); slices.Contains(validNil, vv.Kind()) && (vv.IsZero() || vv.IsNil()) {
                return def
        }
        return v
}