package main

// A session's memory follows the operator (novox/hq ADR 0343, issue 367). Every test runs against temporary homes
// and a state in memory with the bus's watch semantics: never the live memory folders.

import (
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"testing"
	"time"
)

// memState is the `memory` state in memory: revisions, create and compare-and-set, and every change handed to every
// watcher, the writer included, as the bus does.
type memState struct {
	mu       sync.Mutex
	values   map[string]json.RawMessage
	revs     map[string]uint64
	rev      uint64
	pending  []change
	watchers []*MemoryCarrier
}

type change struct {
	key, op string
	value   json.RawMessage
	rev     uint64
}

func newMemState() *memState {
	return &memState{values: map[string]json.RawMessage{}, revs: map[string]uint64{}}
}

var errChanged = errors.New("wrong last revision")

func (s *memState) Get(key string) (json.RawMessage, uint64, bool, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	v, ok := s.values[key]
	return v, s.revs[key], ok, nil
}

func (s *memState) write(key string, value any) {
	raw, _ := json.Marshal(value)
	s.rev++
	s.values[key], s.revs[key] = raw, s.rev
	s.pending = append(s.pending, change{key, "put", raw, s.rev})
}

func (s *memState) Create(key string, value any) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	if _, ok := s.values[key]; ok {
		return errChanged
	}
	s.write(key, value)
	return nil
}

func (s *memState) Update(key string, value any, revision uint64) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.revs[key] != revision {
		return errChanged
	}
	s.write(key, value)
	return nil
}

func (s *memState) Keys() ([]string, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	var keys []string
	for k := range s.values {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	return keys, nil
}

func (s *memState) Delete(key string) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	delete(s.values, key)
	delete(s.revs, key)
	s.rev++
	s.pending = append(s.pending, change{key, "delete", nil, s.rev})
	return nil
}

// pump hands every change so far to every watcher, until none is left.
func (s *memState) pump(t *testing.T) {
	t.Helper()
	for i := 0; i < 50; i++ {
		s.mu.Lock()
		todo := s.pending
		s.pending = nil
		s.mu.Unlock()
		if len(todo) == 0 {
			return
		}
		for _, c := range todo {
			for _, w := range s.watchers {
				if err := w.Take(c.key, c.op, c.value, c.rev); err != nil {
					t.Logf("%s taking %s: %v", w.Node, c.key, err)
				}
			}
		}
		for _, w := range s.watchers {
			if err := w.Drain(); err != nil && !errors.Is(err, errChanged) {
				t.Logf("%s applying: %v", w.Node, err)
			}
		}
	}
	t.Fatal("the state never settled")
}

// clock is a clock a test moves.
type clock struct{ now time.Time }

func (c *clock) Now() time.Time { return c.now }

// memNode is one node's carrier over its own temporary home and state directory.
type memNode struct {
	*MemoryCarrier
	notices []map[string]any
}

func newMemNode(t *testing.T, root, name, kind string, state *memState, c *clock) *memNode {
	t.Helper()
	n := &memNode{}
	home := filepath.Join(root, name, "home")
	stateDir := filepath.Join(root, name, "state")
	for _, d := range []string{filepath.Join(home, ".claude", "projects"), stateDir} {
		if err := os.MkdirAll(d, 0o700); err != nil {
			t.Fatal(err)
		}
	}
	n.MemoryCarrier = &MemoryCarrier{Home: home, Node: name, State: stateDir, Kind: kind, Store: state, Now: c.Now,
		wake:   make(chan struct{}, 1),
		Notify: func(a map[string]any) error { n.notices = append(n.notices, a); return nil }}
	state.watchers = append(state.watchers, n.MemoryCarrier)
	return n
}

func (n *memNode) path(project, file string) string {
	return filepath.Join(n.Home, ".claude", "projects", project, "memory", filepath.FromSlash(file))
}

func (n *memNode) write(t *testing.T, project, file, text string, at time.Time) {
	t.Helper()
	p := n.path(project, file)
	if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(p, []byte(text), 0o644); err != nil {
		t.Fatal(err)
	}
	_ = os.Chtimes(p, at, at)
}

func (n *memNode) read(t *testing.T, project, file string) (string, bool) {
	t.Helper()
	raw, err := os.ReadFile(n.path(project, file))
	if os.IsNotExist(err) {
		return "", false
	}
	if err != nil {
		t.Fatal(err)
	}
	return string(raw), true
}

func (n *memNode) look(t *testing.T) {
	t.Helper()
	if err := n.Look(); err != nil && !errors.Is(err, errChanged) {
		t.Fatalf("%s's look: %v", n.Node, err)
	}
}

