state

func reportCallbackPanic(recovered any, context string, stack []byte)

{
	if OnCallbackPanic == nil {
		log.Printf("[rfw] recovered panic in %s: %v\n%s", context, recovered, stack)
		return
	}
	defer func() {
		if reporterPanic := recover(); reporterPanic != nil {
			log.Printf("[rfw] callback panic reporter failed: %v", reporterPanic)
			log.Printf("[rfw] recovered panic in %s: %v\n%s", context, recovered, stack)
		}
	}()
	OnCallbackPanic(recovered, context, stack)
}

func runCallback(context string, fn func()) (ok bool)

{
	ok = true
	defer func() {
		if recovered := recover(); recovered != nil {
			ok = false
			reportCallbackPanic(recovered, context, debug.Stack())
		}
	}()
	fn()
	return ok
}

func TestStoreConcurrentAccess(_ *testing.T)

{
	s := NewStore("racestore", WithModule("race"), WithHistory(8))
	s.RegisterComputed(NewComputed("double", []string{"n"}, func(m map[string]any) any {
		if v, ok := m["n"].(int); ok {
			return v * 2
		}
		return 0
	}))
	unwatch := s.RegisterWatcher(NewWatcher([]string{"n"}, func(m map[string]any) {
		_ = m["n"]
	}))
	defer unwatch()

	var wg sync.WaitGroup
	for g := 0; g < 4; g++ {
		wg.Add(1)
		go func(g int) {
			defer wg.Done()
			for i := 0; i < 200; i++ {
				s.Set("n", i)
				s.Set(fmt.Sprintf("k%d", g), i)
				_ = s.Get("n")
				_ = s.Snapshot()
				if i%50 == 0 {
					unsub := s.OnChange("n", func(any) {})
					unsub()
					s.Undo()
					s.Redo()
				}
			}
		}(g)
	}
	wg.Wait()
}

func TestSignalConcurrentAccess(_ *testing.T)

{
	sig := NewSignal(0)
	stop := Effect(func() func() {
		_ = sig.Get()
		return nil
	})
	defer stop()
	sub := sig.OnChange(func(int) {})
	defer sub.Stop()

	var wg sync.WaitGroup
	for g := 0; g < 4; g++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := 0; i < 200; i++ {
				sig.Set(i)
				_ = sig.Get()
				_ = sig.Read()
				sig.SetFromHost(float64(i))
			}
		}()
	}
	wg.Wait()
}

func TestReactiveVarInt(t *testing.T)

{
	rv := NewReactiveVar(0)
	var changed int
	rv.OnChange(func(v int) { changed = v })
	rv.Set(42)
	if got := rv.Get(); got != 42 {
		t.Fatalf("expected Get to return 42, got %d", got)
	}
	if changed != 42 {
		t.Fatalf("expected OnChange to fire with 42, got %d", changed)
	}
}

func TestReactiveVarStruct(t *testing.T)

{
	initial := sample{A: 1, B: "foo"}
	rv := NewReactiveVar(initial)
	var changed sample
	rv.OnChange(func(s sample) { changed = s })
	newVal := sample{A: 2, B: "bar"}
	rv.Set(newVal)
	if got := rv.Get(); !reflect.DeepEqual(got, newVal) {
		t.Fatalf("expected Get to return %v, got %v", newVal, got)
	}
	if !reflect.DeepEqual(changed, newVal) {
		t.Fatalf("expected OnChange to receive %v, got %v", newVal, changed)
	}
}

func NewResource[T any](loader func(context.Context) (T, error), opts ...ResourceOption) *Resource[T]

{
	config := resourceConfig{immediate: true}
	for _, opt := range opts {
		opt(&config)
	}
	resource := &Resource[T]{
		loader: loader,
		key:    config.key,
		ttl:    config.ttl,
		value:  NewSignal(*new(T)),
		status: NewSignal(ResourceIdle),
		err:    NewSignal[error](nil),
	}
	if config.immediate {
		resource.Load(context.Background())
	}
	return resource
}

func loadResourceCache[T any](key string) (T, bool)

