package engine

import (
	"fmt"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
)

func TestOverlayBroadCollectionPoliciesAndRetainedDeclarations(t *testing.T) {
	var baseBody, overlayBody strings.Builder
	basePolicies := collectionPolicyScope{}
	var declarations []sequenceDeclarationSpec
	for index := range 64 {
		name := fmt.Sprintf("group/%03d~", index)
		fmt.Fprintf(&baseBody, "%s: {items: [{id: base}], retained: [{id: retained}], scalar: pending}\n", name)
		fmt.Fprintf(&overlayBody, "%s: {items: [{id: overlay}], added: true}\n", name)
		basePolicies.set(Keys(name, "items"), collectionPolicy{
			identityFields: []string{"id"}, identityPresent: true,
			explicitMode: sequenceModeAppend, explicitModePresent: true,
		})
		for _, key := range []string{"retained", "missing", "scalar"} {
			declarations = append(declarations, sequenceDeclarationSpec{
				destination: Keys(name, key), identityFields: []string{"id"}, identityPresent: true,
				mode: sequenceModeAppend, modePresent: true,
			})
		}
	}
	base, diagnostics := composeDocuments(parseCompositionDocument(t, "base", baseBody.String()))
	if len(diagnostics) != 0 {
		t.Fatal(diagnostics)
	}
	base.collectionPolicies = basePolicies
	assembly := newAssemblyAccumulator(base)
	overlay := parseCompositionDocument(t, "overlay", overlayBody.String())
	diagnostics = assembly.applyOverlayWithCollectionPolicy(overlay, nil, collectionPolicyScope{}, nil, LayerOverlay, sequencePolicy{}, declarations)
	if len(diagnostics) != 0 {
		t.Fatal(diagnostics)
	}
	lookup := buildDocumentLookup(assembly.current.root)
	for index := range 64 {
		name := fmt.Sprintf("group/%03d~", index)
		items, found := documentAtPathWithLookup(assembly.current.root, Keys(name, "items"), lookup)
		if !found || items.Kind != document.Sequence || len(items.Sequence) != 2 || items.Sequence[0].Mapping[0].Value.Text != "base" || items.Sequence[1].Mapping[0].Value.Text != "overlay" {
			t.Fatalf("collection %s did not append in order", name)
		}
		for _, key := range []string{"retained", "missing", "scalar"} {
			policy, found := assembly.current.collectionPolicies.at(Keys(name, key))
			if !found || !policy.identityPresent || !policy.explicitModePresent || policy.explicitMode != sequenceModeAppend {
				t.Fatalf("retained/pending declaration lost at %s/%s", name, key)
			}
		}
		if _, found := documentAtPathWithLookup(assembly.current.root, Keys(name, "missing"), lookup); found {
			t.Fatal("pending declaration created a value")
		}
		if origin := assembly.current.origins[Keys(name, "items").Index(1).Key("id").String()]; origin.Layer != LayerOverlay {
			t.Fatal("appended item lost overlay attribution")
		}
	}
}

func TestInheritanceBroadCollectionsInOneDefinition(t *testing.T) {
	var body strings.Builder
	policies := collectionPolicyScope{}
	for _, definition := range []string{"base", "child"} {
		fmt.Fprintf(&body, "%s:\n", definition)
		if definition == "child" {
			body.WriteString("  extends: base\n")
		}
		for index := range 64 {
			name := fmt.Sprintf("group/%03d~", index)
			fmt.Fprintf(&body, "  %s: {items: [{id: %s}]}\n", name, definition)
			policy := collectionPolicy{identityFields: []string{"id"}, identityPresent: true}
			if definition == "child" {
				policy.explicitMode, policy.explicitModePresent = sequenceModeAppend, true
			}
			policies.set(Keys(definition, name, "items"), policy)
			policies.set(Keys(definition, name, "pending"), collectionPolicy{identityFields: []string{"id"}, identityPresent: true})
		}
	}
	root := parseCompositionDocument(t, "wide-collections", body.String())
	result, diagnostics := expandInheritanceWithPolicies(root, nil, policies, defaultProjectionLimits())
	if len(diagnostics) != 0 {
		t.Fatal(diagnostics)
	}
	lookup := buildDocumentLookup(result.root)
	for index := range 64 {
		name := fmt.Sprintf("group/%03d~", index)
		items, found := documentAtPathWithLookup(result.root, Keys("child", name, "items"), lookup)
		if !found || len(items.Sequence) != 2 || items.Sequence[0].Mapping[0].Value.Text != "base" || items.Sequence[1].Mapping[0].Value.Text != "child" {
			t.Fatalf("inherited collection %s did not append in order", name)
		}
		if policy, found := result.collectionPolicies.at(Keys("child", name, "pending")); !found || !policy.identityPresent {
			t.Fatalf("pending inherited policy lost at %s", name)
		}
	}
}