// copies is every text kept in the node's copies.
func (n *memNode) copies(t *testing.T) []string {
	t.Helper()
	var out []string
	_ = filepath.WalkDir(n.MemoryCarrier.copies(), func(p string, d os.DirEntry, err error) error {
		if err == nil && !d.IsDir() {
			raw, _ := os.ReadFile(p)
			out = append(out, string(raw))
		}
		return nil
	})
	return out
}

func holdsText(list []string, s string) bool {
	for _, x := range list {
		if x == s {
			return true
		}
	}
	return false
}

const project = "-home-op-projects-novox-hq"

func twoNodes(t *testing.T) (*memState, *clock, *memNode, *memNode) {
	state, c := newMemState(), &clock{now: time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)}
	root := t.TempDir()
	return state, c, newMemNode(t, root, "g14", HomeOperator, state, c), newMemNode(t, root, "shanks", HomeOperator, state, c)
}

// carried writes a file on g14 and carries it to shanks.
func carriedOnBoth(t *testing.T, state *memState, c *clock, a, b *memNode, file, text string) {
	t.Helper()
	a.write(t, project, file, text, c.now)
	a.look(t)
	state.pump(t)
	b.look(t)
	state.pump(t)
	if got, _ := b.read(t, project, file); got != text {
		t.Fatalf("not carried to %s: %q", b.Node, got)
	}
}

// §5, §6: a memory file written on one node appears unchanged on another, at any depth, and is carried once.
func TestAMemoryFileWrittenOnOneNodeAppearsUnchangedOnAnother(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	g14.write(t, project, "MEMORY.md", "- [state](state.md) — where things stand\n", c.now)
	g14.write(t, project, "notes/state.md", "ADR 0343 proposed.\n", c.now)
	g14.look(t)
	state.pump(t)
	for file, want := range map[string]string{"MEMORY.md": "- [state](state.md) — where things stand\n", "notes/state.md": "ADR 0343 proposed.\n"} {
		if got, ok := shanks.read(t, project, file); !ok || got != want {
			t.Fatalf("%s on shanks: %q, %v", file, got, ok)
		}
	}
	before := state.rev
	shanks.look(t)
	g14.look(t)
	state.pump(t)
	if state.rev != before {
		t.Fatalf("a carried file was carried again: %d changes", state.rev-before)
	}
	// A change on shanks comes back to g14, over the version it replaced, which g14 keeps.
	c.now = c.now.Add(time.Minute)
	shanks.write(t, project, "notes/state.md", "ADR 0343 accepted.\n", c.now)
	shanks.look(t)
	state.pump(t)
	if got, _ := g14.read(t, project, "notes/state.md"); got != "ADR 0343 accepted.\n" {
		t.Fatalf("the change did not reach g14: %q", got)
	}
	if !holdsText(g14.copies(t), "ADR 0343 proposed.\n") {
		t.Fatal("the version replaced on g14 was not kept")
	}
	if len(g14.notices)+len(shanks.notices) != 0 {
		t.Fatalf("a plain change warned: %v %v", g14.notices, shanks.notices)
	}
	// No value in the state is anything but a version of a memory file, and no tool answer carries the text.
	raw, _ := json.Marshal(g14.Status())
	if strings.Contains(string(raw), "accepted") {
		t.Fatalf("the memory tool answered the text: %s", raw)
	}
}

// §1, §2: only the memory folders are carried; a symbolic link, an oversized file and a secret's shape are not, and are
// listed with why.
func TestOnlyTheMemoryFoldersAreCarried(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	projectDir := filepath.Join(g14.Home, ".claude", "projects", project)
	g14.write(t, project, "MEMORY.md", "index\n", c.now)
	for path, text := range map[string]string{
		filepath.Join(projectDir, "session.jsonl"):          "{}\n",
		filepath.Join(g14.Home, ".claude", "settings.json"): "{}\n",
		filepath.Join(g14.Home, ".claude", "history.jsonl"): "{}\n",
	} {
		if err := os.WriteFile(path, []byte(text), 0o600); err != nil {
			t.Fatal(err)
		}
	}
	g14.write(t, project, "key.md", "-----BEGIN OPENSSH PRIVATE KEY-----\nabc\n", c.now)
	g14.write(t, project, "url.md", "https://op:hunter2@git.example.org/x\n", c.now)
	g14.write(t, project, "big.md", strings.Repeat("x", MemoryMostBytes+1), c.now)
	g14.write(t, project, "hash.md", "head 1fe6ea4ee47379007598e163784dbd7ac50b7f79\n", c.now)
	outside := filepath.Join(t.TempDir(), "elsewhere.md")
	_ = os.WriteFile(outside, []byte("not memory\n"), 0o600)
	if err := os.Symlink(outside, g14.path(project, "link.md")); err != nil {
		t.Fatal(err)
	}
	g14.look(t)
	state.pump(t)
	for _, file := range []string{"key.md", "url.md", "big.md", "link.md"} {
		if _, ok := shanks.read(t, project, file); ok {
			t.Errorf("%s was carried", file)
		}
	}
	for _, file := range []string{"MEMORY.md", "hash.md"} {
		if _, ok := shanks.read(t, project, file); !ok {
			t.Errorf("%s was not carried", file)
		}
	}
	if _, err := os.Stat(filepath.Join(shanks.Home, ".claude", "projects", project, "session.jsonl")); err == nil {
		t.Error("a session was carried")
	}
	for _, f := range []string{"settings.json", "history.jsonl"} {
		if _, err := os.Stat(filepath.Join(shanks.Home, ".claude", f)); err == nil {
			t.Errorf("%s was carried", f)
		}
	}
	keys, _ := state.Keys()
	if len(keys) != 2 {
		t.Fatalf("the state holds %d keys, not the two memory files: %v", len(keys), keys)
	}
	not, _ := g14.Status()["not carried"].(map[string]string)
	for _, file := range []string{"key.md", "url.md", "big.md", "link.md"} {
		if not[project+"/"+file] == "" {
			t.Errorf("%s is not listed as not carried: %v", file, not)
		}
	}
}

