package engine

import "testing"

func TestInheritanceEvidenceUsesOrderedPayloadAndConcreteTransferShapes(t *testing.T) {
	t.Parallel()

	controlPath := Keys("child", inheritanceKey)
	transfer := inheritanceTransfer{
		from: Keys("parent"), to: Keys("child"), reference: Keys("parent"),
		locations: []Location{{SourceID: "directive"}},
	}
	parent := parseDocumentForDecode(t, "id: parent\nbranch: {deep: {leaf: inherited}}\n")
	effective := parseDocumentForDecode(t, "id: child\nbranch: replaced\n")
	root := parseDocumentForDecode(t, "parent: {unused: true}\nchild: {id: child, extends: parent, branch: {local: stale}}\n")
	parentOrigins := map[string]Origin{
		Keys("parent", "branch").String():                 {Layer: LayerMain, Locations: []Location{{SourceID: "parent"}}},
		Keys("parent", "branch", "deep").String():         {Layer: LayerMain, Locations: []Location{{SourceID: "parent"}}},
		Keys("parent", "branch", "deep", "leaf").String(): {Layer: LayerMain, Locations: []Location{{SourceID: "parent"}}},
	}
	effectiveOrigins := map[string]Origin{
		Keys("child", "branch").String(): {Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}},
	}
	childOrigins := map[string]Origin{
		Keys("child", "id").String():              {Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}},
		Keys("child", "branch").String():          {Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}},
		Keys("child", "branch", "local").String(): {Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}},
	}
	operation := inheritanceOperation{
		transfer: &transfer, parent: parent, effective: effective,
		parentOrigins: parentOrigins, effectiveOrigins: effectiveOrigins,
		childOrigins: childOrigins, identityFields: []string{"id"},
	}
	controlOrigin := Origin{Layer: LayerOverlay, Locations: []Location{{SourceID: "directive"}}}
	controlOperation := inheritanceOperation{
		control: &inheritanceControl{path: controlPath}, controlOrigin: controlOrigin,
	}
	builder := newHistoryBuilder()
	builder.setScratch(root)
	builder.observeInheritanceEvidence([]inheritanceOperation{controlOperation, operation})
	model := builder.freeze()

	if len(model.inheritancePayloads) != 1 || len(model.inheritancePayloads[0].operations) != 2 {
		t.Fatalf("ordered inheritance payload = %#v", model.inheritancePayloads)
	}
	controlSelections := model.selectHistory(controlPath)
	if len(controlSelections) != 1 || controlSelections[0].role != historyRoleControl || !controlSelections[0].before || controlSelections[0].after ||
		!controlSelections[0].hasAttribution || len(controlSelections[0].attribution.dependencies) != 1 || controlSelections[0].attribution.dependencies[0].String() != controlPath.String() {
		t.Fatalf("consumed control selection = %#v", controlSelections)
	}

	inheritedPath := Keys("child", "branch", "deep", "leaf")
	inherited := model.selectHistory(inheritedPath)
	if len(inherited) != 2 || inherited[0].phase != historyPhaseInheritance || inherited[0].payload.id != 0 || inherited[0].payload.substep != 2 ||
		inherited[0].before || !inherited[0].after || !inherited[0].hasAttribution || inherited[0].attribution.origin.Locations[0].SourceID != "parent" ||
		len(inherited[0].attribution.dependencies) != 2 || inherited[1].payload.substep != 3 || !inherited[1].before || inherited[1].after {
		t.Fatalf("parent transfer selection = %#v", inherited)
	}

	displacedPath := Keys("child", "branch", "local")
	displaced := model.selectHistory(displacedPath)
	if len(displaced) != 1 || displaced[0].payload.substep != 2 || !displaced[0].before || displaced[0].after ||
		displaced[0].attribution.origin.Locations[0].SourceID != "child" {
		t.Fatalf("pre-transfer child shape was not retained: %#v", displaced)
	}
	if builder.scratch != nil {
		t.Fatal("frozen builder unexpectedly retained scratch")
	}
	if identity := model.selectHistory(Keys("child", "id")); len(identity) != 0 {
		t.Fatalf("child identity received inheritance evidence: %#v", identity)
	}
}

