package engine

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

func appendInheritanceExplanation(explanation *Explanation, working **document.Node, query Path, operations []inheritanceOperation, secrets map[string]bool) {
	for _, operation := range operations {
		selectionPath := query
		if operation.transfer != nil {
			selectionPath = operationPathForQuery(operation.transfer.to, query)
		}
		selections := resolveInheritanceAttribution(operation, selectionPath)
		if operation.control != nil {
			control := selectInheritanceEvidence(selections, inheritanceEvidenceControl, inheritanceEvidenceControl)
			if control == nil || !pathsIntersect(operation.control.path, query) {
				continue
			}
			before := valueSnapshot(*working, query, secrets)
			replaceHistoryPath(working, operation.control.path, nil)
			after := valueSnapshot(*working, query, secrets)
			explanation.History = append(explanation.History, ValueChange{
				Before: before, After: after, Origin: cloneOrigin(control.origin),
				Dependencies: clonePaths(control.dependencies),
			})
			continue
		}
		if operation.transfer == nil {
			continue
		}
		before := valueSnapshot(*working, query, secrets)
		replaceHistoryPath(working, operation.transfer.to, operation.parent)
		// A record keeps its own identity throughout inheritance. Restore it
		// before taking enclosing snapshots as well as direct field snapshots.
		for _, field := range operation.identityFields {
			identity, _ := documentAtPath(operation.effective, Keys(field))
			replaceHistoryPath(working, operation.transfer.to.Key(field), identity)
		}
		afterParent := valueSnapshot(*working, query, secrets)
		parent := selectInheritanceEvidence(selections, inheritanceEvidenceParent, inheritanceEvidenceParent)
		if pathsIntersect(operation.transfer.to, query) && parent != nil {
			explanation.History = append(explanation.History, ValueChange{
				Before: before, After: afterParent, Origin: cloneOrigin(parent.origin),
				Dependencies: clonePaths(parent.dependencies),
			})
		}
		replaceHistoryPath(working, operation.transfer.to, operation.effective)
		if !pathsIntersect(operation.transfer.to, query) {
			continue
		}
		afterChild := valueSnapshot(*working, query, secrets)
		child := selectInheritanceEvidence(selections, inheritanceEvidenceChild, inheritanceEvidenceRemoval, inheritanceEvidenceDisplaced)
		if child != nil && (parent == nil || len(selections) > 1) {
			explanation.History = append(explanation.History, ValueChange{
				Before: afterParent, After: afterChild, Origin: cloneOrigin(child.origin),
				Dependencies: clonePaths(child.dependencies),
			})
		}
	}
}

func operationPathForQuery(root, query Path) Path {
	if pathContains(query, root) {
		return root
	}
	return query
}