package view

import (
	"errors"
	"reflect"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-sdk/go/delivery"
)

var t0 = time.Date(2026, 10, 18, 12, 0, 0, 0, time.UTC)

func have(t *testing.T, build string, phase delivery.Phase, health delivery.Health, detail string) []byte {
	t.Helper()
	b, err := delivery.EncodeHave(delivery.Have{Build: build, Phase: phase, Health: health, Detail: detail})
	if err != nil {
		t.Fatal(err)
	}
	return b
}

func haveE(t *testing.T, node, module string, v []byte, at time.Time) Entry {
	return Entry{Bucket: delivery.HaveBucket, Key: node + "." + module, Value: v, At: at}
}

// place is the seat's placement of node, as the assigner keeps it (ADR 0567): the modules placed there.
func place(t *testing.T, node string, modules ...string) Entry {
	t.Helper()
	p := delivery.Placement{Node: node}
	for _, m := range modules {
		p.Modules = append(p.Modules, delivery.PlacedModule{Module: m})
	}
	key, err := delivery.PlacementKey(node)
	if err != nil {
		t.Fatal(err)
	}
	v, err := delivery.EncodePlacement(p)
	if err != nil {
		t.Fatal(err)
	}
	return Entry{Bucket: delivery.PlacementBucket, Key: key, Value: v, At: t0}
}

func buildRec(module, id, extra string) []Entry {
	rec := `{"id":"` + id + `","module":"` + module + `","commit":"c"` + extra + `}`
	return []Entry{
		{Bucket: BuildsBucket, Key: module + ".build." + id, Value: []byte(rec), At: t0},
		{Bucket: BuildsBucket, Key: module + ".newest", Value: []byte(id), At: t0},
	}
}

func find(t *testing.T, s Snapshot, node, module string) Row {
	t.Helper()
	for _, r := range s.Rows {
		if r.Node == node && r.Module == module {
			return r
		}
	}
	t.Fatalf("no row for %s.%s in %+v", node, module, s.Rows)
	return Row{}
}

func fill(m *Model, es ...Entry) {
	for _, e := range es {
		m.Apply(e)
	}
}

// base: two nodes (a, b), three modules (x, y, z).
func base(t *testing.T) []Entry {
	es := []Entry{
		place(t, "a", "x", "y"), place(t, "b", "x", "z"),
		haveE(t, "a", "x", have(t, "b1", delivery.PhaseRunning, delivery.HealthOK, ""), t0.Add(1*time.Minute)),
		haveE(t, "b", "x", have(t, "b1", delivery.PhaseChecking, delivery.HealthWaits, "starting"), t0.Add(2*time.Minute)),
		haveE(t, "b", "z", have(t, "b3", delivery.PhaseRunning, delivery.HealthOK, ""), t0.Add(3*time.Minute)),
	}
	es = append(es, buildRec("x", "b1", "")...)
	es = append(es, buildRec("y", "b2", "")...)
	es = append(es, buildRec("z", "b3", "")...)
	return es
}

func TestRowsPerAssignedModuleAndNode(t *testing.T) { // 1134/AC1
	m := New()
	fill(m, base(t)...)
	s := m.Snapshot()
	if len(s.Rows) != 4 || s.Counted() != 4 {
		t.Fatalf("want 4 rows, got %d counted %d: %+v", len(s.Rows), s.Counted(), s.Rows)
	}
	r := find(t, s, "b", "x")
	want := Row{Node: "b", Module: "x", Status: StatusAssigned, Have: "b1", Phase: "checking", Health: "waits",
		Since: t0.Add(2 * time.Minute), Detail: "starting"}
	if !reflect.DeepEqual(r, want) {
		t.Fatalf("row = %+v, want %+v", r, want)
	}
	y := find(t, s, "a", "y")
	if y.Waits != "no have yet" || y.Have != "" {
		t.Fatalf("a.y = %+v, want 'no have yet'", y)
	}
}

