nikoksr/konfetty

package konfetty

import (
    "errors"
    "reflect"
)

var (
    ErrCircularReference = errors.New("circular reference detected")
    ErrNilConfig         = errors.New("config cannot be nil")
    ErrNotPointer        = errors.New("config must be a pointer to a struct")
)

// applyDefaults is the entry point for applying default values to the loaded config.
func applyDefaults(config any, defaults map[reflect.Type][]any) error {
    v := reflect.ValueOf(config)

    if v.Kind() != reflect.Ptr {
        return ErrNotPointer
    }

    if v.IsNil() {
        return ErrNilConfig
    }

    visited := make(map[uintptr]bool)

    return applyDefaultsRecursive(v.Elem(), defaults, visited)
}

// applyDefaultsRecursive contains the core logic for applying default values to the config.
func applyDefaultsRecursive(v reflect.Value, defaults map[reflect.Type][]any, visited map[uintptr]bool) error {
    if err := checkCircularReference(v, visited); err != nil {
        return err
    }

    t := v.Type()

    if err := applyTypeDefaults(v, defaults[t]); err != nil {
        return err
    }

    //nolint:exhaustive // Only handling relevant types for config structures; other types don't need special processing
    switch t.Kind() {
    case reflect.Struct:
        return handleStruct(v, defaults, visited)
    case reflect.Slice:
        return handleSlice(v, defaults, visited)
    case reflect.Map:
        return handleMap(v, defaults, visited)
    case reflect.Ptr:
        return handlePointer(v, defaults, visited)
    case reflect.Interface:
        return handleInterface(v, defaults, visited)
    default:
        // Other kinds don't need special handling
    }

    return nil
}

func checkCircularReference(v reflect.Value, visited map[uintptr]bool) error {
    if v.Kind() == reflect.Ptr {
        ptr := v.Pointer()
        if visited[ptr] {
            return ErrCircularReference
        }
        visited[ptr] = true
    }

    return nil
}

func applyTypeDefaults(v reflect.Value, typeDefaults []any) error {
    for i := len(typeDefaults) - 1; i >= 0; i-- {
        if err := mergeDefault(v, reflect.ValueOf(typeDefaults[i])); err != nil {
            return err
        }
    }

    return nil
}

func handleStruct(v reflect.Value, defaults map[reflect.Type][]any, visited map[uintptr]bool) error {
    for i := range v.NumField() {
        if err := applyDefaultsRecursive(v.Field(i), defaults, visited); err != nil {
            return err
        }
    }

    return nil
}

func handleSlice(v reflect.Value, defaults map[reflect.Type][]any, visited map[uintptr]bool) error {
    for i := range v.Len() {
        elem := v.Index(i)
        if elem.Kind() == reflect.Interface && !elem.IsNil() {
            elem = elem.Elem()
        }

        newElem := reflect.New(elem.Type()).Elem()
        newElem.Set(elem)
        if err := applyDefaultsRecursive(newElem, defaults, visited); err != nil {
            return err
        }

        v.Index(i).Set(newElem)
    }

    return nil
}

func handleMap(v reflect.Value, defaults map[reflect.Type][]any, visited map[uintptr]bool) error {
    if v.IsNil() {
        v.Set(reflect.MakeMap(v.Type()))
    }

    for _, key := range v.MapKeys() {
        elem := v.MapIndex(key)
        if elem.Kind() == reflect.Interface && !elem.IsNil() {
            elem = elem.Elem()
        }

        newElem := reflect.New(elem.Type()).Elem()
        newElem.Set(elem)
        if err := applyDefaultsRecursive(newElem, defaults, visited); err != nil {
            return err
        }

        v.SetMapIndex(key, newElem)
    }

    return applyMapDefaults(v, defaults[v.Type()])
}

func applyMapDefaults(v reflect.Value, defaultValues []any) error {
    for _, dv := range defaultValues {
        defaultMap := reflect.ValueOf(dv)
        for _, key := range defaultMap.MapKeys() {
            if !v.MapIndex(key).IsValid() {
                v.SetMapIndex(key, defaultMap.MapIndex(key))
            }
        }
    }

    return nil
}

func handlePointer(v reflect.Value, defaults map[reflect.Type][]any, visited map[uintptr]bool) error {
    if !v.IsNil() {
        return applyDefaultsRecursive(v.Elem(), defaults, visited)
    }

    return nil
}

func handleInterface(v reflect.Value, defaults map[reflect.Type][]any, visited map[uintptr]bool) error {
    if !v.IsNil() {
        return applyDefaultsRecursive(v.Elem(), defaults, visited)
    }

    return nil
}

// mergeDefault applies default values from src to dst, but only for zero-value fields in dst.
func mergeDefault(dst, src reflect.Value) error {
    dst = dereference(dst)
    src = dereference(src)

    if src.Kind() != reflect.Struct || dst.Kind() != reflect.Struct {
        return nil
    }

    for i := range src.NumField() {
        if err := mergeField(dst.Field(i), src.Field(i), dst.Type().Field(i)); err != nil {
            return err
        }
    }

    return nil
}

func mergeField(dst, src reflect.Value, structField reflect.StructField) error {
    if !structField.IsExported() {
        return nil
    }

    if dst.IsZero() {
        return setField(dst, src)
    }

    //nolint:exhaustive // Only merging struct, ptr, and map fields; other types are handled by the default zero-value
    //                  // check
    switch src.Kind() {
    case reflect.Struct:
        return mergeDefault(dst, src)
    case reflect.Ptr:
        return mergePtrField(dst, src)
    case reflect.Map:
        return mergeMapField(dst, src)
    default:
        // Other kinds don't need special handling
    }

    return nil
}

func mergePtrField(dst, src reflect.Value) error {
    if src.IsNil() || src.Elem().Kind() != reflect.Struct {
        return nil
    }

    if dst.IsNil() {
        dst.Set(reflect.New(src.Elem().Type()))
    }

    return mergeDefault(dst.Elem(), src.Elem())
}

func mergeMapField(dst, src reflect.Value) error {
    if dst.IsNil() {
        return nil
    }

    for _, key := range src.MapKeys() {
        if !dst.MapIndex(key).IsValid() {
            dst.SetMapIndex(key, src.MapIndex(key))
        }
    }

    return nil
}

func dereference(v reflect.Value) reflect.Value {
    if v.Kind() == reflect.Ptr {
        return v.Elem()
    }

    return v
}

func setField(dst, src reflect.Value) error {
    if src.Kind() == reflect.Map && dst.IsNil() {
        dst.Set(reflect.MakeMap(src.Type()))
        for _, key := range src.MapKeys() {
            dst.SetMapIndex(key, src.MapIndex(key))
        }

        return nil
    }

    dst.Set(src)

    return nil
}