package configkit

import (
	"slices"
	"strings"

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

func applyOverrides(base *composedDocument, sources []SourceInfo, overrides []Override, rule *VersionRule, limits importLimits) (*composedDocument, []SourceInfo, []Diagnostic) {
	if len(overrides) == 0 {
		return base, cloneSourceInfos(sources), nil
	}
	prepared, allSources, diagnostics := prepareOverrides(base, sources, overrides, rule, limits)
	if len(diagnostics) != 0 {
		return nil, allSources, diagnostics
	}
	result := cloneComposedDocument(base)
	for _, override := range prepared {
		applyPreparedOverride(result, override)
		result.inputBytes += override.bytes
		result.inputNodes += override.nodes
	}
	return result, allSources, nil
}

func applyPreparedOverride(result *composedDocument, override preparedOverride) {
	location := document.Location{SourceID: override.source.ID}
	mergeOverlayOrigin(result.origins, Path{}, location, LayerCLI)
	current := result.root
	currentPath := Path{}
	for index, segment := range override.path.segments {
		path := currentPath.Key(segment.key)
		position := documentEntryIndex(current.Mapping, segment.key)
		if index < len(override.path.segments)-1 {
			if position < 0 {
				child := &document.Node{Kind: document.Mapping, Location: location, Mapping: []document.Entry{}}
				current.Mapping = append(current.Mapping, document.Entry{Key: segment.key, KeyLocation: location, ValueLocation: location, Value: child})
				collectOverlayOrigins(result.origins, child, path, LayerCLI)
				current = child
			} else {
				current = current.Mapping[position].Value
				mergeOverlayOrigin(result.origins, path, location, LayerCLI)
			}
			currentPath = path
			continue
		}

		previous := cloneOrigin(result.origins[path.String()])
		var displaced []displacedDefinition
		if position < 0 {
			incoming := document.Clone(override.value)
			current.Mapping = append(current.Mapping, document.Entry{Key: segment.key, KeyLocation: location, ValueLocation: location, Value: incoming})
			collectOverlayOrigins(result.origins, incoming, path, LayerCLI)
		} else {
			existing := current.Mapping[position].Value
			displaced = affectedOverrideOrigins(existing, override.value, result.origins, path)
			if existing.Kind == document.Mapping && override.value.Kind == document.Mapping {
				mergeOverlayOrigin(result.origins, path, location, LayerCLI)
				mergeOverlayMappings(result, existing, override.value, path, LayerCLI, false)
			} else {
				deleteOriginSubtree(result.origins, path)
				current.Mapping[position] = document.Entry{Key: segment.key, KeyLocation: location, ValueLocation: location, Value: document.Clone(override.value)}
				collectOverlayOrigins(result.origins, current.Mapping[position].Value, path, LayerCLI)
			}
		}
		result.overlays = append(result.overlays, overlayRecord{change: Change{
			Path: path.clone(), Origin: overlayOrigin(LayerCLI, location), Previous: previousOrigins(previous),
		}, displaced: displaced})
		result.applications = append(result.applications, historyApplication{
			layer: LayerCLI, path: path.clone(), value: override.value,
			origin: overlayOrigin(LayerCLI, location),
		})
	}
}

func affectedOverrideOrigins(existing, incoming *document.Node, origins map[string]Origin, path Path) []displacedDefinition {
	displaced := []displacedDefinition{{path: path.clone(), origin: cloneOrigin(origins[path.String()])}}
	if existing.Kind == document.Mapping && incoming.Kind == document.Mapping {
		for _, entry := range incoming.Mapping {
			position := documentEntryIndex(existing.Mapping, entry.Key)
			if position < 0 {
				continue
			}
			childPath := path.Key(entry.Key)
			childExisting := existing.Mapping[position].Value
			if childExisting.Kind == document.Mapping && entry.Value.Kind == document.Mapping {
				displaced = append(displaced, affectedOverrideOrigins(childExisting, entry.Value, origins, childPath)...)
			} else {
				displaced = append(displaced, displacedOrigins(childExisting, origins, childPath)...)
			}
		}
	} else {
		displaced = displacedOrigins(existing, origins, path)
	}
	slices.SortFunc(displaced, func(left, right displacedDefinition) int {
		return strings.Compare(left.path.String(), right.path.String())
	})
	return displaced
}