module.go

package config

import (
	"log"
	"reflect"

	"github.com/joho/godotenv"
	"github.com/tinh-tinh/tinhtinh/v2/core"
)

const ENV core.Provide = "ConfigEnv"

type Options[E any] struct {
	EnvPath       string
	IgnoreEnvFile bool
	// Only for env file
	Load func() *E
}

type Param[V any] interface {
	string | Options[V]
}

func ForRoot[E any, param Param[E]](params ...param) core.Modules {
	return func(module core.Module) core.Module {
		var lastValue *E
		var err error

		if len(params) == 0 {
			lastValue, err = New[E]("")
			if err != nil {
				log.Println("env not found")
			}
		} else {
			var envArrs []E
			for _, v := range params {
				if reflect.TypeOf(v).Kind() == reflect.String {
					val, err := New[E](any(v).(string))
					if err != nil {
						continue
					}
					envArrs = append(envArrs, *val)
				} else if reflect.TypeOf(v).Kind() == reflect.Struct {
					opt := any(v).(Options[E])
					err = godotenv.Load(opt.EnvPath)
					if err != nil {
						continue
					}
					val := opt.Load()
					envArrs = append(envArrs, *val)
				}
			}
			if len(envArrs) > 0 {
				value := mergeStruct(envArrs...)
				lastValue = &value
			}
		}

		configModule := module.New(core.NewModuleOptions{})

		if lastValue == nil {
			log.Println("env not found")
			return configModule
		}

		configModule.NewProvider(core.ProviderOptions{
			Name:  ENV,
			Value: lastValue,
		})
		configModule.Export(ENV)

		return configModule
	}
}

func Inject[E any](module core.RefProvider) *E {
	cfg, ok := module.Ref(ENV).(*E)
	if !ok {
		return nil
	}
	return cfg
}

func mergeStruct[T any](input ...T) T {
	var result T
	resultVal := reflect.ValueOf(&result).Elem()

	for _, item := range input {
		inputVal := reflect.ValueOf(item)
		mergeRecursive(resultVal, inputVal)
	}

	return result
}

func mergeRecursive(target, source reflect.Value) {
	for i := 0; i < target.NumField(); i++ {
		tField := target.Field(i)
		sField := source.Field(i)

		// Handle exported fields only
		if !tField.CanSet() {
			continue
		}

		if tField.Kind() == reflect.Struct {
			mergeRecursive(tField, sField)
		} else {
			if !sField.IsZero() {
				tField.Set(sField)
			}
		}
	}
}