// §4: the operator's homes and an agent account's homes never take each other's memory.
func TestHomesOfTheTwoKindsNeverTakeEachOthersMemory(t *testing.T) {
	state, c := newMemState(), &clock{now: time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)}
	root := t.TempDir()
	laptop := newMemNode(t, root, "g14", HomeOperator, state, c)
	control := newMemNode(t, root, "novox", HomeAgent, state, c)
	control.write(t, project, "MEMORY.md", "from a confined agent\n", c.now)
	control.look(t)
	state.pump(t)
	if _, ok := laptop.read(t, project, "MEMORY.md"); ok {
		t.Fatal("a confined agent's memory reached the operator's home")
	}
	laptop.write(t, project, "MEMORY.md", "the operator's\n", c.now)
	laptop.look(t)
	state.pump(t)
	if got, _ := control.read(t, project, "MEMORY.md"); got != "from a confined agent\n" {
		t.Fatalf("the operator's memory reached the agent account's home: %q", got)
	}
	// A value of the other kind put under this kind's key is refused too.
	key := MemoryKey(HomeOperator, project, "x.md")
	raw, _ := json.Marshal(MemoryVersion{Kind: HomeAgent, Project: project, Path: "x.md", Text: "x", Digest: digestOf([]byte("x")), Node: "novox"})
	if err := laptop.Take(key, "put", raw, 99); err == nil {
		t.Fatal("a value of another kind was taken")
	}
	// Which kind a node carries for.
	if k, _ := HomeKind(Paths{Agent: "jochen", Operator: "jochen", Home: "/home/jochen"}); k != HomeOperator {
		t.Fatalf("the operator's own home is %q", k)
	}
	if k, _ := HomeKind(Paths{Agent: "agent", Operator: "jochen", Home: "/home/agent", AgentHome: "/home/agent", OperatorHome: "/home/jochen"}); k != HomeAgent {
		t.Fatalf("an agent account's home is %q", k)
	}
	if k, why := HomeKind(Paths{Agent: "agent", Operator: "jochen", Home: "/home/jochen", AgentHome: "/home/agent", OperatorHome: "/home/jochen"}); k != "" || why == "" {
		t.Fatalf("a confined agent in the operator's home carries %q", k)
	}
}