func TestLeftBehindIsWhatThePlacementDoesNotPut(t *testing.T) { // 1134/AC3, issue 774 (the seat's placement)
	m := New()
	fill(m, base(t)...)
	fill(m, place(t, "b", "x")) // z taken off b
	s := m.Snapshot()
	if r := find(t, s, "b", "z"); r.Status != StatusLeftBehind || s.Counted() != 3 {
		t.Errorf("status = %q counted %d, want %q and 3", r.Status, s.Counted(), StatusLeftBehind)
	}
	m = New()
	fill(m, base(t)...)
	fill(m, haveE(t, "a", "w", have(t, "b9", delivery.PhaseRunning, delivery.HealthOK, ""), t0)) // placed nowhere
	s = m.Snapshot()
	if find(t, s, "a", "w").Status != StatusLeftBehind || s.Counted() != 4 {
		t.Fatalf("a have with no placement: %+v counted %d", find(t, s, "a", "w"), s.Counted())
	}
	fill(m, Entry{Bucket: delivery.PlacementBucket, Key: "placement.b", Deleted: true})
	if s := m.Snapshot(); s.Counted() != 2 || find(t, s, "b", "x").Status != StatusLeftBehind {
		t.Fatalf("b's placement deleted: counted %d, %+v", s.Counted(), s.Rows)
	}
}

func TestUnknownVersionSaysSo(t *testing.T) { // 1134/AC4
	m := New()
	fill(m, base(t)...)
	before := m.Snapshot()
	fill(m, haveE(t, "a", "x", []byte(`{"v":9,"phase":"running","health":"ok"}`), t0))
	s := m.Snapshot()
	r := find(t, s, "a", "x")
	_, sdkErr := delivery.DecodeHave([]byte(`{"v":9,"phase":"running","health":"ok"}`))
	if !errors.Is(sdkErr, delivery.ErrUnknownVersion) {
		t.Fatal("test premise: the SDK must refuse version 9")
	}
	if r.Error != sdkErr.Error() || !strings.Contains(r.Error, "version 9") {
		t.Fatalf("error = %q, want the SDK's %q", r.Error, sdkErr)
	}
	if r.Have != "" || r.Phase != "" || r.Health != "" {
		t.Fatalf("an unreadable have must not be guessed: %+v", r)
	}
	for _, n := range [][2]string{{"a", "y"}, {"b", "x"}, {"b", "z"}} {
		if !reflect.DeepEqual(find(t, s, n[0], n[1]), find(t, before, n[0], n[1])) {
			t.Errorf("row %s.%s changed", n[0], n[1])
		}
	}
}

func TestOnlyTheAffectedRowChanges(t *testing.T) { // 1134/AC5
	m := New()
	fill(m, base(t)...)
	before := m.Snapshot()
	fill(m, haveE(t, "b", "x", have(t, "b1", delivery.PhaseRunning, delivery.HealthOK, ""), t0.Add(9*time.Minute)))
	after := m.Snapshot()
	for i := range before.Rows {
		changed := !reflect.DeepEqual(before.Rows[i], after.Rows[i])
		if changed != (before.Rows[i].Node == "b" && before.Rows[i].Module == "x") {
			t.Errorf("row %s.%s changed = %v", before.Rows[i].Node, before.Rows[i].Module, changed)
		}
	}
	if r := find(t, after, "b", "x"); r.Phase != "running" || r.Health != "ok" || !r.Since.Equal(t0.Add(9*time.Minute)) {
		t.Fatalf("changed row = %+v", r)
	}
	// a want's change touches only its row
	fill(m, wantE(t, "a", "y", delivery.Want{FP: fpNew}))
	if r := find(t, m.Snapshot(), "a", "y"); r.Assigned != fpNew {
		t.Fatalf("want change not seen: %+v", r)
	}
	if !reflect.DeepEqual(find(t, m.Snapshot(), "b", "z"), find(t, after, "b", "z")) {
		t.Fatal("a want of another row changed b.z")
	}
	// a deleted key (a bucket's expiry) removes its value
	m.Apply(Entry{Bucket: delivery.HaveBucket, Key: "a.x", Deleted: true})
	if !strings.HasPrefix(find(t, m.Snapshot(), "a", "x").Waits, "no have yet") {
		t.Fatal("a deleted have must read as no have")
	}
	// a restart rebuilds the same rows from last values
	a, b := New(), New()
	es := base(t)
	fill(a, es...)
	fill(b, es...)
	if !reflect.DeepEqual(a.Snapshot(), b.Snapshot()) {
		t.Fatal("the same last values must give the same rows")
	}
}