{
	var zero T
	if key == "" {
		return zero, false
	}
	resourceShared.Lock()
	defer resourceShared.Unlock()
	entry, ok := resourceShared.cache[key]
	if !ok {
		return zero, false
	}
	if !entry.expires.IsZero() && time.Now().After(entry.expires) {
		delete(resourceShared.cache, key)
		return zero, false
	}
	value, ok := entry.value.(T)
	return value, ok
}

func acquireResourceFlight[T any](ctx context.Context, key string, loader func(context.Context) (T, error)) *resourceFlight

{
	resourceShared.Lock()
	if key != "" {
		if flight := resourceShared.flights[key]; flight != nil {
			flight.waiters++
			resourceShared.Unlock()
			return flight
		}
	}
	base := context.WithoutCancel(ctx)
	flightCtx, cancel := context.WithCancel(base)
	flight := &resourceFlight{done: make(chan struct{}), cancel: cancel, waiters: 1}
	if key != "" {
		resourceShared.flights[key] = flight
	}
	resourceShared.Unlock()

	go func() {
		value, err := runResourceLoader(flightCtx, loader)
		resourceShared.Lock()
		flight.value = value
		flight.err = err
		flight.closed = true
		if key != "" && resourceShared.flights[key] == flight {
			delete(resourceShared.flights, key)
		}
		close(flight.done)
		resourceShared.Unlock()
	}()
	return flight
}

func waitResourceFlight[T any](ctx context.Context, flight *resourceFlight) (T, error)

{
	var zero T
	select {
	case <-flight.done:
		resourceShared.Lock()
		value := flight.value
		err := flight.err
		flight.waiters--
		resourceShared.Unlock()
		typed, ok := value.(T)
		if !ok && err == nil {
			return zero, fmt.Errorf("state: resource result type mismatch")
		}
		return typed, err
	case <-ctx.Done():
		resourceShared.Lock()
		flight.waiters--
		if flight.waiters == 0 && !flight.closed {
			flight.cancel()
		}
		resourceShared.Unlock()
		return zero, ctx.Err()
	}
}

func flushBatch()

{
	effectScheduler.Lock()
	effectScheduler.depth--
	if effectScheduler.depth > 0 {
		effectScheduler.Unlock()
		return
	}
	pending := make([]*effect, 0, len(effectScheduler.pending))
	for effect := range effectScheduler.pending {
		pending = append(pending, effect)
	}
	clear(effectScheduler.pending)
	effectScheduler.Unlock()
	for _, effect := range pending {
		effect.runEffect()
	}
}

func valEqual(a, b any) bool