// §7, §8: a file changed on two nodes since it was carried is kept twice in one file on both, the newer first, with
// one warning; it clears once the file is tidied.
func TestAFileChangedOnTwoNodesIsKeptTwiceTheNewerFirstWithAWarning(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "- base\n")
	g14.write(t, project, "MEMORY.md", "- base\n- learned on g14\n", c.now.Add(time.Minute))
	shanks.write(t, project, "MEMORY.md", "- base\n- learned on shanks\n", c.now.Add(2*time.Minute))
	c.now = c.now.Add(3 * time.Minute)
	g14.look(t)
	shanks.look(t)
	state.pump(t)
	g14.look(t)
	shanks.look(t)
	state.pump(t)
	a, _ := g14.read(t, project, "MEMORY.md")
	b, _ := shanks.read(t, project, "MEMORY.md")
	if a != b {
		t.Fatalf("the nodes did not end on one text:\n%s\n----\n%s", a, b)
	}
	newer, older := strings.Index(a, "learned on shanks"), strings.Index(a, "learned on g14")
	marker := strings.Index(a, "<!-- novox mesh: this file was changed on two nodes")
	if newer < 0 || older < 0 || marker < 0 || !(newer < marker && marker < older) {
		t.Fatalf("not both versions, the newer first, with the line between:\n%s", a)
	}
	if !strings.Contains(a[marker:], "changed on shanks") || !strings.Contains(a[marker:], "changed on g14") {
		t.Fatalf("the line does not name both nodes:\n%s", a)
	}
	notices := append(append([]map[string]any{}, g14.notices...), shanks.notices...)
	if len(notices) != 1 || notices[0]["severity"] != "warning" || notices[0]["clear"] != nil {
		t.Fatalf("not one warning: %v", notices)
	}
	for _, field := range []string{"headline", "explanation", "summary", "resolved"} {
		s, _ := notices[0][field].(string)
		if s == "" || strings.ContainsAny(s, "/~:") && field != "explanation" || strings.Contains(s, ".md") {
			t.Errorf("the warning's %s is empty or names a path: %q", field, s)
		}
		// The plain rule (ADR 0253 §3): it never sends the operator elsewhere.
		if field != "summary" && (strings.Contains(strings.ToLower(s), "agent") || strings.Contains(strings.ToLower(s), "session")) {
			t.Errorf("the warning's %s sends the operator elsewhere: %q", field, s)
		}
	}
	if e, _ := notices[0]["explanation"].(string); !strings.HasPrefix(e, "Needs you: ") {
		t.Errorf("the explanation does not open with its verdict: %q", e)
	}
	if h, _ := notices[0]["headline"].(string); len([]rune(h)) > 60 {
		t.Errorf("the headline is longer than sixty characters: %q", h)
	}
	all := append(g14.copies(t), shanks.copies(t)...)
	for _, v := range []string{"- base\n- learned on g14\n", "- base\n- learned on shanks\n"} {
		if !holdsText(all, v) {
			t.Errorf("the version %q was not kept", v)
		}
	}
	if st := g14.Status(); len(st["conflicts"].([]conflict))+len(shanks.Status()["conflicts"].([]conflict)) != 1 {
		t.Fatalf("the conflict is not listed: %v", st)
	}
	// Tidied on either node, the warning clears.
	c.now = c.now.Add(time.Minute)
	g14.write(t, project, "MEMORY.md", "- base\n- learned on g14\n- learned on shanks\n", c.now)
	g14.look(t)
	state.pump(t)
	cleared := false
	for _, n := range append(g14.notices, shanks.notices...) {
		if n["clear"] == true {
			cleared = true
		}
	}
	if !cleared {
		t.Fatal("the warning did not clear once the file was tidied")
	}
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "- base\n- learned on g14\n- learned on shanks\n" {
		t.Fatalf("the tidied file did not reach shanks: %q", got)
	}
}

// The order of the two versions: the later change first, equal times by node name.
func TestMergeVersionsPutsTheNewerFirst(t *testing.T) {
	at := time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)
	m := string(MergeVersions([]byte("old\n"), "g14", at, []byte("new\n"), "shanks", at.Add(time.Second)))
	if strings.Index(m, "new") > strings.Index(m, "old") {
		t.Fatalf("the newer is not first: %s", m)
	}
	m = string(MergeVersions([]byte("from shanks\n"), "shanks", at, []byte("from ace\n"), "ace", at))
	if strings.Index(m, "from ace") > strings.Index(m, "from shanks") {
		t.Fatalf("equal times are not ordered by node name: %s", m)
	}
}

// §9: a removal moves the other node's unchanged file into the copies.
func TestARemovalMovesTheUnchangedFileIntoTheCopies(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "old.md", "an old note\n")
	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
	if err := os.Remove(g14.path(project, "old.md")); err != nil {
		t.Fatal(err)
	}
	g14.look(t)
	state.pump(t)
	if _, ok := shanks.read(t, project, "old.md"); ok {
		t.Fatal("the removal did not reach shanks")
	}
	if !holdsText(shanks.copies(t), "an old note\n") {
		t.Fatal("the removed version was not kept on shanks")
	}
	raw, _, ok, _ := state.Get(MemoryKey(HomeOperator, project, "old.md"))
	var v MemoryVersion
	_ = json.Unmarshal(raw, &v)
	if !ok || !v.Removed || v.Text != "" {
		t.Fatalf("the removal is not a marker in the state: %s", raw)
	}
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
		t.Fatal("another file was touched")
	}
}

// §9: a change outlives a removal, whichever reaches the state first.
func TestAChangeOutlivesARemoval(t *testing.T) {
	for _, removalFirst := range []bool{true, false} {
		state, c, g14, shanks := twoNodes(t)
		carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
		_ = os.Remove(g14.path(project, "note.md"))
		shanks.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
		if removalFirst {
			g14.look(t)
			state.pump(t)
			shanks.look(t)
		} else {
			shanks.look(t)
			g14.look(t)
		}
		state.pump(t)
		g14.look(t)
		shanks.look(t)
		state.pump(t)
		for _, n := range []*memNode{g14, shanks} {
			if got, _ := n.read(t, project, "note.md"); got != "v2\n" {
				t.Fatalf("removal first %v: the change did not outlive the removal on %s: %q", removalFirst, n.Node, got)
			}
		}
	}
}