func TestInheritanceModelSharesProjectionAttribution(t *testing.T) {
	t.Parallel()

	from, to, reference := Keys("parents", "base"), Keys("children", "item"), Keys("parents", "base")
	path := to.Key("nested").Key("value")
	parent := Origin{Layer: LayerMain, Locations: []Location{{SourceID: "base"}}}
	child := Origin{Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}}
	parentDocument := parseDocumentForDecode(t, "nested: {value: parent}\n")
	effectiveDocument := parseDocumentForDecode(t, "nested: {value: child}\n")
	operation := inheritanceOperation{
		transfer:         &inheritanceTransfer{from: from, to: to, reference: reference},
		parent:           parentDocument,
		effective:        effectiveDocument,
		parentOrigins:    map[string]Origin{from.Key("nested").Key("value").String(): parent},
		effectiveOrigins: map[string]Origin{path.String(): child},
	}
	root := parseDocumentForDecode(t, "children: {item: {nested: {value: old}}}\n")
	builder := newHistoryBuilder()
	builder.setScratch(root)
	builder.observeInheritanceEvidence([]inheritanceOperation{operation})
	model := builder.freeze()
	selections := model.selectHistory(path)
	if len(selections) != 2 || selections[0].role != historyRoleOperation || selections[1].role != historyRoleOperation {
		t.Fatalf("model inheritance selections = %#v", selections)
	}
	if selections[0].reportedPath.String() != to.String() || selections[1].reportedPath.String() != to.String() ||
		selections[0].attribution.origin.Operation != ChangeInheritance || selections[1].attribution.origin.Operation != ChangeInheritance {
		t.Fatalf("parent and child attributions did not share the model owner: %#v", selections)
	}
	if selections[0].attribution.origin.Locations[0].SourceID != "base" ||
		selections[1].attribution.origin.Locations[0].SourceID != "child" ||
		len(selections[0].attribution.dependencies) != 2 || selections[0].attribution.dependencies[0].String() != from.String() ||
		selections[0].attribution.dependencies[1].String() != reference.String() ||
		len(selections[1].attribution.dependencies) != 1 || selections[1].attribution.dependencies[0].String() != reference.String() {
		t.Fatalf("model attribution dependencies or origins differ: %#v", selections)
	}
}

func TestInheritanceEvidenceSeparatesCollidingKeyAndIndexShapes(t *testing.T) {
	t.Parallel()

	from, to := Keys("parent"), Keys("child")
	transfer := inheritanceTransfer{from: from, to: to, reference: from}
	parent := parseDocumentForDecode(t, "items: [{value: inherited}]\n")
	effective := parseDocumentForDecode(t, "items: {'0': {value: child}}\n")
	root := parseDocumentForDecode(t, "child: {items: {'0': {value: old}}}\n")
	parentPath := from.Key("items").Index(0).Key("value")
	childPath := to.Key("items").Key("0").Key("value")
	operation := inheritanceOperation{
		transfer: &transfer, parent: parent, effective: effective,
		parentOrigins:    map[string]Origin{parentPath.String(): {Layer: LayerMain, Locations: []Location{{SourceID: "parent"}}}},
		effectiveOrigins: map[string]Origin{childPath.String(): {Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}}},
		childOrigins:     map[string]Origin{childPath.String(): {Layer: LayerOverlay, Locations: []Location{{SourceID: "child"}}}},
	}
	builder := newHistoryBuilder()
	builder.setScratch(root)
	builder.observeInheritanceEvidence([]inheritanceOperation{operation})
	model := builder.freeze()

	keyPath := to.Key("items").Key("0").Key("value")
	keySelections := model.selectHistory(keyPath)
	if len(keySelections) != 2 || keySelections[0].payload.substep != 0 || !keySelections[0].before || keySelections[0].after ||
		keySelections[0].attribution.origin.Locations[0].SourceID != "child" || keySelections[1].payload.substep != 1 ||
		keySelections[1].before || !keySelections[1].after || keySelections[1].attribution.origin.Locations[0].SourceID != "child" {
		t.Fatalf("mapping-key inheritance selections = %#v", keySelections)
	}

	indexPath := to.Key("items").Index(0).Key("value")
	indexSelections := model.selectHistory(indexPath)
	if len(indexSelections) != 2 || indexSelections[0].payload.substep != 0 || indexSelections[0].before || !indexSelections[0].after ||
		indexSelections[0].attribution.origin.Locations[0].SourceID != "parent" || indexSelections[1].payload.substep != 1 ||
		!indexSelections[1].before || indexSelections[1].after {
		t.Fatalf("sequence-index inheritance selections = %#v", indexSelections)
	}
}