configuration

func TestConfigurationGetAndSection(t *testing.T)

{
	cfg, err := NewBuilder().
		Add(staticProvider{"db:host": "localhost", "db:port": "5432", "feature": "true"}).
		Build(context.Background())
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	if got, ok := cfg.GetString("DB:HOST"); !ok || got != "localhost" {
		t.Fatalf("GetString() = %q, %v", got, ok)
	}
	if got, ok := cfg.GetInt("db:port"); !ok || got != 5432 {
		t.Fatalf("GetInt() = %d, %v", got, ok)
	}
	if got, ok := cfg.GetBool("feature"); !ok || !got {
		t.Fatalf("GetBool() = %v, %v", got, ok)
	}

	section := cfg.GetSection("db")
	if got, ok := section.GetString("host"); !ok || got != "localhost" {
		t.Fatalf("section GetString() = %q, %v", got, ok)
	}
}

func TestConfigurationBind(t *testing.T)

{
	cfg, err := NewBuilder().
		Add(staticProvider{"db:host": "localhost", "port": "8080"}).
		Build(context.Background())
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	var out struct {
		Host    string `conf:"db:host"`
		Port    int
		Enabled bool `conf:"enabled" default:"true"`
	}
	if err := cfg.Bind(&out); err != nil {
		t.Fatalf("Bind() error = %v", err)
	}
	if out.Host != "localhost" || out.Port != 8080 || !out.Enabled {
		t.Fatalf("Bind() = %+v", out)
	}
}

func BindCollection[T any](c *Configuration, prefix string) (map[string]*T, error)

{
	names := c.CollectionKeys(prefix)
	items := make(map[string]*T, len(names))
	for _, name := range names {
		section := c
		if prefix != "" {
			section = c.GetSection(prefix + ":" + name)
		} else {
			section = c.GetSection(name)
		}
		item := new(T)
		if err := section.Bind(item); err != nil {
			return nil, fmt.Errorf("configuration: entry %q: %w", name, err)
		}
		items[name] = item
	}
	return items, nil
}

func ValidateCollection[T any](items map[string]*T, item ItemValidator[T], cross ...CrossValidator[T]) []string

{
	var problems []string

	if item != nil {
		names := make([]string, 0, len(items))
		for name := range items {
			names = append(names, name)
		}
		sort.Strings(names)
		for _, name := range names {
			for _, p := range item(name, items[name]) {
				problems = append(problems, fmt.Sprintf("%s: %s", name, p))
			}
		}
	}

	for _, cv := range cross {
		if cv != nil {
			problems = append(problems, cv(items)...)
		}
	}
	return problems
}

func TestBindCollectionBindsEachSection(t *testing.T)

{
	sites, err := BindCollection[siteConfig](collectionFixture(t), "")
	if err != nil {
		t.Fatal(err)
	}
	if len(sites) != 2 {
		t.Fatalf("got %d entries, want 2", len(sites))
	}
	if sites["a.example"].Domain != "a.example" || sites["a.example"].Port != 8080 {
		t.Errorf("unexpected a.example: %+v", sites["a.example"])
	}
	if sites["b.example"].Port != 9090 {
		t.Errorf("unexpected b.example: %+v", sites["b.example"])
	}
}

func TestBindCollectionWithPrefix(t *testing.T)

{
	c := New()
	c.data["sites:a:port"] = "8080"
	c.data["other:b:port"] = "1"

	sites, err := BindCollection[siteConfig](c, "sites")
	if err != nil {
		t.Fatal(err)
	}
	if len(sites) != 1 || sites["a"].Port != 8080 {
		t.Fatalf("unexpected result: %+v", sites)
	}
}

func TestCollectionKeysSortedAndTopLevelOnly(t *testing.T)

{
	c := New()
	c.data["z.example:ssl:enabled"] = "true"
	c.data["a.example:port"] = "1"
	c.data["m.example:port"] = "2"

	keys := c.CollectionKeys("")
	want := []string{"a.example", "m.example", "z.example"}
	if strings.Join(keys, ",") != strings.Join(want, ",") {
		t.Fatalf("got %v, want %v", keys, want)
	}
}

func TestValidateCollectionAggregatesItemAndCrossProblems(t *testing.T)

{
	sites, err := BindCollection[siteConfig](collectionFixture(t), "")
	if err != nil {
		t.Fatal(err)
	}

	item := func(name string, s *siteConfig) []string {
		if s.Domain == "" {
			return []string{"domain is required"}
		}
		return nil
	}
	cross := func(items map[string]*siteConfig) []string {
		seen := map[int]string{}
		var out []string
		for name, s := range items {
			if prev, dup := seen[s.Port]; dup {
				out = append(out, "port conflict between "+prev+" and "+name)
			}
			seen[s.Port] = name
		}
		return out
	}

	if problems := ValidateCollection(sites, item, cross); len(problems) != 0 {
		t.Fatalf("unexpected problems: %v", problems)
	}

	sites["b.example"].Port = sites["a.example"].Port
	sites["b.example"].Domain = ""
	problems := ValidateCollection(sites, item, cross)
	if len(problems) != 2 {
		t.Fatalf("got %v, want 2 problems", problems)
	}
	if !strings.HasPrefix(problems[0], "b.example: ") {
		t.Errorf("item problem not prefixed with entry name: %q", problems[0])
	}
}

func setField(field reflect.Value, valStr string) error

{
	switch field.Kind() {
	case reflect.String:
		field.SetString(valStr)
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		n, err := strconv.ParseInt(valStr, 10, 64)
		if err != nil {
			return err
		}
		field.SetInt(n)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		n, err := strconv.ParseUint(valStr, 10, 64)
		if err != nil {
			return err
		}
		field.SetUint(n)
	case reflect.Bool:
		b, err := strconv.ParseBool(valStr)
		if err != nil {
			return err
		}
		field.SetBool(b)
	case reflect.Float32, reflect.Float64:
		n, err := strconv.ParseFloat(valStr, 64)
		if err != nil {
			return err
		}
		field.SetFloat(n)
	default:
		return fmt.Errorf("unsupported type %s", field.Kind())
	}
	return nil
}