// §9: a missing folder, a state that lost its keys and a deleted key remove nothing.
func TestAMissingFolderOrAnAbsentKeyRemovesNothing(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
	key := MemoryKey(HomeOperator, project, "MEMORY.md")
	// The folder gone on g14.
	if err := os.RemoveAll(filepath.Join(g14.Home, ".claude", "projects", project, "memory")); err != nil {
		t.Fatal(err)
	}
	g14.look(t)
	state.pump(t)
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
		t.Fatal("a missing folder removed the file elsewhere")
	}
	// A deleted key.
	_ = state.Delete(key)
	state.pump(t)
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
		t.Fatal("a deleted key removed the file")
	}
	// The state lost: the file is carried again, not removed.
	shanks.look(t)
	state.pump(t)
	if _, _, ok, _ := state.Get(key); !ok {
		t.Fatal("a file whose key the state lost was not carried again")
	}
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
		t.Fatalf("the file was touched on shanks: %q", got)
	}
}

// §10: on a first carrying, two nodes' different versions are both kept, and each node's own files reach the other.
func TestTheFirstCarryingKeepsEveryVersion(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	g14.write(t, project, "MEMORY.md", "- laptop's index\n", c.now)
	g14.write(t, project, "laptop.md", "only on the laptop\n", c.now)
	shanks.write(t, project, "MEMORY.md", "- workstation's index\n", c.now.Add(time.Hour))
	shanks.write(t, project, "workstation.md", "only on the workstation\n", c.now)
	shanks.write(t, project, "same.md", "same\n", c.now)
	g14.write(t, project, "same.md", "same\n", c.now)
	g14.look(t)
	state.pump(t)
	shanks.look(t)
	state.pump(t)
	g14.look(t)
	state.pump(t)
	for _, n := range []*memNode{g14, shanks} {
		index, _ := n.read(t, project, "MEMORY.md")
		if !strings.Contains(index, "laptop's index") || !strings.Contains(index, "workstation's index") ||
			strings.Index(index, "workstation's index") > strings.Index(index, "laptop's index") {
			t.Fatalf("%s's index does not hold both, the newer first:\n%s", n.Node, index)
		}
		for file, want := range map[string]string{"laptop.md": "only on the laptop\n", "workstation.md": "only on the workstation\n", "same.md": "same\n"} {
			if got, _ := n.read(t, project, file); got != want {
				t.Fatalf("%s's %s: %q", n.Node, file, got)
			}
		}
	}
	if n := len(g14.notices) + len(shanks.notices); n != 1 {
		t.Fatalf("%d warnings for one conflict", n)
	}
}

// Nothing is written through a symbolic link: a memory folder that is one is neither read nor written.
func TestNothingIsWrittenThroughASymbolicLink(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	elsewhere := t.TempDir()
	if err := os.MkdirAll(filepath.Join(shanks.Home, ".claude", "projects", project), 0o700); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink(elsewhere, filepath.Join(shanks.Home, ".claude", "projects", project, "memory")); err != nil {
		t.Fatal(err)
	}
	g14.write(t, project, "MEMORY.md", "index\n", c.now)
	g14.look(t)
	state.pump(t)
	if entries, _ := os.ReadDir(elsewhere); len(entries) != 0 {
		t.Fatalf("written through a symbolic link: %v", entries)
	}
}

// The manifest declares the state and the tool; the tool reads and never writes.
func TestTheManifestDeclaresTheMemoryState(t *testing.T) {
	raw, err := os.ReadFile("../../module.json")
	if err != nil {
		t.Fatal(err)
	}
	var m struct {
		State []string `json:"state"`
	}
	_ = json.Unmarshal(raw, &m)
	if !holdsText(m.State, MemoryState) {
		t.Fatalf("the manifest does not declare the %q state: %v", MemoryState, m.State)
	}
	var carrier *MemoryCarrier
	if st := carrier.Status(); st["carrying"] != false {
		t.Fatalf("a carrier not started says it carries: %v", st)
	}
}

// replay hands one node the whole current set, as a watch begins when the node comes back.
func (s *memState) replay(t *testing.T, n *memNode) {
	t.Helper()
	keys, _ := s.Keys()
	for _, k := range keys {
		raw, rev, _, _ := s.Get(k)
		if err := n.Take(k, "put", raw, rev); err != nil {
			t.Logf("%s taking %s: %v", n.Node, k, err)
		}
	}
	if err := n.Drain(); err != nil && !errors.Is(err, errChanged) {
		t.Logf("%s applying: %v", n.Node, err)
	}
}

