package engine

import (
	"errors"
	"strings"
	"testing"
	"testing/fstest"
)

func TestCompileSequencePolicyNormalizesRegistrations(t *testing.T) {
	parsed, err := ParsePath("/items/0/a~1b")
	if err != nil {
		t.Fatal(err)
	}

	tests := []struct {
		name          string
		registrations []sequenceRegistration
		want          map[string]string
		wantError     bool
	}{
		{
			name: "identical registrations coalesce",
			registrations: []sequenceRegistration{
				{path: Keys("items"), identityField: "id"},
				{path: Keys("items"), identityField: "id"},
			},
			want: map[string]string{"/items": "id"},
		},
		{
			name: "different identity fields conflict",
			registrations: []sequenceRegistration{
				{path: Keys("items"), identityField: "id"},
				{path: Keys("items"), identityField: "name"},
			},
			wantError: true,
		},
		{
			name:          "empty identity field is literal",
			registrations: []sequenceRegistration{{path: Keys("items"), identityField: ""}},
			want:          map[string]string{"/items": ""},
		},
		{
			name:          "numeric and escaped tokens remain literal keys",
			registrations: []sequenceRegistration{{path: parsed, identityField: "id"}},
			want:          map[string]string{"/items/0/a~1b": "id"},
		},
		{
			name:          "explicit index is invalid",
			registrations: []sequenceRegistration{{path: Keys("items").Index(0), identityField: "id"}},
			wantError:     true,
		},
		{
			name: "unused and root registrations are accepted",
			registrations: []sequenceRegistration{
				{path: Path{}, identityField: "id"},
				{path: Keys("unused"), identityField: "name"},
			},
			want: map[string]string{"": "id", "/unused": "name"},
		},
		{name: "zero option policy", want: map[string]string{}},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			policy, diagnostics := compileSequencePolicy(test.registrations)
			if (len(diagnostics) != 0) != test.wantError {
				t.Fatalf("diagnostics = %#v, wantError = %t", diagnostics, test.wantError)
			}
			if test.wantError {
				if diagnostics[0].Code != CodeOptionsInvalid {
					t.Fatalf("diagnostic code = %q", diagnostics[0].Code)
				}
				return
			}
			if len(policy.identityFields) != len(test.want) {
				t.Fatalf("compiled fields = %#v, want %#v", policy.identityFields, test.want)
			}
			for path, field := range test.want {
				if got := policy.identityFields[path]; got != field {
					t.Errorf("identity field at %q = %q, want %q", path, got, field)
				}
			}
		})
	}
}

func TestSequenceRegistrationPreflightDoesNotReadSources(t *testing.T) {
	t.Parallel()
	type config struct {
		Value string `yaml:"value"`
	}

	ordinaryReader := strings.NewReader("value: ordinary\n")
	_, err := Load[config](Reader("ordinary.yml", ordinaryReader), SecretBinding{}, Options[config]{
		Definition: Definition[config]{sequenceRegistrations: []sequenceRegistration{{path: Keys("items").Index(0), identityField: "id"}}},
	})
	requireSequenceRegistrationOptionError(t, err)
	if ordinaryReader.Len() == 0 {
		t.Fatal("ordinary reader was consumed before invalid registration was rejected")
	}

	mainReader := strings.NewReader("value: main\n")
	underlayReader := strings.NewReader("value: underlay\n")
	_, err = LoadLayered[config](Input{Source: Reader("main.yml", mainReader)}, SecretBinding{}, LayeredOptions[config]{
		Definition: Definition[config]{sequenceRegistrations: []sequenceRegistration{{path: Keys("items").Index(0), identityField: "id"}}},
		Underlays:  []Underlay{{Inputs: []Input{{Source: Reader("underlay.yml", underlayReader)}}}},
	})
	requireSequenceRegistrationOptionError(t, err)
	if mainReader.Len() == 0 || underlayReader.Len() == 0 {
		t.Fatal("layered source was consumed before invalid registration was rejected")
	}
}

func requireSequenceRegistrationOptionError(t *testing.T, err error) {
	t.Helper()
	if err == nil {
		t.Fatal("expected invalid sequence registration error")
	}
	var loadErr *LoadError
	if !errors.As(err, &loadErr) {
		t.Fatalf("error type = %T, want *LoadError", err)
	}
	diagnostics := loadErr.Diagnostics()
	if len(diagnostics) != 1 || diagnostics[0].Code != CodeOptionsInvalid {
		t.Fatalf("diagnostics = %#v, want one options diagnostic", diagnostics)
	}
}

