package transport

import (
	"testing"
)

func TestKnockForMinuteDeterministicAndMinuteSensitive(t *testing.T) {
	var k [32]byte
	for i := range k {
		k[i] = byte(i)
	}
	a := KnockForMinute(k, 1_000_000)
	b := KnockForMinute(k, 1_000_000)
	if a != b {
		t.Fatalf("same inputs gave different output: %x vs %x", a, b)
	}
	c := KnockForMinute(k, 1_000_001)
	if a == c {
		t.Fatalf("different minute gave same output: %x", c)
	}
	var k2 [32]byte
	copy(k2[:], k[:])
	k2[0] ^= 1
	d := KnockForMinute(k2, 1_000_000)
	if a == d {
		t.Fatalf("different key gave same output: %x", d)
	}
}

func TestReorderBufferDeliversInSequenceOrder(t *testing.T) {
	a := newHSAdapter(nil, DefaultOptions())
	// Direct manipulation of the adapter's reorder buffer mimicking the Rust unit test
	// `reorder_buffer_delivers_in_sequence_order`.
	a.acceptIncoming(2, []byte("ccc"))
	a.acceptIncoming(1, []byte("bbb"))
	if len(a.ready) != 0 {
		t.Fatalf("contiguous run unexpectedly emitted: %x", a.ready)
	}
	a.acceptIncoming(0, []byte("aaa"))
	if string(a.ready) != "aaabbbccc" {
		t.Fatalf("delivery order wrong: %s", a.ready)
	}
	if a.nextDeliverSeq != 3 {
		t.Fatalf("contig counter wrong: %d", a.nextDeliverSeq)
	}
}

func TestDuplicateDatagramsAreDropped(t *testing.T) {
	a := newHSAdapter(nil, DefaultOptions())
	a.acceptIncoming(0, []byte("x"))
	a.acceptIncoming(0, []byte("x"))
	if string(a.ready) != "x" {
		t.Fatalf("duplicate retransmit double-counted: %s", a.ready)
	}
	a.acceptIncoming(2, []byte("z"))
	a.acceptIncoming(2, []byte("z"))
	a.acceptIncoming(1, []byte("y"))
	if string(a.ready) != "xyz" {
		t.Fatalf("delivery wrong with duplicates: %s", a.ready)
	}
}

func TestAckUptoReportsHighestContiguousOrSentinel(t *testing.T) {
	a := newHSAdapter(nil, DefaultOptions())
	if a.ackUpto() != ackNone {
		t.Fatalf("initial ack not sentinel: 0x%04X", a.ackUpto())
	}
	a.acceptIncoming(0, []byte("a"))
	if a.ackUpto() != 0 {
		t.Fatalf("after seq 0: %d", a.ackUpto())
	}
	a.acceptIncoming(2, []byte("c"))
	if a.ackUpto() != 0 {
		t.Fatalf("gap should not advance ack: %d", a.ackUpto())
	}
	a.acceptIncoming(1, []byte("b"))
	if a.ackUpto() != 2 {
		t.Fatalf("filling gap should advance: %d", a.ackUpto())
	}
}

func TestPruneAckedIsCumulativeAndRespectsSentinel(t *testing.T) {
	a := newHSAdapter(nil, DefaultOptions())
	a.unacked[0] = []byte{0}
	a.unacked[1] = []byte{1}
	a.unacked[2] = []byte{2}

	a.pruneAcked(ackNone)
	if len(a.unacked) != 3 {
		t.Fatalf("sentinel should prune nothing, got %d", len(a.unacked))
	}
	a.pruneAcked(1)
	if _, ok := a.unacked[0]; ok {
		t.Fatal("seq 0 should be pruned")
	}
	if _, ok := a.unacked[1]; ok {
		t.Fatal("seq 1 should be pruned")
	}
	if _, ok := a.unacked[2]; !ok {
		t.Fatal("seq 2 should remain")
	}
	a.pruneAcked(2)
	if len(a.unacked) != 0 {
		t.Fatalf("should be empty: %d", len(a.unacked))
	}
}