package metrics

import (
	"bytes"
	"testing"
)

// mxHas is a local substring scan. bytes.Contains routes a long haystack
// through bytes.Index's Rabin-Karp fallback, which returns -1 for a needle
// that is demonstrably present (see the reported stdlib defect), so the tests
// cannot use it. This helper is the two-line brute force instead.
func mxHas(hay, needle []byte) (ok bool) {
	for i := 0; i+len(needle) <= len(hay); i++ {
		if bytes.Equal(hay[i:i+len(needle)], needle) {
			return true
		}
	}
	return false
}

// TestBucketOf pins the power-of-two bucket map, including the two boundary
// cases: values below 2 land in bucket 0, and everything at or above 2^24 is
// clamped into the last bucket.
func TestBucketOf(t *testing.T) {
	cases := []struct {
		ns   uint64
		want int32
	}{
		{0, 0},
		{1, 0},
		{2, 1},
		{3, 1},
		{4, 2},
		{7, 2},
		{8, 3},
		{15, 3},
		{16, 4},
		{8388608, 23},          // 2^23
		{16777216, 24},         // 2^24, first clamped value
		{1099511627776, 24},    // 2^40, still clamped
	}
	for _, c := range cases {
		got := bucketOf(c.ns)
		if got != c.want {
			t.Fatalf("bucketOf(%d) = %d, want %d", c.ns, got, c.want)
		}
	}
}

// TestObserveCountsSumAndAverage pins Count / SumNs / AvgNs and the per-bucket
// tallies for observations in different buckets.
func TestObserveCountsSumAndAverage(t *testing.T) {
	h := NewHistogram("t")
	if h.Name != "t" {
		t.Fatalf("NewHistogram name = %q", h.Name)
	}
	h.Observe(0)
	h.Observe(100)
	if h.Count != 2 {
		t.Fatalf("Count = %d, want 2", h.Count)
	}
	if h.SumNs != 100 {
		t.Fatalf("SumNs = %d, want 100", h.SumNs)
	}
	if h.AvgNs() != 50 {
		t.Fatalf("AvgNs = %d, want 50", h.AvgNs())
	}
	if h.Buckets[0] != 1 {
		t.Fatalf("bucket 0 = %d, want 1", h.Buckets[0])
	}
	if bucketOf(100) != 6 {
		t.Fatalf("test assumption broken: bucketOf(100) = %d", bucketOf(100))
	}
	if h.Buckets[6] != 1 {
		t.Fatalf("bucket 6 = %d, want 1", h.Buckets[6])
	}
	var total uint64
	for i := 0; i < numBuckets; i++ {
		total += h.Buckets[i]
	}
	if total != 2 {
		t.Fatalf("bucket total = %d, want 2", total)
	}
}

// TestObserveClampsNegative pins that a negative duration is recorded as zero
// rather than wrapping to a huge uint64 (which would poison SumNs).
func TestObserveClampsNegative(t *testing.T) {
	h := NewHistogram("neg")
	h.Observe(-5)
	if h.Count != 1 {
		t.Fatalf("Count = %d, want 1", h.Count)
	}
	if h.SumNs != 0 {
		t.Fatalf("SumNs = %d, want 0", h.SumNs)
	}
	if h.Buckets[0] != 1 {
		t.Fatalf("bucket 0 = %d, want 1", h.Buckets[0])
	}
	if h.AvgNs() != 0 {
		t.Fatalf("AvgNs = %d, want 0", h.AvgNs())
	}
}

// TestPercentile pins the approximate percentile: it returns the upper bound of
// the bucket holding the target sample, 0 when empty, and the last-bucket value
// for p100.
func TestPercentile(t *testing.T) {
	empty := NewHistogram("e")
	if empty.Percentile(50) != 0 {
		t.Fatalf("empty Percentile = %d, want 0", empty.Percentile(50))
	}
	if empty.AvgNs() != 0 {
		t.Fatalf("empty AvgNs = %d, want 0", empty.AvgNs())
	}

	h := NewHistogram("p")
	h.Observe(0)
	h.Observe(100)
	// p50 target = 1: the first sample (bucket 0) satisfies it -> upper bound 2.
	if h.Percentile(50) != 2 {
		t.Fatalf("p50 = %d, want 2", h.Percentile(50))
	}
	// p95 target = 2*95/100 = 1 -> still bucket 0.
	if h.Percentile(95) != 2 {
		t.Fatalf("p95 = %d, want 2", h.Percentile(95))
	}
	// p99 target = 2*99/100 = 1 -> still bucket 0.
	if h.Percentile(99) != 2 {
		t.Fatalf("p99 = %d, want 2", h.Percentile(99))
	}
	// p100 target = 2: must walk to bucket 6 -> upper bound 1<<7 = 128.
	if h.Percentile(100) != 128 {
		t.Fatalf("p100 = %d, want 128", h.Percentile(100))
	}
}

