package main

import (
	"context"
	"encoding/json"
	"errors"
	"reflect"
	"sync"
	"testing"
	"time"

	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	dynamicfake "k8s.io/client-go/dynamic/fake"
	k8stesting "k8s.io/client-go/testing"
)

func TestContinuousCreatesBuildWithOpaqueTargets(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{"refs/heads/main": revision}}
	now := time.Date(2026, time.August, 20, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	object.Object["spec"].(map[string]any)["source"].(map[string]any)["repository"] = "https://forge.quorate.internal/quorate/cluster"
	targets := []any{map[string]any{
		"kind":       "Git",
		"repository": "https://git.quorate.dev/ms2k/quorate",
		"ref":        "refs/heads/master",
		"options":    map[string]any{"force": true},
	}}
	object.Object["spec"].(map[string]any)["targets"] = targets
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	build, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(
		ctx,
		workflowName("build", string(object.GetUID()), "continuous", revision),
		metav1.GetOptions{},
	)
	if err != nil {
		t.Fatal(err)
	}
	if workflowHasParameter(t, build, "input-plan") {
		t.Fatal("controller supplied input-plan")
	}
	if mutex := workflowMutex(t, build); mutex != "nuthatch-delivery" {
		t.Fatalf("Workflow mutex = %q", mutex)
	}
	var passedTargets []any
	if err := json.Unmarshal([]byte(workflowParameter(t, build, "targets")), &passedTargets); err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(passedTargets, targets) {
		t.Fatalf("targets = %#v", passedTargets)
	}
}

func TestDuplicateTargetsAreRejected(t *testing.T) {
	object := continuousDelivery()
	target := map[string]any{"kind": "QuayOCI", "repository": "quorate/nuthatch"}
	object.Object["spec"].(map[string]any)["targets"] = []any{target, target}
	instance := testController(t, object, &mutableRefs{}, new(time.Time))

	err := instance.reconcile(context.Background(), object)
	if err == nil || err.Error() != "duplicate target at index 1" {
		t.Fatalf("reconcile error = %v", err)
	}
}

func TestWorkflowMutexIsScopedByTemplateReference(t *testing.T) {
	now := time.Date(2026, time.August, 25, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	instance := testController(t, object, &mutableRefs{}, &now)
	delivery, err := decodeProjectDelivery(object)
	if err != nil {
		t.Fatal(err)
	}
	ctx := context.Background()
	for _, item := range []struct {
		name     string
		template string
	}{
		{name: "first", template: "shared-delivery"},
		{name: "second", template: "shared-delivery"},
		{name: "third", template: "other-delivery"},
	} {
		if err := instance.ensureWorkflow(ctx, &delivery, item.name, item.template, "build", map[string]string{}, nil); err != nil {
			t.Fatal(err)
		}
		workflow, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(ctx, item.name, metav1.GetOptions{})
		if err != nil {
			t.Fatal(err)
		}
		if mutex := workflowMutex(t, workflow); mutex != item.template {
			t.Fatalf("Workflow %q mutex = %q", item.name, mutex)
		}
	}
}

func TestPointCreatesBuildWithoutReadingRefs(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 20, 0, 0, 0, 0, time.UTC)
	object := pointDelivery(revision)
	instance := testController(t, object, refs, &now)

	instance.reconcileAll(context.Background())

	if refs.calls != 0 {
		t.Fatalf("Forgejo ref reads = %d", refs.calls)
	}
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

type mutableRefs struct {
	values     map[string]string
	identities map[string]string
	calls      int
	pathCalls  int
}

func (source *mutableRefs) PathIdentity(_ context.Context, _ string, revision string, _ []string) (string, error) {
	source.pathCalls++
	if value, found := source.identities[revision]; found {
		return value, nil
	}
	return revision, nil
}

func (source *mutableRefs) Refs(context.Context, string) (map[string]string, error) {
	source.calls++
	result := make(map[string]string, len(source.values))
	for name, revision := range source.values {
		result[name] = revision
	}
	return result, nil
}

func TestPointDeliveryConsumesRevisionsWithoutReadingRefs(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 20, 0, 0, 0, 0, time.UTC)
	object := pointDelivery(first)
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	if refs.calls != 0 {
		t.Fatalf("Forgejo ref reads = %d", refs.calls)
	}
	firstBuild := workflowName("build", string(object.GetUID()), "", first)
	build, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(ctx, firstBuild, metav1.GetOptions{})
	if err != nil {
		t.Fatal(err)
	}
	if value := workflowParameter(t, build, "source-ref"); value != "" {
		t.Fatalf("source-ref = %q", value)
	}
	if value := workflowParameter(t, build, "source-revision"); value != first {
		t.Fatalf("source-revision = %q", value)
	}

	delivery := getDelivery(t, instance, "point")
	if err := unstructured.SetNestedStringSlice(delivery.Object, []string{second}, "spec", "source", "point", "revisions"); err != nil {
		t.Fatal(err)
	}
	if _, err := instance.client.Resource(projectDeliveryGVR).Namespace("delivery").Update(ctx, delivery, metav1.UpdateOptions{}); err != nil {
		t.Fatal(err)
	}
	setNamedWorkflowStatus(t, instance, firstBuild, "Succeeded", map[string]string{
		"delivery-result": `{"digest":"sha256:first"}`,
	})
	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)

	secondBuild := workflowName("build", string(object.GetUID()), "", second)
	setNamedWorkflowStatus(t, instance, secondBuild, "Failed", nil)
	instance.reconcileAll(ctx)

	if refs.calls != 0 {
		t.Fatalf("Forgejo ref reads = %d", refs.calls)
	}
	if countWorkflows(t, instance, "build") != 2 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	delivery = getDelivery(t, instance, "point")
	points, found, err := unstructured.NestedSlice(delivery.Object, "status", "points")
	if err != nil || !found {
		t.Fatalf("read point status: found=%t error=%v", found, err)
	}
	if len(points) != 2 {
		t.Fatalf("point status count = %d", len(points))
	}
	firstStatus := points[0].(map[string]any)
	secondStatus := points[1].(map[string]any)
	if firstStatus["revision"] != first || firstStatus["phase"] != "Succeeded" {
		t.Fatalf("first point status = %#v", firstStatus)
	}
	if secondStatus["revision"] != second || secondStatus["phase"] != "Failed" {
		t.Fatalf("second point status = %#v", secondStatus)
	}
}

