package configkit_test

import (
	"testing"
	"testing/fstest"

	configkit "gitea.maximumdirect.net/eric/ConfigKit"
)

func TestFacadeItemDomainVersionsKeepEffectiveScope(t *testing.T) {
	for _, test := range []struct {
		name, item, child, helper string
		underlay, mainItem        bool
	}{
		{name: "item", item: "id: item\nversion: domain\n"},
		{name: "helper", item: "id: item\nconfigkit: {imports: [{path: helper.yml}]}\n", helper: "version: domain\n"},
		{name: "nested", item: "id: parent\nconfigkit: {imports: [{path: child.yml, destination: [children], placement: sequence-item}]}\n", child: "id: child\nversion: domain\n"},
		{name: "underlay", item: "id: item\nversion: domain\n", underlay: true},
		{name: "main-item", item: "id: parent\nconfigkit: {imports: [{path: child.yml, destination: [children], placement: sequence-item}]}\n", child: "id: child\nversion: domain\n", mainItem: true},
	} {
		t.Run(test.name, func(t *testing.T) {
			files := fstest.MapFS{
				"main.yml":     {Data: []byte("version: 1\nconfigkit: {imports: [{path: item.yml, destination: [items], placement: sequence-item}]}\n")},
				"item.yml":     {Data: []byte(test.item)},
				"child.yml":    {Data: []byte(test.child)},
				"helper.yml":   {Data: []byte(test.helper)},
				"underlay.yml": {Data: []byte("configkit: {imports: [{path: item.yml, destination: [items], placement: sequence-item}]}\n")},
			}
			filesystem := configkit.NewFilesystem("items", files)
			definition := configkit.Definition[map[string]any]{Version: &configkit.VersionRule{
				Path: configkit.Keys("version"), Check: func(configkit.Version, *configkit.Validation) error { return nil },
			}}
			var result *configkit.Result[map[string]any]
			var err error
			switch {
			case test.underlay:
				result, err = configkit.LoadLayered(configkit.Input{Source: configkit.Mapping("main", map[string]any{"version": "1"})}, configkit.LayeredOptions[map[string]any]{
					Definition: definition, Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: filesystem.File("underlay.yml"), Imports: true}}}},
				})
			case test.mainItem:
				result, err = configkit.Load(filesystem.File("item.yml"), configkit.Options[map[string]any]{
					Imports: true, Destination: configkit.Keys("items"), PlacementMode: configkit.PlacementModeSequenceItem, Definition: definition,
				})
			default:
				result, err = configkit.Load(filesystem.File("main.yml"), configkit.Options[map[string]any]{Imports: true, Definition: definition})
			}
			if err != nil {
				t.Fatal(err)
			}
			item := result.Config["items"].([]any)[0].(map[string]any)
			fieldPath := configkit.Keys("items").Index(0).Key("version")
			if test.child != "" {
				item = item["children"].([]any)[0].(map[string]any)
				fieldPath = configkit.Keys("items").Index(0).Key("children").Index(0).Key("version")
			}
			if item["version"] != "domain" {
				t.Fatalf("domain version = %#v", item)
			}
			if info, ok := result.Metadata().Lookup(fieldPath); !ok || !info.Explicit {
				t.Fatalf("version metadata = %#v, %v", info, ok)
			}
		})
	}
}