// §6: a node that was away while a file changed twice takes the newest version, whose base it never saw, because
// its own file holds no change it did not carry; the version replaced is kept.
func TestANodeThatWasAwayTakesTheNewestVersion(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "v1\n")
	state.watchers = []*MemoryCarrier{g14.MemoryCarrier}
	for _, v := range []string{"v2\n", "v3\n"} {
		c.now = c.now.Add(time.Minute)
		g14.write(t, project, "MEMORY.md", v, c.now)
		g14.look(t)
		state.pump(t)
	}
	state.watchers = append(state.watchers, shanks.MemoryCarrier)
	state.replay(t, shanks)
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "v3\n" {
		t.Fatalf("the node that was away holds %q", got)
	}
	if !holdsText(shanks.copies(t), "v1\n") {
		t.Fatal("the version replaced was not kept")
	}
	if len(g14.notices)+len(shanks.notices) != 0 {
		t.Fatal("taking a newer version warned")
	}
}

// §2, §7: two versions too large to share one file are kept in two: the newer in the file, the older beside it,
// both carried; and a text that would not fit in one value of the state is not carried.
func TestTwoVersionsTooLargeForOneFileAreKeptInTwo(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "big.md", "base\n")
	older := strings.Repeat("from g14 ", MemoryMostBytes/9-100) + "\n"
	newer := strings.Repeat("from shanks ", MemoryMostBytes/12-100) + "\n"
	g14.write(t, project, "big.md", older, c.now.Add(time.Minute))
	shanks.write(t, project, "big.md", newer, c.now.Add(2*time.Minute))
	c.now = c.now.Add(3 * time.Minute)
	g14.look(t)
	shanks.look(t)
	state.pump(t)
	g14.look(t)
	shanks.look(t)
	state.pump(t)
	beside := OlderBeside("big.md", "g14")
	if beside != "big.older-from-g14.md" {
		t.Fatalf("the older is named %q", beside)
	}
	for _, n := range []*memNode{g14, shanks} {
		if got, _ := n.read(t, project, "big.md"); got != newer {
			t.Fatalf("%s's file does not hold the newer version", n.Node)
		}
		if got, _ := n.read(t, project, beside); got != older {
			t.Fatalf("%s does not hold the older version beside it", n.Node)
		}
	}
	notices := append(append([]map[string]any{}, g14.notices...), shanks.notices...)
	if len(notices) != 1 || !strings.Contains(notices[0]["explanation"].(string), "second file beside it") {
		t.Fatalf("not one warning saying the older is beside it: %v", notices)
	}
	// Under the size limit, but too large once encoded: not carried, and said.
	g14.write(t, project, "angles.md", strings.Repeat("<", MemoryMostBytes-10), c.now)
	g14.look(t)
	state.pump(t)
	if _, ok := shanks.read(t, project, "angles.md"); ok {
		t.Fatal("a text too large for one value was carried")
	}
	not, _ := g14.Status()["not carried"].(map[string]string)
	if not[project+"/angles.md"] == "" {
		t.Fatalf("it is not listed as not carried: %v", not)
	}
}

// stateHolds says whether any value of the state holds s.
func (s *memState) holds(sub string) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	for _, v := range s.values {
		var mv MemoryVersion
		_ = json.Unmarshal(v, &mv)
		if strings.Contains(mv.Text, sub) {
			return true
		}
	}
	return false
}

// putRaw puts a value straight into the state, as a holder of a tool runner's credential could.
func (s *memState) putRaw(t *testing.T, v MemoryVersion) string {
	t.Helper()
	key := MemoryKey(v.Kind, v.Project, v.Path)
	s.mu.Lock()
	s.write(key, v)
	s.mu.Unlock()
	return key
}

// Review of #276, 1: a value whose project or path leads out of a memory folder is never taken, and nothing is
// written for it.
func TestAValueLeadingOutOfAMemoryFolderIsNeverTaken(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	root := filepath.Dir(filepath.Dir(shanks.Home))
	for _, bad := range []struct{ project, path string }{
		{"../../../escaped", "x.md"}, {"..", "x.md"}, {"a/b", "x.md"}, {"", "x.md"},
		{project, "../x.md"}, {project, "/abs.md"}, {project, "a//x.md"}, {project, "./x.md"}, {project, "a/../../x.md"},
	} {
		text := "planted\n"
		state.putRaw(t, MemoryVersion{Kind: HomeOperator, Project: bad.project, Path: bad.path, Text: text,
			Digest: digestOf([]byte(text)), Node: "elsewhere", Changed: c.now})
		if NameProblem(bad.project, bad.path) == "" {
			t.Errorf("%q %q is taken as a name", bad.project, bad.path)
		}
	}
	state.pump(t)
	g14.look(t)
	shanks.look(t)
	_ = filepath.WalkDir(root, func(p string, d os.DirEntry, err error) error {
		if err == nil && !d.IsDir() {
			if raw, _ := os.ReadFile(p); string(raw) == "planted\n" {
				t.Errorf("a planted value was written at %s", p)
			}
		}
		return nil
	})
	if NameProblem(project, "notes/a.md") != "" || NameProblem(project, "MEMORY.md") != "" {
		t.Fatal("a memory file's own name is refused")
	}
}

