package engine

import (
	"testing"

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

func TestPreparePairedDiffSnapshotReportsWhollyMaskedChanges(t *testing.T) {
	left := &document.Node{Kind: document.String, Text: "private-before"}
	right := &document.Node{Kind: document.String, Text: "private-after"}
	paired, supported := preparePairedDiffSnapshot(
		left, right, Keys("credential"), newDiffSensitivity(nil, map[string]bool{"/credential": true}),
	)
	if !supported || !paired.hiddenChanged || !paired.leftRedacted || !paired.rightRedacted {
		t.Fatalf("masked change = %#v, supported=%v", paired, supported)
	}
	assertDiffStringNode(t, paired.left, "[REDACTED]")
	assertDiffStringNode(t, paired.right, "[REDACTED]")
}

func TestPreparePairedDiffSnapshotDetectsRawChangesBehindIdenticalMarkers(t *testing.T) {
	left := parseCompositionDocument(t, "left", "token: old-canary\n")
	right := parseCompositionDocument(t, "right", "token: new-canary\n")
	paired, supported := preparePairedDiffSnapshot(
		mappingValue(t, left, "token"), mappingValue(t, right, "token"), Keys("token"),
		newDiffSensitivity(map[string]bool{"/token": true}, nil),
	)
	if !supported || !paired.hiddenChanged || paired.left.Text != paired.right.Text {
		t.Fatalf("identically rendered masked values lost raw change: %#v, supported=%v", paired, supported)
	}
}

func TestPreparePairedDiffSnapshotCombinesPublicAndHiddenChanges(t *testing.T) {
	left := parseCompositionDocument(t, "left", "public: before\ntoken: old\n")
	right := parseCompositionDocument(t, "right", "public: after\ntoken: new\n")
	paired, supported := preparePairedDiffSnapshot(
		left, right, Path{}, newDiffSensitivity(nil, map[string]bool{"/token": true}),
	)
	if !supported || !paired.hiddenChanged {
		t.Fatalf("mixed public and hidden change = %#v, supported=%v", paired, supported)
	}
	assertDiffStringNode(t, mappingValue(t, paired.left, "public"), "before")
	assertDiffStringNode(t, mappingValue(t, paired.right, "public"), "after")
	assertDiffStringNode(t, mappingValue(t, paired.left, "token"), "[REDACTED]")
	assertDiffStringNode(t, mappingValue(t, paired.right, "token"), "[REDACTED]")
}

func TestPreparePairedDiffSnapshotDoesNotFlagUnchangedMaskedValues(t *testing.T) {
	left := parseCompositionDocument(t, "left", "public: before\ntoken: unchanged\n")
	right := parseCompositionDocument(t, "right", "public: after\ntoken: unchanged\n")
	regions, err := prepareDiffRegions(diffTestInspection(left), diffTestInspection(right))
	if err != nil || len(regions) != 1 || regions[0].path.String() != "/public" {
		t.Fatalf("changed regions = %#v, err = %v; want only /public", regions, err)
	}
	paired, supported := preparePairedDiffSnapshot(
		left, right, Path{}, newDiffSensitivity(map[string]bool{"/token": true}, nil),
	)
	if !supported || !paired.leftRedacted || !paired.rightRedacted || paired.hiddenChanged {
		t.Fatalf("unchanged masked values affected hidden-change state: %#v, supported=%v", paired, supported)
	}

	leftSequence := parseCompositionDocument(t, "left-sequence", "items: [unchanged, before]\n")
	rightSequence := parseCompositionDocument(t, "right-sequence", "items: [unchanged, after]\n")
	sequence, supported := preparePairedDiffSnapshot(
		mappingValue(t, leftSequence, "items"), mappingValue(t, rightSequence, "items"), Keys("items"),
		newDiffSensitivity(nil, map[string]bool{"/items/0": true}),
	)
	if !supported || !sequence.leftRedacted || !sequence.rightRedacted || sequence.hiddenChanged {
		t.Fatalf("unchanged masked sequence member affected hidden-change state: %#v, supported=%v", sequence, supported)
	}
}

func TestPreparePairedDiffSnapshotReportsMaskedAdditionAndRemoval(t *testing.T) {
	value := &document.Node{Kind: document.String, Text: "private"}
	tests := []struct {
		name        string
		left, right *document.Node
		leftHidden  bool
		rightHidden bool
	}{
		{name: "addition", right: value, rightHidden: true},
		{name: "removal", left: value, leftHidden: true},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			paired, supported := preparePairedDiffSnapshot(
				test.left, test.right, Keys("token"), newDiffSensitivity(nil, map[string]bool{"/token": true}),
			)
			if !supported || !paired.hiddenChanged || paired.leftRedacted != test.leftHidden || paired.rightRedacted != test.rightHidden {
				t.Fatalf("masked presence change = %#v, supported=%v", paired, supported)
			}
			if test.left == nil && paired.left != nil || test.right == nil && paired.right != nil {
				t.Fatalf("absence became a value: %#v", paired)
			}
		})
	}
}

func TestPreparePairedDiffSnapshotReportsHiddenSequenceLengthChange(t *testing.T) {
	left := parseCompositionDocument(t, "left", "items: [public]\n")
	right := parseCompositionDocument(t, "right", "items: [public, private]\n")
	paired, supported := preparePairedDiffSnapshot(
		mappingValue(t, left, "items"), mappingValue(t, right, "items"), Keys("items"),
		newDiffSensitivity(nil, map[string]bool{"/items/1": true}),
	)
	if !supported || !paired.hiddenChanged || paired.leftRedacted || !paired.rightRedacted {
		t.Fatalf("masked sequence length change = %#v, supported=%v", paired, supported)
	}
	if len(paired.left.Sequence) != 1 || len(paired.right.Sequence) != 2 {
		t.Fatalf("safe sequence lengths = %d, %d; want 1, 2", len(paired.left.Sequence), len(paired.right.Sequence))
	}
	assertDiffStringNode(t, paired.right.Sequence[1], "[REDACTED]")
}

func TestPreparePairedDiffSnapshotClassificationAloneDoesNotCreateHiddenChange(t *testing.T) {
	left := parseCompositionDocument(t, "left", "token: same\n")
	right := parseCompositionDocument(t, "right", "token: same\n")
	regions, err := prepareDiffRegions(diffTestInspection(left), diffTestInspection(right))
	if err != nil || len(regions) != 0 {
		t.Fatalf("classification-independent changed regions = %#v, err = %v", regions, err)
	}
	paired, supported := preparePairedDiffSnapshot(
		mappingValue(t, left, "token"), mappingValue(t, right, "token"), Keys("token"),
		newDiffSensitivity(map[string]bool{"/token": true}, nil),
	)
	if !supported || !paired.leftRedacted || !paired.rightRedacted || paired.hiddenChanged {
		t.Fatalf("classification alone reported hidden change: %#v, supported=%v", paired, supported)
	}
}