func TestNodeRow(t *testing.T) { // 1134/AC1 (the node's own key gives a node row)
	m := New()
	v, _ := delivery.EncodeHaveNode(delivery.HaveNode{Windows: []byte(`[1,2]`), Busy: []byte(`{"a":1}`), Strays: []byte(`[]`)})
	fill(m, Entry{Bucket: delivery.HaveBucket, Key: "a.node", Value: v, At: t0})
	n := m.Snapshot().Nodes
	if len(n) != 1 || n[0].Node != "a" || n[0].Windows != 2 || n[0].Busy != 1 || n[0].Strays != 0 {
		t.Fatalf("nodes = %+v", n)
	}
}

func presenceE(t *testing.T, key string, online bool, at time.Time) Entry {
	t.Helper()
	b, err := delivery.EncodePresence(delivery.Presence{Online: online})
	if err != nil {
		t.Fatal(err)
	}
	return Entry{Bucket: delivery.PresenceBucket, Key: key, Value: b, At: at}
}

func stuckE(t *testing.T, bucket, key, waited string, since time.Time, moved bool) Entry {
	t.Helper()
	b, err := delivery.EncodeStuck(delivery.Stuck{Bucket: bucket, Key: key, Waited: waited, Since: since, Moved: moved})
	if err != nil {
		t.Fatal(err)
	}
	return Entry{Bucket: delivery.StuckBucket, Key: bucket + "." + key, Value: b, At: since}
}

func TestOfflineAndStuckAreListed(t *testing.T) { // 1168/AC2
	m := New()
	fill(m, base(t)...)
	fill(m,
		presenceE(t, "a", false, t0),
		presenceE(t, "b", true, t0),
		presenceE(t, "part.mesh-delivery-view.i1", false, t0.Add(time.Minute)),
		stuckE(t, "node-engine_have", "a.x", "a report from a", t0.Add(2*time.Minute), false),
		stuckE(t, "node-engine_have", "b.x", "a report from b", t0, true),
	)
	s := m.Snapshot()
	want := []OfflineRow{{Kind: "node", Node: "a", Since: t0}, {Kind: "part", Part: "mesh-delivery-view", Instance: "i1", Since: t0.Add(time.Minute)}}
	if !reflect.DeepEqual(s.Offline, want) {
		t.Fatalf("offline = %+v, want %+v", s.Offline, want)
	}
	wantStuck := []StuckRow{{Bucket: "node-engine_have", Key: "a.x", Waited: "a report from a", Since: t0.Add(2 * time.Minute)}}
	if !reflect.DeepEqual(s.Stuck, wantStuck) {
		t.Fatalf("stuck = %+v, want %+v", s.Stuck, wantStuck)
	}
	// back online and moved leave the lists
	fill(m, presenceE(t, "a", true, t0.Add(5*time.Minute)), presenceE(t, "part.mesh-delivery-view.i1", true, t0.Add(5*time.Minute)),
		stuckE(t, "node-engine_have", "a.x", "a report from a", t0.Add(2*time.Minute), true))
	s = m.Snapshot()
	if len(s.Offline) != 0 || len(s.Stuck) != 0 {
		t.Fatalf("offline %+v stuck %+v, want both empty", s.Offline, s.Stuck)
	}
}

func TestUnknownWatchmanVersionIsUnreadableNotDropped(t *testing.T) { // 1168/AC3
	m := New()
	fill(m,
		Entry{Bucket: delivery.PresenceBucket, Key: "c", Value: []byte(`{"v":9,"online":false}`), At: t0},
		Entry{Bucket: delivery.StuckBucket, Key: "node-engine_have.c.x", Value: []byte(`{"v":9}`), At: t0},
		presenceE(t, "a", false, t0),
	)
	s := m.Snapshot()
	if len(s.Unreadable) != 2 || len(s.Offline) != 1 {
		t.Fatalf("unreadable %+v offline %+v", s.Unreadable, s.Offline)
	}
	_, sdkErr := delivery.DecodePresence([]byte(`{"v":9,"online":false}`))
	var got *UnreadableRow
	for i := range s.Unreadable {
		if s.Unreadable[i].Key == "c" {
			got = &s.Unreadable[i]
		}
	}
	if got == nil || got.Bucket != delivery.PresenceBucket || got.Error != sdkErr.Error() {
		t.Fatalf("unreadable = %+v, want key c with the SDK's error %q", s.Unreadable, sdkErr)
	}
	// a good value later replaces the unreadable one
	fill(m, presenceE(t, "c", true, t0))
	if len(m.Snapshot().Unreadable) != 1 {
		t.Fatal("a readable value must clear the unreadable mark")
	}
}