// Review of #276, 2: a file or a folder that cannot be read is kept everywhere, never carried as a removal, and is
// said as not carried.
func TestWhatCannotBeReadIsNeverTakenForGone(t *testing.T) {
	if os.Geteuid() == 0 {
		t.Skip("root reads a file whatever its mode")
	}
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
	carriedOnBoth(t, state, c, g14, shanks, "notes/deep.md", "deep\n")
	file, folder := g14.path(project, "MEMORY.md"), filepath.Dir(g14.path(project, "notes/deep.md"))
	_ = os.Chmod(file, 0)
	_ = os.Chmod(folder, 0)
	t.Cleanup(func() { _ = os.Chmod(file, 0o644); _ = os.Chmod(folder, 0o755) })
	g14.look(t)
	state.pump(t)
	for _, f := range []string{"MEMORY.md", "notes/deep.md"} {
		if _, ok := shanks.read(t, project, f); !ok {
			t.Errorf("%s, unreadable on g14, was removed on shanks", f)
		}
	}
	not, _ := g14.Status()["not carried"].(map[string]string)
	if len(not) == 0 {
		t.Fatalf("nothing is said as not carried: %v", not)
	}
	keys, _ := state.Keys()
	for _, k := range keys {
		raw, _, _, _ := state.Get(k)
		var v MemoryVersion
		_ = json.Unmarshal(raw, &v)
		if v.Removed {
			t.Errorf("%s/%s was carried as a removal", v.Project, v.Path)
		}
	}
}

// Review of #276, 3: no text reaches the state without being screened, on the removal and the conflict paths too.
func TestNoUnscreenedTextReachesTheState(t *testing.T) {
	token := "ghp_" + strings.Repeat("A1b2C3d4", 5) + "\n"
	big := strings.Repeat("x", MemoryMostBytes+10) + "\n"
	for _, text := range []string{token, big} {
		// The removal path: removed on g14, changed on shanks to what is never carried.
		state, c, g14, shanks := twoNodes(t)
		carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
		_ = os.Remove(g14.path(project, "note.md"))
		shanks.write(t, project, "note.md", text, c.now.Add(time.Minute))
		g14.look(t)
		state.pump(t)
		if state.holds(text[:20]) {
			t.Errorf("the removal path put text that is never carried into the state")
		}
		if got, _ := shanks.read(t, project, "note.md"); got != text {
			t.Errorf("the change on shanks was not kept")
		}
		// The conflict path: changed on g14, and on shanks to what is never carried.
		state, c, g14, shanks = twoNodes(t)
		carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
		g14.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
		shanks.write(t, project, "note.md", text, c.now.Add(2*time.Minute))
		g14.look(t)
		state.pump(t)
		shanks.look(t)
		state.pump(t)
		if state.holds(text[:20]) {
			t.Errorf("the conflict path put text that is never carried into the state")
		}
		if got, _ := shanks.read(t, project, "note.md"); got != text {
			t.Errorf("shanks's own version was not kept as it was")
		}
	}
}

// Review of #276, 4: a conflict whose file cannot be written leaves the state as it was, says so once, and merges
// once when the folder is writable again.
func TestAConflictThatCannotBeWrittenIsNotMergedAgainAndAgain(t *testing.T) {
	if os.Geteuid() == 0 {
		t.Skip("root writes a folder whatever its mode")
	}
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "base\n")
	g14.write(t, project, "MEMORY.md", "base\nfrom g14\n", c.now.Add(time.Minute))
	shanks.write(t, project, "MEMORY.md", "base\nfrom shanks\n", c.now.Add(2*time.Minute))
	folder := filepath.Dir(shanks.path(project, "MEMORY.md"))
	_ = os.Chmod(folder, 0o500)
	t.Cleanup(func() { _ = os.Chmod(folder, 0o700) })
	g14.look(t)
	state.pump(t)
	for i := 0; i < 5; i++ {
		_ = shanks.Look()
		state.pump(t)
	}
	if state.holds("<!-- novox mesh") {
		t.Fatal("a merge that could not be written here reached the state")
	}
	unwritten := 0
	for _, n := range shanks.notices {
		if strings.HasSuffix(n["key"].(string), ".unwritten") {
			unwritten++
		}
	}
	if unwritten != 1 {
		t.Fatalf("%d warnings that the file could not be written", unwritten)
	}
	_ = os.Chmod(folder, 0o700)
	shanks.look(t)
	state.pump(t)
	g14.look(t)
	state.pump(t)
	for _, n := range []*memNode{g14, shanks} {
		got, _ := n.read(t, project, "MEMORY.md")
		if strings.Count(got, "<!-- novox mesh") != 1 || !strings.Contains(got, "from g14") || !strings.Contains(got, "from shanks") {
			t.Fatalf("%s does not hold both versions once:\n%s", n.Node, got)
		}
	}
}

