ConfigKit/internal/engine/load_input.go

package engine

import (
	"strconv"

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

// assembledInput is the source/document handoff across schema and version checks.
type assembledInput struct {
	parsed      parsedSource
	document    *document.Node
	composition *composedDocument
	inheritance *inheritanceScope
	sources     []SourceInfo
	contexts    map[string]ResourceContext
}

func assembleBaseInput[T any](source Source, options Options[T]) (assembledInput, []Diagnostic) {
	return assembleBaseInputTracked(source, options, Path{}, &importAccounting{}, nil, nil)
}

func assembleBaseInputTracked[T any](source Source, options Options[T], destination Path, accounting *importAccounting, visited map[resourceIdentity]importRoute, hostToken *namespaceToken) (assembledInput, []Diagnostic) {
	limits := defaultImportLimits()
	parseLimits := defaultParseLimits()
	parseLimits.source.remaining = limits.bytes - accounting.bytes
	parsed, diagnostics := parseSource(source, "source-"+strconv.Itoa(accounting.sources+1), parseLimits)
	input := assembledInput{parsed: parsed, document: parsed.document}
	if len(diagnostics) != 0 {
		input.sources = sourceInfos(parsed.source)
		setSourceDestinations(input.sources, destination)
		return input, diagnostics
	}
	if options.Imports {
		input.composition, input.sources, diagnostics = loadImportedDocumentsTracked(source, options.Filesystem, parsed, destination, options.Definition.Version, limits, accounting, visited, hostToken)
		setSourceDestinations(input.sources, destination)
		if len(diagnostics) != 0 {
			return input, diagnostics
		}
		input.document = input.composition.root
	} else {
		input.sources = sourceInfos(parsed.source)
		setSourceDestinations(input.sources, destination)
		if options.Filesystem != nil && !activeOverlay(options.Overlay) {
			if diagnostic := validateFilesystemContext(source, options.Filesystem, parsed); diagnostic != nil {
				return input, []Diagnostic{*diagnostic}
			}
		}
	}
	if !options.Imports && input.document != nil {
		if diagnostics := disabledDirectiveDiagnostics(input.document, Path{}); len(diagnostics) != 0 {
			return input, diagnostics
		}
		_, placed, err := placeDocument(input.document, destination, input.document.Location, parseLimits.document.Depth, parseLimits.document.Nodes)
		if err != nil {
			return input, []Diagnostic{sourceDiagnostic(CodeSourceLimitExceeded, parsed.source.ID, "configuration exceeds the source depth or node limit after destination placement")}
		}
		input.document = placed
		if accounting.sources+1 > limits.sources || accounting.bytes+parsed.bytes > limits.bytes || accounting.nodes+countInputNodes(parsed.document) > limits.nodes {
			return input, []Diagnostic{sourceDiagnostic(CodeSourceLimitExceeded, parsed.source.ID, "configuration exceeds the aggregate input limit")}
		}
		if diagnostic := registerAcquiredSource(source, options.Filesystem, parsed.source, visited, hostToken); diagnostic != nil {
			return input, []Diagnostic{*diagnostic}
		}
		accounting.sources++
		accounting.bytes += parsed.bytes
		accounting.nodes += countInputNodes(parsed.document)
	}
	if !activeOverlay(options.Overlay) || options.Imports {
		contexts, diagnostic := contextsForAcquiredSources(source, options.Filesystem, parsed.source, input.sources)
		if diagnostic != nil {
			return input, []Diagnostic{*diagnostic}
		}
		input.contexts = contexts
	}
	return input, nil
}

func registerAcquiredSource(source Source, context *FilesystemContext, info *SourceInfo, visited map[resourceIdentity]importRoute, hostToken *namespaceToken) *Diagnostic {
	if visited == nil || info == nil || info.Path == "" {
		return nil
	}
	identity := resourceIdentity{namespace: hostToken, path: info.Path}
	if source.kind == sourceFilesystem {
		identity.namespace = source.namespace.token
	} else if context != nil && context.FS != nil {
		identity.namespace = context.FS.namespace.token
	}
	if previous, repeated := visited[identity]; repeated {
		value := importRepeatedDiagnostic(Location{SourceID: info.ID}, previous, importRoute{})
		return &value
	}
	visited[identity] = importRoute{canonical: info.Path}
	return nil
}

func applyInputLayers[T any](source Source, options Options[T], input assembledInput) (assembledInput, []Diagnostic) {
	if !activeOverlay(options.Overlay) && len(options.Overrides) == 0 {
		return input, nil
	}
	composition, diagnostics := compositionForInput(input)
	if len(diagnostics) != 0 {
		return input, diagnostics
	}
	assembly := newAssemblyAccumulator(composition)
	if activeOverlay(options.Overlay) {
		input.sources, diagnostics = loadSelectedOverlayInto(
			source, options.Filesystem, input.parsed, assembly, input.sources,
			options.Overlay, options.Definition.Version, defaultImportLimits(),
		)
		if len(diagnostics) != 0 {
			return input, diagnostics
		}
		contexts, diagnostic := contextsForAcquiredSources(source, options.Filesystem, input.parsed.source, input.sources[len(input.sources)-1:])
		if diagnostic != nil {
			return input, []Diagnostic{*diagnostic}
		}
		mergeResourceContexts(&input.contexts, contexts)
	}
	if len(options.Overrides) != 0 {
		input.sources, diagnostics = assembly.applyOverrides(
			input.sources, options.Overrides, options.Definition.Version, defaultImportLimits(),
		)
		if len(diagnostics) != 0 {
			return input, diagnostics
		}
	}
	input.composition = assembly.current
	input.document = assembly.current.root
	return input, nil
}

// compositionForInput initializes one handoff for overlays and CLI, including
// defaults-only CLI input. Raw source bytes and mapping keys retain their budgets.
func compositionForInput(input assembledInput) (*composedDocument, []Diagnostic) {
	if input.composition != nil {
		return input.composition, nil
	}
	if input.document == nil {
		return &composedDocument{root: &document.Node{Kind: document.Mapping}, origins: make(map[string]Origin)}, nil
	}
	composition, diagnostics := composeDocuments(input.document)
	if len(diagnostics) != 0 {
		return nil, diagnostics
	}
	composition.inputBytes = input.parsed.bytes
	composition.inputNodes = countInputNodes(input.document)
	return composition, nil
}