func TestRegisteredSequencePolicyAcrossLoadingLifecycle(t *testing.T) {
	t.Parallel()
	type item struct {
		ID string `yaml:"id"`
	}
	type config struct {
		Items []item `yaml:"items"`
	}
	definition := Definition[config]{sequenceRegistrations: []sequenceRegistration{{path: Keys("items"), identityField: "id"}}}
	registered := Options[config]{Definition: definition}
	loadCode := func(t *testing.T, err error) Code {
		t.Helper()
		var loadErr *LoadError
		if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) == 0 {
			t.Fatalf("error = %v, want a diagnostic load error", err)
		}
		return loadErr.Diagnostics()[0].Code
	}

	t.Run("ordinary authored list is checked with one source", func(t *testing.T) {
		if _, err := testLoad[config](Bytes("main", []byte("items: [{id: same}, {id: same}]\n")), registered); err == nil || loadCode(t, err) != CodeComposeConflict {
			t.Fatalf("duplicate identity error = %v", err)
		}
		result, err := testLoad[config](Bytes("main", []byte("items: [{id: one}]\n")), registered)
		if err != nil || len(result.Config.Items) != 1 || result.Config.Items[0].ID != "one" {
			t.Fatalf("single-source load = %#v, %v", result, err)
		}
	})

	t.Run("ordinary imports retain registered composition", func(t *testing.T) {
		directory := t.TempDir()
		mainPath := writeImportFile(t, directory, "main.yml", "configkit: {imports: [{path: fragment.yml}]}\nitems: [{id: authored}]\n")
		writeImportFile(t, directory, "fragment.yml", "items: [{id: imported}]\n")
		result, err := testLoad[config](File(mainPath), Options[config]{Imports: true, Definition: definition})
		if err != nil || len(result.Config.Items) != 2 || result.Config.Items[0].ID != "imported" || result.Config.Items[1].ID != "authored" {
			t.Fatalf("registered imported list = %#v, %v", result, err)
		}
	})

	t.Run("strict underlay group appends while separate tiers reset identities", func(t *testing.T) {
		request := loadRequest[config]{
			main: loadInput{source: Bytes("main", []byte("items: [{id: shared}]\n"))},
			underlays: []loadGroup{{inputs: []loadInput{
				{source: Bytes("first", []byte("items: [{id: lower}]\n"))},
				{source: Bytes("second", []byte("items: [{id: other}]\n"))},
			}}},
			definition: definition, sequencePolicy: mustCompileSequencePolicy(t, definition.sequenceRegistrations),
		}
		result, err := testGroupedLoad(request)
		if err != nil || len(result.Config.Items) != 1 || result.Config.Items[0].ID != "shared" {
			t.Fatalf("grouped load = %#v, %v", result, err)
		}

		request.underlays = []loadGroup{{inputs: []loadInput{
			{source: Bytes("first", []byte("items: [{id: shared}]\n"))},
			{source: Bytes("second", []byte("items: [{id: lower}]\n"))},
		}}}
		request.main.source = Bytes("main", []byte("items: [{id: shared}]\n"))
		if _, err := testGroupedLoad(request); err != nil {
			t.Fatalf("same identity in a separate tier: %v", err)
		}
	})

	t.Run("empty registered contribution clears lower sequence", func(t *testing.T) {
		result, err := testLoad[config](Bytes("main", []byte("items: []\n")), registered)
		if err != nil || len(result.Config.Items) != 0 {
			t.Fatalf("empty sequence load = %#v, %v", result, err)
		}
		request := loadRequest[config]{
			main:       loadInput{source: Bytes("main", []byte("items: []\n"))},
			underlays:  []loadGroup{{inputs: []loadInput{{source: Bytes("lower", []byte("items: [{id: lower}]\n"))}}}},
			definition: definition, sequencePolicy: mustCompileSequencePolicy(t, definition.sequenceRegistrations),
		}
		result, err = testGroupedLoad(request)
		if err != nil || len(result.Config.Items) != 0 {
			t.Fatalf("empty higher tier = %#v, %v", result, err)
		}
	})

	t.Run("unregistered list overlap remains atomic", func(t *testing.T) {
		request := loadRequest[config]{
			main: loadInput{source: Bytes("main", []byte("items: [{id: main}]\n"))},
			underlays: []loadGroup{{inputs: []loadInput{
				{source: Bytes("first", []byte("items: [{id: lower}]\n"))},
				{source: Bytes("second", []byte("items: [{id: other}]\n"))},
			}}},
		}
		_, err := testGroupedLoad(request)
		if got := loadCode(t, err); got != CodeComposeConflict {
			t.Fatalf("unregistered overlap error = %s", got)
		}
	})

	t.Run("malformed lower tier fails before precedence replacement", func(t *testing.T) {
		request := loadRequest[config]{
			main:       loadInput{source: Bytes("main", []byte("items: [{id: main}]\n"))},
			underlays:  []loadGroup{{inputs: []loadInput{{source: Bytes("lower", []byte("items: [{id: same}, {id: same}]\n"))}}}},
			definition: definition, sequencePolicy: mustCompileSequencePolicy(t, definition.sequenceRegistrations),
		}
		if got := loadCode(t, func() error { _, err := testGroupedLoad(request); return err }()); got != CodeComposeConflict {
			t.Fatalf("hidden lower-tier error = %s", got)
		}

		overlayFilesystem := NewFilesystem("overlay", fstest.MapFS{
			"overlays/testing.yml": &fstest.MapFile{Data: []byte("items: [{id: overlay}]\n")},
		})
		request.overlay = "testing"
		request.overlayFilesystem = &FilesystemContext{Root: ".", BaseDir: ".", FS: &overlayFilesystem}
		if got := loadCode(t, func() error { _, err := testGroupedLoad(request); return err }()); got != CodeComposeConflict {
			t.Fatalf("selected replacement overlay hid lower-tier error: %s", got)
		}
	})

	t.Run("replacement overlay and CLI may introduce duplicates", func(t *testing.T) {
		directory := t.TempDir()
		mainPath := writeImportFile(t, directory, "main.yml", "items: [{id: base}]\n")
		writeImportFile(t, directory, "overlays/testing.yml", "items: [{id: duplicate}, {id: duplicate}]\n")
		result, err := testLoad[config](File(mainPath), Options[config]{Definition: definition, Overlay: "testing"})
		if err != nil {
			t.Fatalf("replacement overlay error code = %s", loadCode(t, err))
		}
		if len(result.Config.Items) != 2 {
			t.Fatalf("replacement overlay = %#v, %v", result, err)
		}

		result, err = testLoad[config](Bytes("main", []byte("items: [{id: base}]\n")), Options[config]{
			Definition: definition,
			Overrides:  []Override{{Path: Keys("items"), Flag: "--items", Value: []any{map[string]any{"id": "duplicate"}, map[string]any{"id": "duplicate"}}}},
		})
		if err != nil || len(result.Config.Items) != 2 {
			t.Fatalf("replacement CLI value = %#v, %v", result, err)
		}

		resolved := definition
		resolved.Resolve = func(value *config, resolution *Resolution) error {
			value.Items[1].ID = value.Items[0].ID
			resolution.Record(Keys("items"), ChangeNormalization, "registered identities collide")
			return nil
		}
		result, err = testLoad[config](Bytes("main", []byte("items: [{id: first}, {id: second}]\n")), Options[config]{Definition: resolved})
		if err != nil {
			t.Fatalf("resolver replacement error code = %s", loadCode(t, err))
		}
		if len(result.Config.Items) != 2 {
			t.Fatalf("resolver replacement = %#v, %v", result, err)
		}
	})

	t.Run("application validation can reject replacement duplicates", func(t *testing.T) {
		checked := definition
		checked.Validate = func(value *config, validation *Validation) {
			seen := make(map[string]bool)
			for index, entry := range value.Items {
				if seen[entry.ID] {
					validation.Error(Keys("items").Index(index).Key("id"), "identity must be unique")
				}
				seen[entry.ID] = true
			}
		}
		_, err := testLoad[config](Bytes("main", []byte("items: [{id: base}]\n")), Options[config]{
			Definition: checked,
			Overrides:  []Override{{Path: Keys("items"), Flag: "--items", Value: []any{map[string]any{"id": "duplicate"}, map[string]any{"id": "duplicate"}}}},
		})
		if got := loadCode(t, err); got != CodeValidateError {
			t.Fatalf("application validation error = %s", got)
		}
	})
}

func mustCompileSequencePolicy(t *testing.T, registrations []sequenceRegistration) sequencePolicy {
	t.Helper()
	policy, diagnostics := compileSequencePolicy(registrations)
	if len(diagnostics) != 0 {
		t.Fatal(diagnostics)
	}
	return policy
}