package cluster

import (
	"context"
	"testing"

	"webui4frpc/internal/store"
)

// Helper: build an engine for tests.
func newTestEngine(id string, isLeader bool) *Engine {
	return NewEngine(id, id+":7500", "u", "p", "0.1.0", nil,
		&fakeHandler{load: Load{MemPct: 20, NetPct: 20}},
		func(ctx context.Context, next string, tk *Token) error { return nil },
		id+":7500", isLeader, "")
}

// TestLogAppendDeltaReplay: append entries, extract delta after a watermark,
// replay on another node idempotently + in order.
func TestLogAppendDeltaReplay(t *testing.T) {
	l := NewClusterLog()
	if _, err := l.Append("n1", LogForwardAdd, map[string]string{"k": "v"}); err != nil {
		t.Fatal(err)
	}
	e2, _ := l.Append("n1", LogNodeJoin, nil)
	if e2.Seq != 2 {
		t.Fatalf("seq = %d want 2", e2.Seq)
	}

	dst := NewClusterLog()
	if _, err := dst.ApplyDelta(l.EntriesAfter(0)); err != nil {
		t.Fatalf("apply: %v", err)
	}
	if len(dst.Snapshot()) != 2 {
		t.Fatalf("dst log = %+v", dst.Snapshot())
	}
	if _, err := dst.ApplyDelta(l.EntriesAfter(0)); err != nil {
		t.Fatalf("idempotent apply: %v", err)
	}
	if len(dst.Snapshot()) != 2 {
		t.Fatalf("dedupe failed: %+v", dst.Snapshot())
	}
}

// TestLogGapDetection: a delta with a seq gap must error.
func TestLogGapDetection(t *testing.T) {
	l := NewClusterLog()
	if _, err := l.ApplyDelta([]LogEntry{{Seq: 1, Kind: LogNodeJoin}, {Seq: 3, Kind: LogForwardAdd}}); err == nil {
		t.Fatal("expected gap error, got nil")
	}
}

// TestLogAfterWatermark: delta only includes entries newer than watermark.
func TestLogAfterWatermark(t *testing.T) {
	l := NewClusterLog()
	_, _ = l.Append("a", LogNodeJoin, nil)
	_, _ = l.Append("a", LogForwardAdd, nil)
	after := l.EntriesAfter(1)
	if len(after) != 1 || after[0].Seq != 2 {
		t.Fatalf("after(1) = %+v want [seq 2]", after)
	}
}

// TestClaimLogsToEngine: a claimed task appends LogForwardAdd to engine log.
func TestClaimLogsToEngine(t *testing.T) {
	eng := newTestEngine("n1", true)
	eng.state.AddPending(store.Local{Name: "l1"}, store.Remote{Name: "r1"}, store.Link{})
	out, err := eng.OnToken(context.Background(), &Token{Cycle: 1, State: eng.state})
	if err != nil {
		t.Fatal(err)
	}
	if out == nil {
		t.Fatal("nil token after OnToken")
	}
	snap := eng.Log.Snapshot()
	if len(snap) != 1 || snap[0].Kind != LogForwardAdd {
		t.Fatalf("engine log = %+v", snap)
	}
}