{
	if a == nil && b == nil {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	switch av := a.(type) {
	case string:
		if bv, ok := b.(string); ok {
			return av == bv
		}
	case int:
		if bv, ok := b.(int); ok {
			return av == bv
		}
	case float64:
		if bv, ok := b.(float64); ok {
			return av == bv
		}
	case bool:
		if bv, ok := b.(bool); ok {
			return av == bv
		}
	case int64:
		if bv, ok := b.(int64); ok {
			return av == bv
		}
	case float32:
		if bv, ok := b.(float32); ok {
			return av == bv
		}
	}
	return reflect.DeepEqual(a, b)
}

func depsChanged(current, last map[string]any) bool

{
	if len(current) != len(last) {
		return true
	}
	for k, v := range current {
		if lv, ok := last[k]; !ok || !valEqual(v, lv) {
			return true
		}
	}
	return false
}

func Map2[A, B, R any](s *Store, key, depA, depB string, compute func(A, B) R)

{
	c := NewComputed(key, []string{depA, depB}, func(m map[string]any) any {
		a, okA := m[depA].(A)
		b, okB := m[depB].(B)
		if okA && okB {
			return compute(a, b)
		}
		var zero R
		return zero
	})
	s.RegisterComputed(c)
}

func pathMatches(key, dep string) bool

{
	if key == dep {
		return true
	}
	if strings.HasPrefix(key, dep+".") {
		return true
	}
	if strings.HasPrefix(dep, key+".") {
		return true
	}
	return false
}

func TestUnregisterStore(t *testing.T)

{
	sm := &StoreManager{modules: make(map[string]map[string]*Store)}
	s := NewStore("test", WithModule("mod"))
	sm.RegisterStore("mod", "test", s)
	if sm.GetStore("mod", "test") == nil {
		t.Fatalf("expected store to be registered")
	}
	sm.UnregisterStore("mod", "test")
	if sm.GetStore("mod", "test") != nil {
		t.Fatalf("expected store to be unregistered")
	}
}

func TestDispatch(t *testing.T)

{
	called := false
	a := Action(func(_ Context) error {
		called = true
		return nil
	})
	if err := Dispatch(context.Background(), a); err != nil {
		t.Fatalf("dispatch returned error: %v", err)
	}
	if !called {
		t.Fatalf("action was not executed")
	}
}

func TestUseAction(t *testing.T)

{
	called := false
	a := Action(func(_ Context) error {
		called = true
		return nil
	})
	fn := UseAction(context.Background(), a)
	if err := fn(); err != nil {
		t.Fatalf("use action returned error: %v", err)
	}
	if !called {
		t.Fatalf("action not executed via UseAction")
	}
}

func loadPersistedState(key string) map[string]any

{
	ls := js.LocalStorage()
	if !ls.Truthy() {
		return nil
	}
	item := ls.Call("getItem", key)
	if item.Type() != js.TypeString {
		return nil
	}
	var state map[string]any
	if err := json.Unmarshal([]byte(item.String()), &state); err != nil {
		return nil
	}
	return state
}

func saveState(key string, state map[string]any)

{
	ls := js.LocalStorage()
	if !ls.Truthy() {
		return
	}
	data, err := json.Marshal(state)
	if err != nil {
		return
	}
	ls.Call("setItem", key, string(data))
}

func TestSignalEffect(t *testing.T)

{
	a := NewSignal(0)
	b := NewSignal(0)

	var runs int
	stop := Effect(func() func() {
		_ = a.Get()
		runs++
		return nil
	})
	defer stop()

	b.Set(1)
	if runs != 1 {
		t.Fatalf("effect ran on unrelated signal change")
	}
	a.Set(1)
	if runs != 2 {
		t.Fatalf("effect did not rerun on dependent signal change")
	}
}

func TestEffectCleanup(t *testing.T)

{
	s := NewSignal(0)
	var cleans int
	stop := Effect(func() func() {
		_ = s.Get()
		return func() { cleans++ }
	})

	s.Set(1)
	if cleans != 1 {
		t.Fatalf("cleanup not called before rerun, got %d", cleans)
	}
	stop()
	if cleans != 2 {
		t.Fatalf("cleanup not called on stop, got %d", cleans)
	}
}

func TestSetNotifiesAllSubscribers(t *testing.T)

{
	s := NewSignal(0)

	var val1, val2 int
	stop1 := Effect(func() func() {
		val1 = s.Get()
		return nil
	})
	defer stop1()

	stop2 := Effect(func() func() {
		val2 = s.Get() * 2
		return nil
	})
	defer stop2()

	if val1 != 0 || val2 != 0 {
		t.Fatalf("initial: expected 0,0 got %d,%d", val1, val2)
	}

	s.Set(5)
	if val1 != 5 {
		t.Fatalf("effect1 after Set(5): expected 5, got %d", val1)
	}
	if val2 != 10 {
		t.Fatalf("effect2 after Set(5): expected 10, got %d", val2)
	}
}

func TestExprEffectWithMultipleSignals(t *testing.T)

{
	count := NewSignal(0)
	factor := NewSignal(0)

	var result int
	stop := Effect(func() func() {
		result = count.Get() * factor.Get()
		return nil
	})
	defer stop()

	if result != 0 {
		t.Fatalf("initial: expected 0, got %d", result)
	}

	factor.Set(2)
	if result != 0 {
		t.Fatalf("after factor=2: expected 0, got %d", result)
	}

	count.Set(1)
	if result != 2 {
		t.Fatalf("after count=1: expected 2, got %d", result)
	}

	count.Set(3)
	if result != 6 {
		t.Fatalf("after count=3: expected 6, got %d", result)
	}

	factor.Set(3)
	if result != 9 {
		t.Fatalf("after factor=3: expected 9, got %d", result)
	}
}

func TestOnChangeBasic(t *testing.T)

{
	s := NewSignal("hello")
	var received []string

	sub := s.OnChange(func(v string) {
		received = append(received, v)
	})

	s.Set("world")
	s.Set("!")

	if len(received) != 2 || received[0] != "world" || received[1] != "!" {
		t.Fatalf("expected [world !], got %v", received)
	}

	sub.Stop()
	s.Set("after-stop")
	if len(received) != 2 {
		t.Fatalf("callback fired after Stop: %v", received)
	}
}

func TestOnChangeMultipleListeners(t *testing.T)

{
	s := NewSignal(0)
	var sum int

	sub1 := s.OnChange(func(v int) { sum += v })
	sub2 := s.OnChange(func(v int) { sum += v * 10 })

	s.Set(1)
	if sum != 11 {
		t.Fatalf("expected 11, got %d", sum)
	}

	sub1.Stop()
	s.Set(2)
	if sum != 31 {
		t.Fatalf("expected 31, got %d", sum)
	}

	sub2.Stop()
	s.Set(3)
	if sum != 31 {
		t.Fatalf("expected 31 after all stopped, got %d", sum)
	}
}

func TestOnChangeStopsAreIdempotent(t *testing.T)

{
	s := NewSignal(0)
	calls := 0

	sub := s.OnChange(func(int) { calls++ })

	s.Set(1)
	if calls != 1 {
		t.Fatalf("expected 1, got %d", calls)
	}

	sub.Stop()
	sub.Stop()
	sub.Stop()

	s.Set(2)
	if calls != 1 {
		t.Fatalf("callback fired after multiple stops: %d", calls)
	}
}

func TestChannelLazyCreation(t *testing.T)

{
	s := NewSignal(0)

	s.onChangeMu.Lock()
	hasCh := s.chCreated
	s.onChangeMu.Unlock()
	if hasCh {
		t.Fatal("channel should not exist before Channel() call")
	}

	ch := s.Channel()

	s.onChangeMu.Lock()
	hasCh = s.chCreated
	s.onChangeMu.Unlock()
	if !hasCh {
		t.Fatal("channel should exist after Channel() call")
	}
	_ = ch
}

func TestChannelReceivesValues(t *testing.T)

{
	s := NewSignal(0)
	ch := s.Channel()

	s.Set(42)

	select {
	case v := <-ch:
		if v != 42 {
			t.Fatalf("expected 42, got %d", v)
		}
	default:
		t.Fatal("channel should have received value")
	}
}

func TestOnChangeDoesNotFireAfterStop(t *testing.T)

{
	s := NewSignal(10)
	calls := 0

	sub := s.OnChange(func(int) { calls++ })

	s.Set(20)
	if calls != 1 {
		t.Fatalf("expected 1 call, got %d", calls)
	}

	sub.Stop()

	s.Set(30)
	s.Set(40)
	if calls != 1 {
		t.Fatalf("expected calls to stay 1 after Stop, got %d", calls)
	}
}

func TestSetFromHostConversions(t *testing.T)

{
	i64 := NewSignal[int64](0)
	i64.SetFromHost(float64(42))
	if i64.Get() != 42 {
		t.Fatalf("int64: got %d", i64.Get())
	}
	f32 := NewSignal[float32](0)
	f32.SetFromHost(float64(1.5))
	if f32.Get() != 1.5 {
		t.Fatalf("float32: got %v", f32.Get())
	}
	u := NewSignal[uint](0)
	u.SetFromHost(float64(7))
	if u.Get() != 7 {
		t.Fatalf("uint: got %d", u.Get())
	}
	type point struct {
		X int    `json:"x"`
		Y string `json:"y"`
	}
	p := NewSignal[point](point{})
	p.SetFromHost(map[string]any{"x": float64(3), "y": "hi"})
	if got := p.Get(); got.X != 3 || got.Y != "hi" {
		t.Fatalf("struct: got %+v", got)
	}
	sl := NewSignal[[]int](nil)
	sl.SetFromHost([]any{float64(1), float64(2)})
	if got := sl.Get(); len(got) != 2 || got[1] != 2 {
		t.Fatalf("slice: got %v", got)
	}
	// Incompatible payloads leave the value untouched.
	n := NewSignal[int](9)
	n.SetFromHost("not a number")
	if n.Get() != 9 {
		t.Fatalf("mismatch should be ignored, got %d", n.Get())
	}
	notify := 0
	m := NewSignal[int](0)
	m.OnChange(func(int) { notify++ })
	m.SetFromHost(float64(5))
	if m.Get() != 5 || notify != 1 {
		t.Fatalf("notify: value %d, calls %d", m.Get(), notify)
	}
}

func TestStoreUndoRedo(t *testing.T)

{
	s := NewStore("hist", WithHistory(10))
	s.Set("count", 1)
	s.Set("count", 2)
	if v := s.Get("count"); v != 2 {
		t.Fatalf("expected 2, got %v", v)
	}
	s.Undo()
	if v := s.Get("count"); v != 1 {
		t.Fatalf("expected 1 after undo, got %v", v)
	}
	s.Redo()
	if v := s.Get("count"); v != 2 {
		t.Fatalf("expected 2 after redo, got %v", v)
	}
}

func TestStoreHistoryLimit(t *testing.T)

{
	s := NewStore("limit", WithHistory(2))
	s.Set("val", 1)
	s.Set("val", 2)
	s.Set("val", 3)
	s.Set("val", 4)
	// history limit 2 means only last two changes are tracked
	s.Undo() // 4 -> 3
	if v := s.Get("val"); v != 3 {
		t.Fatalf("expected 3 after first undo, got %v", v)
	}
	s.Undo() // 3 -> 2
	if v := s.Get("val"); v != 2 {
		t.Fatalf("expected 2 after second undo, got %v", v)
	}
	s.Undo() // no effect, history exhausted
	if v := s.Get("val"); v != 2 {
		t.Fatalf("expected 2 after exhausting history, got %v", v)
	}
}

func TestRedoClearedOnNewMutation(t *testing.T)

{
	s := NewStore("redo", WithHistory(10))
	s.Set("a", 1)
	s.Set("a", 2)
	s.Undo()      // a ->1, future has mutation 1->2
	s.Set("a", 3) // new mutation should clear redo stack
	s.Redo()      // should do nothing
	if v := s.Get("a"); v != 3 {
		t.Fatalf("expected 3 after redo with cleared history, got %v", v)
	}
}

func ExposeUpdateStore()

{
	js.Set("goUpdateStore", js.SafeFuncOf(func(_ js.Value, args []js.Value) any {
		if len(args) < 4 {
			return nil
		}
		module := args[0].String()
		storeName := args[1].String()
		key := args[2].String()

		var newValue any
		switch args[3].Type() {
		case js.TypeString:
			newValue = args[3].String()
		case js.TypeBoolean:
			newValue = args[3].Bool()
		case js.TypeNumber:
			newValue = args[3].Float()
		default:
			newValue = args[3]
		}

		store := GlobalStoreManager.GetStore(module, storeName)
		if store == nil {
			store = NewStore(storeName, WithModule(module))
		}
		store.Set(key, newValue)
		return nil
	}))
}

func TestExposeUpdateStoreBool(t *testing.T)

{
	ExposeUpdateStore()
	js.Call("goUpdateStore", "mod", "test", "flag", true)
	store := GlobalStoreManager.GetStore("mod", "test")
	if store == nil {
		t.Fatalf("store not created")
	}
	v, ok := store.Get("flag").(bool)
	if !ok || !v {
		t.Fatalf("expected true bool, got %#v", store.Get("flag"))
	}
}

func captureCallbackPanics(t *testing.T) *[]string

{
	t.Helper()
	previous := OnCallbackPanic
	contexts := []string{}
	OnCallbackPanic = func(_ any, context string, stack []byte) {
		if len(stack) == 0 {
			t.Error("recovered callback panic had no stack")
		}
		contexts = append(contexts, context)
	}
	t.Cleanup(func() { OnCallbackPanic = previous })
	return &contexts
}

func TestStoreContinuesNotificationsAfterListenerPanic(t *testing.T)

{
	contexts := captureCallbackPanics(t)
	store := NewStore("recovery", WithModule("test"))
	called := 0
	store.OnChange("value", func(any) { panic("first listener") })
	store.OnChange("value", func(any) { called++ })

	store.Set("value", 1)
	store.Set("value", 2)

	if called != 2 {
		t.Fatalf("healthy listener calls = %d, want 2", called)
	}
	if len(*contexts) != 2 || !strings.Contains((*contexts)[0], "test.recovery.value") {
		t.Fatalf("unexpected recovery contexts: %v", *contexts)
	}
}

func TestSignalContinuesListenersAfterPanic(t *testing.T)

{
	contexts := captureCallbackPanics(t)
	signal := NewSignal(0)
	called := 0
	signal.OnChange(func(int) { panic("first listener") })
	signal.OnChange(func(int) { called++ })

	signal.Set(1)
	signal.Set(2)

	if called != 2 {
		t.Fatalf("healthy listener calls = %d, want 2", called)
	}
	if len(*contexts) != 2 || (*contexts)[0] != "signal change listener" {
		t.Fatalf("unexpected recovery contexts: %v", *contexts)
	}
}

func TestEffectCanRunAgainAfterPanic(t *testing.T)

{
	contexts := captureCallbackPanics(t)
	signal := NewSignal(0)
	runs := 0
	stop := Effect(func() func() {
		value := signal.Get()
		runs++
		if value == 1 {
			panic("effect update")
		}
		return nil
	})
	defer stop()

	signal.Set(1)
	signal.Set(2)

	if runs != 3 {
		t.Fatalf("effect runs = %d, want 3", runs)
	}
	if len(*contexts) != 1 || (*contexts)[0] != "signal effect" {
		t.Fatalf("unexpected recovery contexts: %v", *contexts)
	}
}

func TestResourceLoadsAndMutates(t *testing.T)

{
	resource := NewResource(func(context.Context) (int, error) { return 7, nil })
	defer resource.Close()
	waitResourceStatus(t, resource, ResourceReady)

	value, err := resource.Read()
	if err != nil || value != 7 {
		t.Fatalf("Read() = %d, %v", value, err)
	}
	resource.Mutate(9)
	value, err = resource.Read()
	if err != nil || value != 9 {
		t.Fatalf("Read() after Mutate = %d, %v", value, err)
	}
}

func TestKeyedResourcesDeduplicateLoads(t *testing.T)

{
	const key = "resource-deduplicate"
	ClearResourceCache(key)
	t.Cleanup(func() { ClearResourceCache(key) })
	start := make(chan struct{})
	var calls atomic.Int32
	loader := func(context.Context) (int, error) {
		calls.Add(1)
		<-start
		return 11, nil
	}
	first := NewResource(loader, WithResourceKey(key))
	second := NewResource(loader, WithResourceKey(key))
	defer first.Close()
	defer second.Close()
	close(start)
	waitResourceStatus(t, first, ResourceReady)
	waitResourceStatus(t, second, ResourceReady)

	if calls.Load() != 1 {
		t.Fatalf("loader calls = %d", calls.Load())
	}
}

func TestResourceCloseCancelsLoad(t *testing.T)

{
	cancelled := make(chan struct{})
	resource := NewResource(func(ctx context.Context) (int, error) {
		<-ctx.Done()
		close(cancelled)
		return 0, ctx.Err()
	})
	resource.Close()

	select {
	case <-cancelled:
	case <-time.After(time.Second):
		t.Fatal("loader context was not cancelled")
	}
}

func TestResourceLoaderPanicBecomesError(t *testing.T)

{
	resource := NewResource(func(context.Context) (int, error) {
		panic("loader")
	})
	defer resource.Close()

	waitResourceStatus(t, resource, ResourceError)
	if resource.Error() == nil {
		t.Fatal("resource panic did not become an error")
	}
}

func TestBatchRunsDependentEffectOnce(t *testing.T)

{
	first := NewSignal(1)
	second := NewSignal(2)
	runs := 0
	stop := Effect(func() func() {
		_ = first.Get() + second.Get()
		runs++
		return nil
	})
	defer stop()

	Batch(func() {
		first.Set(3)
		second.Set(4)
	})

	if runs != 2 {
		t.Fatalf("effect runs = %d", runs)
	}
}

func TestUntrackedReadDoesNotBecomeDependency(t *testing.T)

{
	tracked := NewSignal(1)
	ignored := NewSignal(2)
	runs := 0
	stop := Effect(func() func() {
		_ = tracked.Get()
		_ = Untracked(ignored.Get)
		runs++
		return nil
	})
	defer stop()

	ignored.Set(3)
	if runs != 1 {
		t.Fatalf("effect tracked untracked signal: runs = %d", runs)
	}
	tracked.Set(2)
	if runs != 2 {
		t.Fatalf("tracked signal did not rerun effect: runs = %d", runs)
	}
}

func TestMemoTracksDependencies(t *testing.T)

{
	first := NewSignal(2)
	second := NewSignal(3)
	total := Memo(func() int { return first.Get() + second.Get() })
	defer total.Stop()

	if total.Get() != 5 {
		t.Fatalf("initial memo = %d", total.Get())
	}
	Batch(func() {
		first.Set(4)
		second.Set(5)
	})
	if total.Get() != 9 {
		t.Fatalf("updated memo = %d", total.Get())
	}
}

func TestComputedStability(t *testing.T)

{
	s := NewStore("test")
	s.Set("a", 1)

	evalCount := 0
	c := NewComputed("double", []string{"a"}, func(m map[string]any) any {
		evalCount++
		return m["a"].(int) * 2
	})
	s.RegisterComputed(c)

	if evalCount != 1 {
		t.Fatalf("expected 1 evaluation, got %d", evalCount)
	}
	if v := s.Get("double"); v != 2 {
		t.Fatalf("expected computed value 2, got %v", v)
	}

	// Setting dependency to same value should not re-evaluate
	s.Set("a", 1)
	if evalCount != 1 {
		t.Fatalf("computed re-evaluated without dependency change")
	}

	// Setting unrelated key should not re-evaluate
	s.Set("b", 5)
	if evalCount != 1 {
		t.Fatalf("computed re-evaluated for unrelated key")
	}

	// Changing dependency should trigger re-evaluation
	s.Set("a", 3)
	if evalCount != 2 {
		t.Fatalf("expected second evaluation after dependency change, got %d", evalCount)
	}
	if v := s.Get("double"); v != 6 {
		t.Fatalf("expected computed value 6, got %v", v)
	}
}

func TestMapHelpers(t *testing.T)

{
	s := NewStore("test")
	s.Set("count", 2)

	Map(s, "double", "count", func(v int) int { return v * 2 })

	if v := s.Get("double"); v != 4 {
		t.Fatalf("expected 4, got %v", v)
	}

	s.Set("count", 3)
	if v := s.Get("double"); v != 6 {
		t.Fatalf("expected 6 after update, got %v", v)
	}

	s.Set("first", "Ada")
	s.Set("last", "Lovelace")

	Map2(s, "fullName", "first", "last", func(f, l string) string {
		return strings.TrimSpace(f + " " + l)
	})

	if v := s.Get("fullName"); v != "Ada Lovelace" {
		t.Fatalf("expected full name Ada Lovelace, got %v", v)
	}

	s.Set("last", "Hopper")
	if v := s.Get("fullName"); v != "Ada Hopper" {
		t.Fatalf("expected full name Ada Hopper, got %v", v)
	}
}