// TestReset pins that Reset zeroes Count, SumNs and every bucket, restoring the
// empty histogram's percentile/avg answers.
func TestReset(t *testing.T) {
	h := NewHistogram("r")
	h.Observe(0)
	h.Observe(64)
	h.Observe(4096)
	h.Reset()
	if h.Count != 0 {
		t.Fatalf("Count after Reset = %d", h.Count)
	}
	if h.SumNs != 0 {
		t.Fatalf("SumNs after Reset = %d", h.SumNs)
	}
	if h.AvgNs() != 0 {
		t.Fatalf("AvgNs after Reset = %d", h.AvgNs())
	}
	if h.Percentile(50) != 0 {
		t.Fatalf("Percentile after Reset = %d", h.Percentile(50))
	}
	for i := 0; i < numBuckets; i++ {
		if h.Buckets[i] != 0 {
			t.Fatalf("bucket %d after Reset = %d", i, h.Buckets[i])
		}
	}
}

// TestAppendUint64 pins the fmt-free base-10 encoder, including zero (which has
// no digits and must not return an empty string).
func TestAppendUint64(t *testing.T) {
	if string(appendUint64(nil, 0)) != "0" {
		t.Fatalf("appendUint64(0) = %q", string(appendUint64(nil, 0)))
	}
	if string(appendUint64(nil, 7)) != "7" {
		t.Fatalf("appendUint64(7) = %q", string(appendUint64(nil, 7)))
	}
	if string(appendUint64(nil, 12345)) != "12345" {
		t.Fatalf("appendUint64(12345) = %q", string(appendUint64(nil, 12345)))
	}
	if string(appendUint64([]byte("x"), 10)) != "x10" {
		t.Fatalf("appendUint64 append = %q", string(appendUint64([]byte("x"), 10)))
	}
}

// TestAppendJSONShape pins the exact JSON document for an empty histogram, then
// checks that an observation shows up in the count and bucket array.
func TestAppendJSONShape(t *testing.T) {
	h := NewHistogram("x")
	want := []byte("\"x\":{\"count\":0,\"sum_ns\":0,\"avg_ns\":0,\"p50_ns\":0,\"p95_ns\":0,\"p99_ns\":0,\"buckets\":[")
	for i := 0; i < numBuckets; i++ {
		if i > 0 {
			want = want | ","
		}
		want = want | "0"
	}
	want = want | "]}"
	got := h.AppendJSON(nil)
	if !bytes.Equal(got, want) {
		t.Fatalf("AppendJSON = %s, want %s", string(got), string(want))
	}

	h.Observe(1)
	got2 := h.AppendJSON(nil)
	if !mxHas(got2, []byte("\"count\":1")) {
		t.Fatalf("AppendJSON after Observe missing count: %s", string(got2))
	}
	if !mxHas(got2, []byte("\"buckets\":[1,")) {
		t.Fatalf("AppendJSON after Observe missing bucket 0: %s", string(got2))
	}
}

// TestNowAndSince pins the monotonic timestamp helpers: Now is a positive Unix
// nanosecond value and Since never returns a negative elapsed time.
func TestNowAndSince(t *testing.T) {
	if Now() <= 0 {
		t.Fatal("Now() must be positive")
	}
	if Since(Now()) < 0 {
		t.Fatal("Since(Now()) must not be negative")
	}
	start := Now()
	if Since(start) < 0 {
		t.Fatal("Since(start) must not be negative")
	}
}

// TestSnapshotAllAndResetAll pins that the registry covers every declared
// histogram by name, and that resetting the registry clears one that was
// observed.
func TestSnapshotAllAndResetAll(t *testing.T) {
	ResetAll()
	names := []string{
		"ingest_pipeline_ns", "sig_verify_ns", "acl_allowwrite_ns",
		"wal_append_ns", "wal_fsync_ns", "accept_handle_ns",
		"accept_wait_ns", "handle_event_ns", "envelope_parse_ns",
		"send_ws_ns", "broadcast_ns", "ws_frame_ns", "on_poll_ns",
	}
	if len(allHistograms) != len(names) {
		t.Fatalf("registry size = %d, want %d", int32(len(allHistograms)), int32(len(names)))
	}
	buf := SnapshotAll(nil)
	if !bytes.HasPrefix(buf, []byte("{")) || !bytes.HasSuffix(buf, []byte("}")) {
		t.Fatalf("SnapshotAll is not a JSON object: %s", string(buf))
	}
	for _, n := range names {
		marker := "\"" | n | "\":{\"count\":"
		if !mxHas(buf, []byte(marker)) {
			t.Fatalf("SnapshotAll missing %s", n)
		}
	}

	// The globals are writable through their pointers; observing one and then
	// resetting the registry must bring it back to empty.
	SigVerifyNs.Observe(1234)
	if SigVerifyNs.Count != 1 || SigVerifyNs.SumNs != 1234 {
		t.Fatalf("global observe: count=%d sum=%d", SigVerifyNs.Count, SigVerifyNs.SumNs)
	}
	ResetAll()
	if SigVerifyNs.Count != 0 || SigVerifyNs.SumNs != 0 {
		t.Fatalf("ResetAll left sig_verify_ns: count=%d sum=%d", SigVerifyNs.Count, SigVerifyNs.SumNs)
	}
}