package link

import (
	"context"
	"testing"
	"time"

	"github.com/nats-io/nats.go/jetstream"
)

// The calls bucket against a real server (novox/hq to-be 45 §6): whether a call's outcome is
// readable by id from a controller that did not serve it is a claim about what the bus keeps.

// waitKept waits until the keeper holds a call in a state, the writes being queued.
func waitKept(t *testing.T, keeper CallKeeper, id, state string) Call {
	t.Helper()
	deadline := time.Now().Add(5 * time.Second)
	for {
		c, found, err := keeper.Kept(context.Background(), id)
		if err == nil && found && c.State == state {
			return c
		}
		if time.Now().After(deadline) {
			t.Fatalf("%s never kept as %q: %+v %v %v", id, state, c, found, err)
		}
		time.Sleep(20 * time.Millisecond)
	}
}

// **A controller restart keeps every call's outcome** (to-be 45 Phase 0): a call one controller
// answered is read whole by id from the next, and a call it left running is said abandoned rather
// than running for ever.

// racingRecent wraps a CallKeeper so a finish lands right after its Recent() snapshot is taken, as
// if that finish raced the moment the snapshot was read (novox/hq issue 711): the snapshot still
// says a call is running, but by the time anything acts on that entry the record has already moved
// on.
type racingRecent struct {
	CallKeeper
	thenLand func()
}

func (r racingRecent) Recent(ctx context.Context) ([]Call, error) {
	out, err := r.CallKeeper.Recent(ctx)
	if err == nil && r.thenLand != nil {
		r.thenLand()
	}
	return out, err
}

// **A finish recorded before the sweep reaches a call stands, with its kept answer** (novox/hq issue
// 711): a stale "running" snapshot is no excuse to overwrite a record that has since said how the
// call ended. A caller reading `abandoned` for a call that succeeded would redo work already done.

// A call left running with no finish recorded is still marked abandoned — unchanged (novox/hq issue
// 711): only a finish actually recorded for it may stand instead.

// delayedKV wraps a jetstream.KeyValue so a hook runs just before Update, to land a write between a
// reader's Get and its own compare-and-set write.
type delayedKV struct {
	jetstream.KeyValue
	before func()
}

func (d delayedKV) Update(ctx context.Context, key string, value []byte, revision uint64) (uint64, error) {
	d.before()
	return d.KeyValue.Update(ctx, key, value, revision)
}

// **The race where a finish lands after the sweep's own read but before its write: the finish
// wins** (novox/hq issue 711). The sweep's write is a compare-and-set on the revision it read, so a
// finish landing in between invalidates it; the sweep rereads, finds the finish, and leaves it alone.

// alwaysMismatchKV wraps a jetstream.KeyValue whose Update always fails with a revision mismatch, as
// if some other writer kept winning the race forever (novox/hq issue 711 review round 1).
type alwaysMismatchKV struct {
	jetstream.KeyValue
	tries *int
}

func (a alwaysMismatchKV) Update(ctx context.Context, key string, value []byte, revision uint64) (uint64, error) {
	*a.tries++
	return 0, jetstream.ErrKeyRevisionMismatch
}

// **MarkAbandoned gives up after markAbandonedTries rather than loop forever** (novox/hq issue 711
// review round 1): a record whose compare-and-set keeps losing is left as it stands, said in an
// error naming the call, not retried without end.

// The bucket holds the last thousand calls or fourteen days: a call is two keys, so the stream under
// it holds twice as many messages, and asserting it again keeps the count.

// An answer larger than the bound is cut and says so, and the record is still written.

// Who asked is read from the inbox the answer goes to.
func TestTheCallerIsTheInboxsPrincipal(t *testing.T) {
	for reply, want := range map[string]string{
		"_INBOX.node-tools.g14.Pe3sGzAtv8jUBYQ6sKSvKz.1": "node-tools.g14",
		"_INBOX.jochen.Pe3sGzAtv8jUBYQ6sKSvKz":           "jochen",
		"_INBOX.x.1":                                     "",
		"mesh.control.one":                               "",
		"":                                               "",
	} {
		if got := callerOf(reply); got != want {
			t.Errorf("%q: %q, want %q", reply, got, want)
		}
	}
}