options

func Merge[T any](cfgs ...T) T

{
	var result T
	resultVal := reflect.ValueOf(&result).Elem()
	resultType := resultVal.Type()

	for _, cfg := range cfgs {
		cfgVal := reflect.ValueOf(cfg)
		for i := 0; i < resultType.NumField(); i++ {
			resultVal.Field(i).Set(cfgVal.Field(i))
		}
	}
	return result
}

func MergeConfig[T any](semantics MergeWithSemantics, cfgs ...T) T

{
	var result T
	resultVal := reflect.ValueOf(&result).Elem()
	resultType := resultVal.Type()

	for _, cfg := range cfgs {
		cfgVal := reflect.ValueOf(cfg)
		for i := 0; i < resultType.NumField(); i++ {
			field := cfgVal.Field(i)
			switch semantics {
			case LastWins:
				resultVal.Field(i).Set(field)
			case SkipZero:
				if !field.IsZero() {
					resultVal.Field(i).Set(field)
				}
			}
		}
	}
	return result
}

func MustValidate[T any](cfg T)

{
	val := reflect.ValueOf(cfg)
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}
	typ := val.Type()

	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		if field.Tag.Get("required") == "true" {
			if val.Field(i).IsZero() {
				panic(fmt.Sprintf("options: required field %s is zero", field.Name))
			}
		}
	}
}

func TestMergeConfig_LastWins(t *testing.T)

{
	type Config struct {
		Debug bool
		Port  int
	}

	defaults := Config{Debug: true, Port: 8080}
	override := Config{Debug: false, Port: 0}

	result := MergeConfig(LastWins, defaults, override)
	if result.Debug != false {
		t.Errorf("Debug: got %v, want false", result.Debug)
	}
	if result.Port != 0 {
		t.Errorf("Port: got %d, want 0", result.Port)
	}
}

func TestMergeConfig_SkipZero(t *testing.T)

{
	type Config struct {
		Port  int
		Host  string
	}

	defaults := Config{Port: 8080, Host: "localhost"}
	override := Config{Port: 0, Host: "overridden"}

	result := MergeConfig(SkipZero, defaults, override)
	if result.Port != 8080 {
		t.Errorf("Port: got %d, want 8080 (zero should not overwrite)", result.Port)
	}
	if result.Host != "overridden" {
		t.Errorf("Host: got %q, want %q", result.Host, "overridden")
	}
}

func TestConfigure(t *testing.T)

{
	type AppOptions struct {
		Host string `config:"host" required:"true"`
		Port int    `config:"port"`
	}

	opts := Configure(AppOptions{Host: "localhost", Port: 8080})
	if opts.Value.Host != "localhost" {
		t.Errorf("Configure: got %q, want %q", opts.Value.Host, "localhost")
	}
}

func TestMustValidate(t *testing.T)

{
	type Config struct {
		Name string `required:"true"`
		Port int
	}

	t.Run("valid", func(t *testing.T) {
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("should not panic: %v", r)
			}
		}()
		MustValidate(Config{Name: "app"})
	})

	t.Run("missing required", func(t *testing.T) {
		defer func() {
			if r := recover(); r == nil {
				t.Error("should panic for missing required field")
			}
		}()
		MustValidate(Config{Name: ""})
	})
}

func TestApply(t *testing.T)

{
	cfg := &ServerConfig{Host: "localhost", Port: 8080}

	Apply(cfg, WithHost("0.0.0.0"), WithPort(9000))

	if cfg.Host != "0.0.0.0" {
		t.Errorf("Host: got %q, want %q", cfg.Host, "0.0.0.0")
	}
	if cfg.Port != 9000 {
		t.Errorf("Port: got %d, want %d", cfg.Port, 9000)
	}
}

func TestBuilder(t *testing.T)

{
	defaults := ServerConfig{Host: "localhost", Port: 8080, Timeout: 30}

	cfg := NewBuilder(defaults).
		With(WithHost("127.0.0.1")).
		With(WithTimeout(60)).
		Build()

	if cfg.Host != "127.0.0.1" {
		t.Errorf("Host: got %q, want %q", cfg.Host, "127.0.0.1")
	}
	if cfg.Port != 8080 {
		t.Errorf("Port should remain default: got %d, want %d", cfg.Port, 8080)
	}
	if cfg.Timeout != 60 {
		t.Errorf("Timeout: got %d, want %d", cfg.Timeout, 60)
	}
}

func TestBuilder_Ptr(t *testing.T)

{
	defaults := ServerConfig{Port: 3000}

	cfg := NewBuilder(defaults).
		With(WithHost("api.example.com")).
		Ptr()

	if cfg.Host != "api.example.com" {
		t.Errorf("Host: got %q, want %q", cfg.Host, "api.example.com")
	}
	if cfg.Port != 3000 {
		t.Errorf("Port: got %d, want %d", cfg.Port, 3000)
	}
}