func TestPointDeliveryCreatesOneBuildWithTwoReconcilers(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 20, 0, 0, 0, 0, time.UTC)
	object := pointDelivery(revision)
	instance := testController(t, object, refs, &now)
	peer := *instance
	firstObject := getDelivery(t, instance, "point")
	secondObject := firstObject.DeepCopy()

	errors := make(chan error, 2)
	var reconcilers sync.WaitGroup
	reconcilers.Add(2)
	for index, reconciler := range []*controller{instance, &peer} {
		object := []*unstructured.Unstructured{firstObject, secondObject}[index]
		go func() {
			defer reconcilers.Done()
			errors <- reconciler.reconcile(context.Background(), object)
		}()
	}
	reconcilers.Wait()
	close(errors)
	for err := range errors {
		if err != nil {
			t.Fatal(err)
		}
	}

	if refs.calls != 0 {
		t.Fatalf("Forgejo ref reads = %d", refs.calls)
	}
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	delivery := getDelivery(t, instance, "point")
	points, found, err := unstructured.NestedSlice(delivery.Object, "status", "points")
	if err != nil || !found || len(points) != 1 {
		t.Fatalf("point status: count=%d found=%t error=%v", len(points), found, err)
	}
}

func TestContinuousDeliveryDebouncesAndDoesNotRetrigger(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{"refs/heads/main": revision}}
	now := time.Date(2026, time.August, 17, 0, 0, 0, 0, time.UTC)
	instance := testController(t, continuousDelivery(), refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	setWorkflowStatus(t, instance, "build", "Succeeded", map[string]string{"delivery-result": `{"digest":"sha256:abc"}`})
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	delivery := getDelivery(t, instance, "continuous")
	phase, _, _ := unstructured.NestedString(delivery.Object, "status", "continuous", "attempt", "phase")
	if phase != "Succeeded" {
		t.Fatalf("attempt phase = %q", phase)
	}
}