// Review of #276, minor: a file that changed between its reading and its writing is not written over; text that is
// not UTF-8 is not carried.
func TestAFileChangedBeforeItsWritingIsNotWrittenOver(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	_ = state
	g14.write(t, project, "a.md", "read\n", c.now)
	g14.write(t, project, "a.md", "changed meanwhile\n", c.now)
	err := g14.writeLocal(project, "a.md", []byte("incoming\n"), "replaced", digestOf([]byte("read\n")))
	if !errors.Is(err, errChangedHere) {
		t.Fatalf("written over a change: %v", err)
	}
	if got, _ := g14.read(t, project, "a.md"); got != "changed meanwhile\n" {
		t.Fatalf("the change was replaced: %q", got)
	}
	g14.write(t, project, "latin1.md", "caf\xe9\n", c.now)
	g14.look(t)
	state.pump(t)
	if _, ok := shanks.read(t, project, "latin1.md"); ok {
		t.Fatal("text that is not UTF-8 was carried")
	}
	not, _ := g14.Status()["not carried"].(map[string]string)
	if !strings.Contains(not[project+"/latin1.md"], "UTF-8") {
		t.Fatalf("it is not said why: %v", not)
	}
}

// §9: a node that was away takes a removal of a version newer than the one it holds, when it holds no change of
// its own: the removed file does not come back.
func TestARemovalReachesANodeThatWasAway(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	carriedOnBoth(t, state, c, g14, shanks, "old.md", "v1\n")
	state.watchers = []*MemoryCarrier{g14.MemoryCarrier}
	c.now = c.now.Add(time.Minute)
	g14.write(t, project, "old.md", "v2\n", c.now)
	g14.look(t)
	state.pump(t)
	_ = os.Remove(g14.path(project, "old.md"))
	g14.look(t)
	state.pump(t)
	state.watchers = append(state.watchers, shanks.MemoryCarrier)
	state.replay(t, shanks)
	shanks.look(t)
	state.pump(t)
	g14.look(t)
	if _, ok := shanks.read(t, project, "old.md"); ok {
		t.Fatal("the removal did not reach the node that was away")
	}
	if _, ok := g14.read(t, project, "old.md"); ok {
		t.Fatal("the removed file came back")
	}
	if !holdsText(shanks.copies(t), "v1\n") {
		t.Fatal("the version removed on the node that was away was not kept")
	}
}

// slowState answers every read only once it is let go, as a state a whole bus away does under load.
type slowState struct {
	*memState
	gate chan struct{}
}

func (s slowState) Get(key string) (json.RawMessage, uint64, bool, error) {
	<-s.gate
	return s.memState.Get(key)
}

// Issue 367, seen live: the runtime hands a watch its current values one at a time and gives them all ten seconds;
// shanks's handler read the state and waited for its look for each of a few hundred values, so the watch never
// started and nothing written on g14 reached it. The handler now only notes a change: it returns at once while a
// look holds the carrier and while the state is slow to answer, and Drain applies what it noted.
func TestTheWatchHandlerReturnsAtOnceAndDrainAppliesWhatItNoted(t *testing.T) {
	state, c, g14, shanks := twoNodes(t)
	g14.write(t, project, "MEMORY.md", "index\n", c.now)
	g14.look(t)
	state.mu.Lock()
	state.pending = nil
	state.mu.Unlock()
	slow := slowState{memState: state, gate: make(chan struct{})}
	shanks.Store = slow
	key := MemoryKey(HomeOperator, project, "MEMORY.md")
	raw, rev, _, _ := state.Get(key)
	shanks.mu.Lock() // a look running
	done := make(chan error, 1)
	start := time.Now()
	for i := 0; i < 400; i++ {
		go func() { done <- shanks.Take(key, "put", raw, rev) }()
	}
	for i := 0; i < 400; i++ {
		select {
		case err := <-done:
			if err != nil {
				t.Fatal(err)
			}
		case <-time.After(2 * time.Second):
			t.Fatalf("the watch handler waited for the look or the state (%d of 400 returned)", i)
		}
	}
	if took := time.Since(start); took > time.Second {
		t.Fatalf("400 values took %s to hand over", took)
	}
	shanks.mu.Unlock()
	close(slow.gate)
	if err := shanks.Drain(); err != nil {
		t.Fatal(err)
	}
	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
		t.Fatalf("what the watch noted was not applied: %q", got)
	}
}