"istio.io/istio/pkg/kube/krt"
	"istio.io/istio/pkg/slices"
	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/util/assert"
)

func TestJoinCollection(t *testing.T) {
	c1 := krt.NewStatic[Named](nil)
	c2 := krt.NewStatic[Named](nil)
	c3 := krt.NewStatic[Named](nil)
	j := krt.JoinCollection([]krt.Collection[Named]{c1.AsCollection(), c2.AsCollection(), c3.AsCollection()})
	last := atomic.NewString("")
	j.Register(func(o krt.Event[Named]) {

import (
	"testing"

	"istio.io/istio/pkg/kube/krt"
	"istio.io/istio/pkg/ptr"
	"istio.io/istio/pkg/test/util/assert"
)

func TestRecomputeTrigger(t *testing.T) {
	rt := krt.NewRecomputeTrigger()
	col1 := krt.NewStatic(ptr.Of("foo")).AsCollection()
	response := "foo"
	col2 := krt.NewCollection(col1, func(ctx krt.HandlerContext, i string) *string {
		rt.MarkDependant(ctx)
		return ptr.Of(response)
	})
	tt := assert.NewTracker[string](t)

type dummyValue struct{}

func (d dummyValue) ResourceName() string {
	return ""
}

type StaticSingleton[T any] interface {
	Singleton[T]
	Set(*T)
}

func NewStatic[T any](initial *T) StaticSingleton[T] {
	val := new(atomic.Pointer[T])
	val.Store(initial)
	x := &static[T]{
		val:           val,
		id:            nextUID(),
		eventHandlers: &handlers[T]{},
	}

	// is called to ensure our event is not suppressed.
	i *atomic.Int32
}

func NewRecomputeTrigger() *RecomputeTrigger {
	inner := NewStatic[int32](ptr.Of(int32(0)))
	return &RecomputeTrigger{inner: inner, i: atomic.NewInt32(0)}
}

// TriggerRecomputation tells all dependants to recompute
func (r *RecomputeTrigger) TriggerRecomputation() {
	v := r.i.Inc()

}

func GetMockSingleton[T any](mc *MockCollection) krt.StaticSingleton[T] {
	t := extractType[T](&mc.inputs)
	if len(t) > 1 {
		mc.t.Helper()
		mc.t.Fatalf("multiple types returned")
	}
	return krt.NewStatic(slices.First(t))
}

func extractType[T any](items *[]any) []T {
	var matched []T
	var unmatched []any
	arr := *items
	for _, val := range arr {
		if c, ok := val.(T); ok {
			matched = append(matched, c)

			Namespace: "ns",
		},
	})
	tt.WaitUnordered("delete/", "add/ns/a")
	assert.Equal(t, *ConfigMapNames.Get(), "ns/a")
}

func TestNewStatic(t *testing.T) {
	tt := assert.NewTracker[string](t)
	s := krt.NewStatic[string](nil)
	s.Register(TrackerHandler[string](tt))

	assert.Equal(t, s.Get(), nil)

	s.Set(ptr.Of("foo"))
	assert.Equal(t, s.Get(), ptr.Of("foo"))
	tt.WaitOrdered("add/foo")

	s.Set(nil)

This is basically an `Informer`, but not tied to Kubernetes.

Currently, there are three ways to build a `Collection`:
* Built from an `Informer` with `WrapClient` or `NewInformer`.
* Statically configured with `NewStatic`.
* Derived from other collections (more information on this below).

Unlike `Informers`, these primitives work on arbitrary objects.
However, these objects are expected to have some properties, depending on their usage.

func GetMeshConfig(mc *krttest.MockCollection) krt.StaticSingleton[MeshConfig] {
	attempt := krttest.GetMockSingleton[MeshConfig](mc)
	if attempt.Get() == nil {
		return krt.NewStatic(&MeshConfig{mesh.DefaultMeshConfig()})
	}
	return attempt