func TestContinuousDeliveryUsesConfiguredDebounce(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	refs := &mutableRefs{values: map[string]string{"refs/heads/main": first}}
	now := time.Date(2026, time.August, 17, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	if err := unstructured.SetNestedField(object.Object, "2m", "spec", "source", "continuous", "debounce"); err != nil {
		t.Fatal(err)
	}
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	now = now.Add(119 * time.Second)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 0 {
		t.Fatal("build Workflow created before configured debounce elapsed")
	}

	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	now = now.Add(time.Second)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 0 {
		t.Fatal("build Workflow created without restarting configured debounce")
	}

	now = now.Add(119 * time.Second)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

func TestPathFilteredDebounceIgnoresUnrelatedCommits(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	refs := &mutableRefs{
		values:     map[string]string{"refs/heads/main": first},
		identities: map[string]string{first: "sha256:selected", second: "sha256:selected"},
	}
	now := time.Date(2026, time.August, 21, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	if err := unstructured.SetNestedField(object.Object, "2m", "spec", "source", "continuous", "debounce"); err != nil {
		t.Fatal(err)
	}
	if err := unstructured.SetNestedStringSlice(object.Object, []string{"packages/fsharp-runner"}, "spec", "source", "continuous", "paths"); err != nil {
		t.Fatal(err)
	}
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(119 * time.Second)
	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 0 {
		t.Fatal("build created before filtered debounce elapsed")
	}
	now = now.Add(time.Second)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	build, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(
		ctx,
		workflowName("build", string(object.GetUID()), "continuous", refs.identities[second]),
		metav1.GetOptions{},
	)
	if err != nil {
		t.Fatal(err)
	}
	if workflowParameter(t, build, "source-revision") != second {
		t.Fatal("build did not advance to the latest unrelated commit")
	}
}

func TestPathFilteredDebounceRestartsForSelectedChanges(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	refs := &mutableRefs{
		values:     map[string]string{"refs/heads/main": first},
		identities: map[string]string{first: "sha256:first", second: "sha256:second"},
	}
	now := time.Date(2026, time.August, 21, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	if err := unstructured.SetNestedField(object.Object, "2m", "spec", "source", "continuous", "debounce"); err != nil {
		t.Fatal(err)
	}
	if err := unstructured.SetNestedStringSlice(object.Object, []string{"packages/fsharp-runner"}, "spec", "source", "continuous", "paths"); err != nil {
		t.Fatal(err)
	}
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(119 * time.Second)
	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	now = now.Add(119 * time.Second)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 0 {
		t.Fatal("build created before restarted filtered debounce elapsed")
	}
	now = now.Add(time.Second)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

func TestPathFilteredDeliveryUsesSuccessfulBaseline(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	third := "fedcba9876543210fedcba9876543210fedcba98"
	refs := &mutableRefs{
		values: map[string]string{"refs/heads/main": first},
		identities: map[string]string{
			first:  "sha256:first",
			second: "sha256:first",
			third:  "sha256:third",
		},
	}
	now := time.Date(2026, time.August, 21, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	if err := unstructured.SetNestedField(object.Object, "1m", "spec", "source", "continuous", "debounce"); err != nil {
		t.Fatal(err)
	}
	if err := unstructured.SetNestedStringSlice(object.Object, []string{"packages/fsharp-runner"}, "spec", "source", "continuous", "paths"); err != nil {
		t.Fatal(err)
	}
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	setWorkflowStatus(t, instance, "build", "Succeeded", nil)
	instance.reconcileAll(ctx)

	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatal("unrelated commit created another build")
	}
	delivery := getDelivery(t, instance, "continuous")
	delivered, found, err := unstructured.NestedMap(delivery.Object, "status", "continuous", "delivered")
	if err != nil || !found || delivered["revision"] != first || delivered["identity"] != "sha256:first" {
		t.Fatalf("delivered baseline = %#v, found=%t, error=%v", delivered, found, err)
	}

	refs.values["refs/heads/main"] = third
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 2 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

func TestPathFilteredFailureDoesNotAdvanceBaseline(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	third := "fedcba9876543210fedcba9876543210fedcba98"
	fourth := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	refs := &mutableRefs{
		values: map[string]string{"refs/heads/main": first},
		identities: map[string]string{
			first:  "sha256:first",
			second: "sha256:second",
			third:  "sha256:second",
			fourth: "sha256:fourth",
		},
	}
	now := time.Date(2026, time.August, 21, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	if err := unstructured.SetNestedField(object.Object, "1m", "spec", "source", "continuous", "debounce"); err != nil {
		t.Fatal(err)
	}
	if err := unstructured.SetNestedStringSlice(object.Object, []string{"packages/fsharp-runner"}, "spec", "source", "continuous", "paths"); err != nil {
		t.Fatal(err)
	}
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	setWorkflowStatus(t, instance, "build", "Succeeded", nil)
	instance.reconcileAll(ctx)

	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	setNamedWorkflowStatus(
		t,
		instance,
		workflowName("build", string(object.GetUID()), "continuous", refs.identities[second]),
		"Failed",
		nil,
	)
	instance.reconcileAll(ctx)

	refs.values["refs/heads/main"] = third
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 2 {
		t.Fatal("same failed filtered identity was retried")
	}
	delivery := getDelivery(t, instance, "continuous")
	delivered, _, _ := unstructured.NestedMap(delivery.Object, "status", "continuous", "delivered")
	if delivered["identity"] != "sha256:first" {
		t.Fatalf("delivered baseline = %#v", delivered)
	}

	refs.values["refs/heads/main"] = fourth
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 3 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

func TestPathFilteredRevertCancelsCandidate(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	third := "fedcba9876543210fedcba9876543210fedcba98"
	refs := &mutableRefs{
		values: map[string]string{"refs/heads/main": first},
		identities: map[string]string{
			first:  "sha256:first",
			second: "sha256:second",
			third:  "sha256:first",
		},
	}
	now := time.Date(2026, time.August, 21, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	if err := unstructured.SetNestedField(object.Object, "1m", "spec", "source", "continuous", "debounce"); err != nil {
		t.Fatal(err)
	}
	if err := unstructured.SetNestedStringSlice(object.Object, []string{"packages/fsharp-runner"}, "spec", "source", "continuous", "paths"); err != nil {
		t.Fatal(err)
	}
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	setWorkflowStatus(t, instance, "build", "Succeeded", nil)
	instance.reconcileAll(ctx)

	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	refs.values["refs/heads/main"] = third
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 1 {
		t.Fatal("reverted filtered candidate created a build")
	}
	delivery := getDelivery(t, instance, "continuous")
	candidate, _, _ := unstructured.NestedString(delivery.Object, "status", "continuous", "candidateIdentity")
	if candidate != "" {
		t.Fatalf("candidate identity = %q", candidate)
	}
}

func TestContinuousDeliveryCoalescesUpdatesWhileBuildIsActive(t *testing.T) {
	first := "0123456789abcdef0123456789abcdef01234567"
	second := "89abcdef0123456789abcdef0123456789abcdef"
	third := "fedcba9876543210fedcba9876543210fedcba98"
	refs := &mutableRefs{values: map[string]string{"refs/heads/main": first}}
	now := time.Date(2026, time.August, 17, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)

	refs.values["refs/heads/main"] = second
	instance.reconcileAll(ctx)
	refs.values["refs/heads/main"] = third
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build count while first build active = %d", countWorkflows(t, instance, "build"))
	}

	setWorkflowStatus(t, instance, "build", "Succeeded", nil)
	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 2 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	if _, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(
		ctx,
		workflowName("build", string(object.GetUID()), "continuous", second),
		metav1.GetOptions{},
	); !apierrors.IsNotFound(err) {
		t.Fatal("intermediate revision received a build workflow")
	}
}

func TestDeletionCreatesNoWorkflow(t *testing.T) {
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 17, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	deletion := metav1.NewTime(now)
	object.SetDeletionTimestamp(&deletion)
	instance := testController(t, object, refs, &now)

	instance.reconcileAll(context.Background())
	if countWorkflows(t, instance, "build") != 0 {
		t.Fatal("deletion created a build Workflow")
	}
}

func TestContinuousRetryAfterWorkflowGC(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{"refs/heads/main": revision}}
	now := time.Date(2026, time.August, 24, 0, 0, 0, 0, time.UTC)
	object := continuousDelivery()
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	now = now.Add(time.Minute)
	instance.reconcileAll(ctx)
	first := workflowName("build", string(object.GetUID()), "continuous", revision)
	setNamedWorkflowStatus(t, instance, first, "Failed", nil)
	instance.reconcileAll(ctx)
	if err := instance.client.Resource(workflowGVR).Namespace("delivery").Delete(ctx, first, metav1.DeleteOptions{}); err != nil {
		t.Fatal(err)
	}
	setRetry(t, instance, "continuous", first)
	instance.reconcileAll(ctx)

	if countWorkflows(t, instance, "build") != 1 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
	delivery := getDelivery(t, instance, "continuous")
	handled, _, _ := unstructured.NestedString(delivery.Object, "status", "lastHandledRetry")
	if handled != first {
		t.Fatalf("last handled retry = %q", handled)
	}
	successor := workflowName("build", string(object.GetUID()), "continuous", revision, first)
	workflow, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(ctx, successor, metav1.GetOptions{})
	if err != nil {
		t.Fatal(err)
	}
	if workflowHasParameter(t, workflow, "input-plan") {
		t.Fatal("retry supplied input-plan")
	}
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatal("acknowledged retry created another successor")
	}
}

func TestPointRetryReplaysSucceededAttempt(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 24, 0, 0, 0, 0, time.UTC)
	object := pointDelivery(revision)
	instance := testController(t, object, refs, &now)
	ctx := context.Background()

	instance.reconcileAll(ctx)
	first := workflowName("build", string(object.GetUID()), "", revision)
	setNamedWorkflowStatus(t, instance, first, "Running", nil)
	instance.reconcileAll(ctx)
	setRetry(t, instance, "point", first)
	instance.reconcileAll(ctx)
	if countWorkflows(t, instance, "build") != 1 {
		t.Fatal("active attempt received a retry")
	}
	delivery := getDelivery(t, instance, "point")
	handled, _, _ := unstructured.NestedString(delivery.Object, "status", "lastHandledRetry")
	if handled != "" {
		t.Fatalf("active retry was acknowledged as %q", handled)
	}
	setNamedWorkflowStatus(t, instance, first, "Succeeded", nil)
	instance.reconcileAll(ctx)
	instance.reconcileAll(ctx)

	delivery = getDelivery(t, instance, "point")
	points, _, _ := unstructured.NestedSlice(delivery.Object, "status", "points")
	if len(points) != 2 {
		t.Fatalf("point status count = %d", len(points))
	}
	successor := points[1].(map[string]any)
	if successor["revision"] != revision {
		t.Fatalf("retry status = %#v", successor)
	}
	if countWorkflows(t, instance, "build") != 2 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

func TestRetryCreatesOneSuccessorWithTwoReconcilers(t *testing.T) {
	revision := "0123456789abcdef0123456789abcdef01234567"
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 24, 0, 0, 0, 0, time.UTC)
	object := pointDelivery(revision)
	instance := testController(t, object, refs, &now)
	peer := *instance
	ctx := context.Background()

	instance.reconcileAll(ctx)
	first := workflowName("build", string(object.GetUID()), "", revision)
	setNamedWorkflowStatus(t, instance, first, "Failed", nil)
	instance.reconcileAll(ctx)
	setRetry(t, instance, "point", first)

	errors := make(chan error, 2)
	var reconcilers sync.WaitGroup
	for _, reconciler := range []*controller{instance, &peer} {
		reconcilers.Add(1)
		go func() {
			defer reconcilers.Done()
			errors <- reconciler.reconcileKey(ctx, "delivery", "point")
		}()
	}
	reconcilers.Wait()
	close(errors)
	for err := range errors {
		if err != nil {
			t.Fatal(err)
		}
	}
	if countWorkflows(t, instance, "build") != 2 {
		t.Fatalf("build workflow count = %d", countWorkflows(t, instance, "build"))
	}
}

func TestReconcileRetriesResourceConflict(t *testing.T) {
	refs := &mutableRefs{values: map[string]string{}}
	now := time.Date(2026, time.August, 17, 0, 0, 0, 0, time.UTC)
	instance := testController(t, continuousDelivery(), refs, &now)
	conflicts := 0
	instance.client.(*dynamicfake.FakeDynamicClient).PrependReactor(
		"update",
		"projectdeliveries",
		func(k8stesting.Action) (bool, runtime.Object, error) {
			if conflicts > 0 {
				return false, nil, nil
			}
			conflicts++
			return true, nil, apierrors.NewConflict(
				schema.GroupResource{Group: projectDeliveryGVR.Group, Resource: projectDeliveryGVR.Resource},
				"continuous",
				errors.New("concurrent update"),
			)
		},
	)

	instance.reconcileAll(context.Background())

	if conflicts != 1 {
		t.Fatalf("conflicts = %d", conflicts)
	}
	if countWorkflows(t, instance, "build") != 0 {
		t.Fatal("candidate created a build too early")
	}
}

func testController(t *testing.T, delivery *unstructured.Unstructured, refs sourceReader, now *time.Time) *controller {
	t.Helper()
	objects := []runtime.Object{delivery}
	for _, namespace := range []string{"delivery", "other"} {
		for _, name := range []string{"nuthatch-delivery", "shared-delivery", "other-delivery", "qual-tests", "other-template", "other-qual"} {
			objects = append(objects, testTemplate(namespace, name))
		}
	}
	client := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(
		runtime.NewScheme(),
		map[schema.GroupVersionResource]string{
			projectDeliveryGVR: "ProjectDeliveryList",
			workflowGVR:        "WorkflowList",
			templateGVR:        "WorkflowTemplateList",
			configMapGVR:       "ConfigMapList",
		},
		objects...,
	)
	return &controller{
		client: client,
		source: refs,
		now:    func() time.Time { return *now },
		config: controllerConfig{
			pollInterval:   time.Second,
			bucketInterval: time.Minute,
			requestTimeout: time.Second,
		},
	}
}

func testTemplate(namespace, name string) *unstructured.Unstructured {
	return &unstructured.Unstructured{Object: map[string]any{
		"apiVersion": "argoproj.io/v1alpha1", "kind": "WorkflowTemplate",
		"metadata": map[string]any{
			"name": name, "namespace": namespace, "generation": int64(1),
			"labels": map[string]any{"app.kubernetes.io/name": "project-delivery", "app.kubernetes.io/instance": "synthetic"},
		},
		"spec": map[string]any{"entrypoint": "build", "templates": []any{map[string]any{
			"name": "build", "container": map[string]any{"image": "example.invalid/builder:v1"},
		}}},
	}}
}

func continuousDelivery() *unstructured.Unstructured {
	return deliveryObject("continuous", map[string]any{"continuous": map[string]any{"ref": "refs/heads/main"}})
}

func pointDelivery(revisions ...string) *unstructured.Unstructured {
	values := make([]any, len(revisions))
	for index, revision := range revisions {
		values[index] = revision
	}
	return deliveryObject("point", map[string]any{"point": map[string]any{"revisions": values}})
}

func deliveryObject(name string, sourceMode map[string]any) *unstructured.Unstructured {
	source := map[string]any{"repository": "https://git.quorate.dev/quorate/nuthatch"}
	for key, value := range sourceMode {
		source[key] = value
	}
	return &unstructured.Unstructured{Object: map[string]any{
		"apiVersion": "delivery.quorate.dev/v1alpha1",
		"kind":       "ProjectDelivery",
		"metadata": map[string]any{
			"name":       name,
			"namespace":  "delivery",
			"uid":        "11111111-2222-3333-4444-555555555555",
			"generation": int64(1),
		},
		"spec": map[string]any{
			"source": source,
			"targets": []any{
				map[string]any{"kind": "QuayOCI", "repository": "quorate/nuthatch"},
			},
			"workflowTemplateRef": map[string]any{"name": "nuthatch-delivery"},
		},
	}}
}

func setWorkflowStatus(t *testing.T, instance *controller, purpose, phase string, outputs map[string]string) {
	t.Helper()
	items, err := instance.client.Resource(workflowGVR).Namespace("delivery").List(context.Background(), metav1.ListOptions{})
	if err != nil {
		t.Fatal(err)
	}
	for index := range items.Items {
		item := &items.Items[index]
		if item.GetLabels()[purposeAnnotation] != purpose {
			continue
		}
		status := map[string]any{"phase": phase}
		if len(outputs) != 0 {
			parameters := make([]any, 0, len(outputs))
			for name, value := range outputs {
				parameters = append(parameters, map[string]any{"name": name, "value": value})
			}
			status["nodes"] = map[string]any{
				item.GetName(): map[string]any{"outputs": map[string]any{"parameters": parameters}},
			}
		}
		item.Object["status"] = status
		if _, err := instance.client.Resource(workflowGVR).Namespace("delivery").UpdateStatus(context.Background(), item, metav1.UpdateOptions{}); err != nil {
			t.Fatal(err)
		}
		return
	}
	t.Fatalf("workflow purpose %q not found", purpose)
}

func setNamedWorkflowStatus(t *testing.T, instance *controller, name, phase string, outputs map[string]string) {
	t.Helper()
	item, err := instance.client.Resource(workflowGVR).Namespace("delivery").Get(context.Background(), name, metav1.GetOptions{})
	if err != nil {
		t.Fatal(err)
	}
	status := map[string]any{"phase": phase}
	if len(outputs) != 0 {
		parameters := make([]any, 0, len(outputs))
		for outputName, value := range outputs {
			parameters = append(parameters, map[string]any{"name": outputName, "value": value})
		}
		status["nodes"] = map[string]any{
			item.GetName(): map[string]any{"outputs": map[string]any{"parameters": parameters}},
		}
	}
	item.Object["status"] = status
	if _, err := instance.client.Resource(workflowGVR).Namespace("delivery").UpdateStatus(context.Background(), item, metav1.UpdateOptions{}); err != nil {
		t.Fatal(err)
	}
}

func countWorkflows(t *testing.T, instance *controller, purpose string) int {
	t.Helper()
	items, err := instance.client.Resource(workflowGVR).Namespace("delivery").List(context.Background(), metav1.ListOptions{})
	if err != nil {
		t.Fatal(err)
	}
	count := 0
	for _, item := range items.Items {
		if item.GetLabels()[purposeAnnotation] == purpose {
			count++
		}
	}
	return count
}

func getDelivery(t *testing.T, instance *controller, name string) *unstructured.Unstructured {
	t.Helper()
	object, err := instance.client.Resource(projectDeliveryGVR).Namespace("delivery").Get(context.Background(), name, metav1.GetOptions{})
	if err != nil {
		t.Fatal(err)
	}
	return object
}

func setRetry(t *testing.T, instance *controller, name, workflow string) {
	t.Helper()
	object := getDelivery(t, instance, name)
	annotations := object.GetAnnotations()
	if annotations == nil {
		annotations = map[string]string{}
	}
	annotations[retryAnnotation] = workflow
	object.SetAnnotations(annotations)
	if _, err := instance.client.Resource(projectDeliveryGVR).Namespace("delivery").Update(context.Background(), object, metav1.UpdateOptions{}); err != nil {
		t.Fatal(err)
	}
}

func workflowHasParameter(t *testing.T, workflow *unstructured.Unstructured, name string) bool {
	t.Helper()
	parameters, found, err := unstructured.NestedSlice(workflow.Object, "spec", "arguments", "parameters")
	if err != nil || !found {
		t.Fatalf("read Workflow parameters: found=%t error=%v", found, err)
	}
	for _, item := range parameters {
		parameter := item.(map[string]any)
		if parameter["name"] == name {
			return true
		}
	}
	return false
}

func workflowParameter(t *testing.T, workflow *unstructured.Unstructured, name string) string {
	t.Helper()
	parameters, found, err := unstructured.NestedSlice(workflow.Object, "spec", "arguments", "parameters")
	if err != nil || !found {
		t.Fatalf("read Workflow parameters: found=%t error=%v", found, err)
	}
	for _, item := range parameters {
		parameter := item.(map[string]any)
		if parameter["name"] == name {
			value, _ := parameter["value"].(string)
			return value
		}
	}
	t.Fatalf("Workflow parameter %q not found", name)
	return ""
}

func workflowMutex(t *testing.T, workflow *unstructured.Unstructured) string {
	t.Helper()
	mutexes, found, err := unstructured.NestedSlice(workflow.Object, "spec", "synchronization", "mutexes")
	if err != nil || !found || len(mutexes) != 1 {
		t.Fatalf("read Workflow mutex: count=%d found=%t error=%v", len(mutexes), found, err)
	}
	mutex, ok := mutexes[0].(map[string]any)
	if !ok {
		t.Fatalf("Workflow mutex = %#v", mutexes[0])
	}
	name, _ := mutex["name"].(string)
	return name
}