// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

package aggregate

import (
	"context"
	"fmt"
	"math"
	"sync"
	"sync/atomic"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/internal/global"
	"go.opentelemetry.io/otel/sdk/internal/x"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
)

type noErrorHandler struct{ t *testing.T }

func (h *noErrorHandler) Handle(e error) {
	require.NoError(h.t, e)
}

func withHandler(t *testing.T) func() {
	t.Helper()
	h := &noErrorHandler{t: t}
	original := global.GetErrorHandler()
	global.SetErrorHandler(h)
	return func() { global.SetErrorHandler(original) }
}

func TestExpoHistogramDataPointRecord(t *testing.T) {
	t.Run("float64", testExpoHistogramDataPointRecord[float64])
	t.Run("float64 MinMaxSum", testExpoHistogramMinMaxSumFloat64)
	t.Run("float64-2", testExpoHistogramDataPointRecordFloat64)
	t.Run("int64", testExpoHistogramDataPointRecord[int64])
	t.Run("int64 MinMaxSum", testExpoHistogramMinMaxSumInt64)
}

func testExpoHistogramDataPointRecord[N int64 | float64](t *testing.T) {
	testCases := []struct {
		maxSize        int
		values         []N
		expectedStart  int32
		expectedCounts []uint64
		expectedScale  int32
	}{
		{
			maxSize:        4,
			values:         []N{2, 4, 1},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 1, 1},
			expectedScale:  0,
		},
		{
			maxSize:        4,
			values:         []N{4, 4, 4, 2, 16, 1},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 4, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []N{1, 2, 4},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 2},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []N{1, 4, 2},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 2},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []N{2, 4, 1},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 2},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []N{2, 1, 4},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 2},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []N{4, 1, 2},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 2},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []N{4, 2, 1},
			expectedStart:  -1,
			expectedCounts: []uint64{1, 2},
			expectedScale:  -1,
		},
	}
	for _, tt := range testCases {
		t.Run(fmt.Sprint(tt.values), func(t *testing.T) {
			restore := withHandler(t)
			defer restore()

			dp := newExpoHistogramDataPoint[N](alice, tt.maxSize, 20, false, false)
			for _, v := range tt.values {
				dp.record(v)
				dp.record(-v)
			}

			assertBuckets(t, tt.expectedStart, tt.expectedCounts, dp.posBuckets, "positive buckets")
			assertBuckets(t, tt.expectedStart, tt.expectedCounts, dp.negBuckets, "negative buckets")
			assert.Equal(t, tt.expectedScale, dp.scale.Load(), "scale")
		})
	}
}

// TODO: This can be defined in the test after we drop support for go1.19.
type expectedMinMaxSum[N int64 | float64] struct {
	min   N
	max   N
	sum   N
	count uint
}
type expoHistogramDataPointRecordMinMaxSumTestCase[N int64 | float64] struct {
	values   []N
	expected expectedMinMaxSum[N]
}

func testExpoHistogramMinMaxSumInt64(t *testing.T) {
	testCases := []expoHistogramDataPointRecordMinMaxSumTestCase[int64]{
		{
			values:   []int64{2, 4, 1},
			expected: expectedMinMaxSum[int64]{1, 4, 7, 3},
		},
		{
			values:   []int64{4, 4, 4, 2, 16, 1},
			expected: expectedMinMaxSum[int64]{1, 16, 31, 6},
		},
	}

	for _, tt := range testCases {
		t.Run(fmt.Sprint(tt.values), func(t *testing.T) {
			restore := withHandler(t)
			defer restore()

			h := newExponentialHistogram[int64](4, 20, false, false, 0, dropExemplars[int64])
			for _, v := range tt.values {
				h.measure(t.Context(), v, alice, nil)
			}
			dp := h.values[alice.Equivalent()]

			assert.Equal(t, tt.expected.max, dp.minMax.maximum.Load())
			assert.Equal(t, tt.expected.min, dp.minMax.minimum.Load())
			assert.InDelta(t, tt.expected.sum, dp.sum.load(), 0.01)
		})
	}
}

func testExpoHistogramMinMaxSumFloat64(t *testing.T) {
	testCases := []expoHistogramDataPointRecordMinMaxSumTestCase[float64]{
		{
			values:   []float64{2, 4, 1},
			expected: expectedMinMaxSum[float64]{1, 4, 7, 3},
		},
		{
			values:   []float64{2, 4, 1, math.Inf(1)},
			expected: expectedMinMaxSum[float64]{1, 4, 7, 4},
		},
		{
			values:   []float64{2, 4, 1, math.Inf(-1)},
			expected: expectedMinMaxSum[float64]{1, 4, 7, 4},
		},
		{
			values:   []float64{2, 4, 1, math.NaN()},
			expected: expectedMinMaxSum[float64]{1, 4, 7, 4},
		},
		{
			values:   []float64{4, 4, 4, 2, 16, 1},
			expected: expectedMinMaxSum[float64]{1, 16, 31, 6},
		},
	}

	for _, tt := range testCases {
		t.Run(fmt.Sprint(tt.values), func(t *testing.T) {
			restore := withHandler(t)
			defer restore()

			h := newExponentialHistogram[float64](4, 20, false, false, 0, dropExemplars[float64])
			for _, v := range tt.values {
				h.measure(t.Context(), v, alice, nil)
			}
			dp := h.values[alice.Equivalent()]

			assert.Equal(t, tt.expected.max, dp.minMax.maximum.Load())
			assert.Equal(t, tt.expected.min, dp.minMax.minimum.Load())
			assert.InDelta(t, tt.expected.sum, dp.sum.load(), 0.01)
		})
	}
}

func testExpoHistogramDataPointRecordFloat64(t *testing.T) {
	type TestCase struct {
		maxSize        int
		values         []float64
		expectedStart  int32
		expectedCounts []uint64
		expectedScale  int32
	}

	testCases := []TestCase{
		{
			maxSize:        4,
			values:         []float64{2, 2, 2, 1, 8, 0.5},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 3, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []float64{1, 0.5, 2},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []float64{1, 2, 0.5},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []float64{2, 0.5, 1},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []float64{2, 1, 0.5},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []float64{0.5, 1, 2},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 1},
			expectedScale:  -1,
		},
		{
			maxSize:        2,
			values:         []float64{0.5, 2, 1},
			expectedStart:  -1,
			expectedCounts: []uint64{2, 1},
			expectedScale:  -1,
		},
	}
	for _, tt := range testCases {
		t.Run(fmt.Sprint(tt.values), func(t *testing.T) {
			restore := withHandler(t)
			defer restore()

			dp := newExpoHistogramDataPoint[float64](alice, tt.maxSize, 20, false, false)
			for _, v := range tt.values {
				dp.record(v)
				dp.record(-v)
			}

			assertBuckets(t, tt.expectedStart, tt.expectedCounts, dp.posBuckets, "positive buckets")
			assertBuckets(t, tt.expectedStart, tt.expectedCounts, dp.negBuckets, "negative buckets")
			assert.Equal(t, tt.expectedScale, dp.scale.Load(), "scale")
			assert.Equal(t, tt.expectedScale, dp.scale.Load())
		})
	}
}

func TestExponentialHistogramDataPointRecordLimits(t *testing.T) {
	// These bins are calculated from the following formula:
	// floor( log2( value) * 2^20 ) using an arbitrary precision calculator.

	fdp := newExpoHistogramDataPoint[float64](alice, 4, 20, false, false)
	fdp.record(math.MaxFloat64)

	if fdp.posBuckets.startBin != 1073741823 {
		t.Errorf("Expected startBin to be 1073741823, got %d", fdp.posBuckets.startBin)
	}

	fdp = newExpoHistogramDataPoint[float64](alice, 4, 20, false, false)
	fdp.record(math.SmallestNonzeroFloat64)

	if fdp.posBuckets.startBin != -1126170625 {
		t.Errorf("Expected startBin to be -1126170625, got %d", fdp.posBuckets.startBin)
	}

	idp := newExpoHistogramDataPoint[int64](alice, 4, 20, false, false)
	idp.record(math.MaxInt64)

	if idp.posBuckets.startBin != 66060287 {
		t.Errorf("Expected startBin to be 66060287, got %d", idp.posBuckets.startBin)
	}
}

func newBucket(startBin int32, counts []uint64) *expoBuckets {
	b := &expoBuckets{startBin: startBin, counts: make([]atomic.Uint64, len(counts))}
	for i, v := range counts {
		b.counts[i].Store(v)
	}
	return b
}

func assertBuckets(t *testing.T, expectedStart int32, expectedCounts []uint64, actual expoBuckets, msg string) {
	t.Helper()
	assert.Equal(t, expectedStart, actual.startBin, "%s: startBin", msg)
	var actualCounts []uint64
	if len(actual.counts) > 0 {
		actualCounts = make([]uint64, len(actual.counts))
		for i := range actual.counts {
			actualCounts[i] = actual.counts[i].Load()
		}
	}
	assert.Equal(t, expectedCounts, actualCounts, "%s: counts", msg)
}

func TestExpoBucketDownscale(t *testing.T) {
	tests := []struct {
		name       string
		bucket     *expoBuckets
		scale      int32
		wantStart  int32
		wantCounts []uint64
	}{
		{
			name:       "Empty bucket",
			bucket:     newBucket(0, nil),
			scale:      3,
			wantStart:  0,
			wantCounts: nil,
		},
		{
			name:       "1 size bucket",
			bucket:     newBucket(50, []uint64{7}),
			scale:      4,
			wantStart:  3,
			wantCounts: []uint64{7},
		},
		{
			name:       "zero scale",
			bucket:     newBucket(50, []uint64{7, 5}),
			scale:      0,
			wantStart:  50,
			wantCounts: []uint64{7, 5},
		},
		{
			name:       "aligned bucket scale 1",
			bucket:     newBucket(0, []uint64{1, 2, 3, 4, 5, 6}),
			scale:      1,
			wantStart:  0,
			wantCounts: []uint64{3, 7, 11},
		},
		{
			name:       "aligned bucket scale 2",
			bucket:     newBucket(0, []uint64{1, 2, 3, 4, 5, 6}),
			scale:      2,
			wantStart:  0,
			wantCounts: []uint64{10, 11},
		},
		{
			name:       "aligned bucket scale 3",
			bucket:     newBucket(0, []uint64{1, 2, 3, 4, 5, 6}),
			scale:      3,
			wantStart:  0,
			wantCounts: []uint64{21},
		},
		{
			name:       "unaligned bucket scale 1",
			bucket:     newBucket(5, []uint64{1, 2, 3, 4, 5, 6}), // This is equivalent to [0,0,0,0,0,1,2,3,4,5,6]
			scale:      1,
			wantStart:  2,
			wantCounts: []uint64{1, 5, 9, 6}, // This is equivalent to [0,0,1,5,9,6]
		},
		{
			name:       "unaligned bucket scale 2",
			bucket:     newBucket(7, []uint64{1, 2, 3, 4, 5, 6}), // This is equivalent to [0,0,0,0,0,0,0,1,2,3,4,5,6]
			scale:      2,
			wantStart:  1,
			wantCounts: []uint64{1, 14, 6}, // This is equivalent to [0,1,14,6]
		},
		{
			name:       "unaligned bucket scale 3",
			bucket:     newBucket(3, []uint64{1, 2, 3, 4, 5, 6}), // This is equivalent to [0,0,0,1,2,3,4,5,6]
			scale:      3,
			wantStart:  0,
			wantCounts: []uint64{15, 6}, // This is equivalent to [0,15,6]
		},
		{
			name:       "unaligned bucket scale 1",
			bucket:     newBucket(1, []uint64{1, 0, 1}),
			scale:      1,
			wantStart:  0,
			wantCounts: []uint64{1, 1},
		},
		{
			name:       "negative startBin",
			bucket:     newBucket(-1, []uint64{1, 0, 3}),
			scale:      1,
			wantStart:  -1,
			wantCounts: []uint64{1, 3},
		},
		{
			name:       "negative startBin 2",
			bucket:     newBucket(-4, []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
			scale:      1,
			wantStart:  -2,
			wantCounts: []uint64{3, 7, 11, 15, 19},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.bucket.downscale(tt.scale)

			assertBuckets(t, tt.wantStart, tt.wantCounts, *tt.bucket, tt.name)
		})
	}
}

func TestExpoBucketRecord(t *testing.T) {
	tests := []struct {
		name       string
		bucket     *expoBuckets
		bin        int32
		wantStart  int32
		wantCounts []uint64
	}{
		{
			name:       "Empty Bucket creates first count",
			bucket:     newBucket(0, nil),
			bin:        -5,
			wantStart:  -5,
			wantCounts: []uint64{1},
		},
		{
			name:       "Bin is in the bucket",
			bucket:     newBucket(3, []uint64{1, 2, 3, 4, 5, 6}),
			bin:        5,
			wantStart:  3,
			wantCounts: []uint64{1, 2, 4, 4, 5, 6},
		},
		{
			name:       "Bin is before the start of the bucket",
			bucket:     newBucket(1, []uint64{1, 2, 3, 4, 5, 6}),
			bin:        -2,
			wantStart:  -2,
			wantCounts: []uint64{1, 0, 0, 1, 2, 3, 4, 5, 6},
		},
		{
			name:       "Bin is after the end of the bucket",
			bucket:     newBucket(-2, []uint64{1, 2, 3, 4, 5, 6}),
			bin:        4,
			wantStart:  -2,
			wantCounts: []uint64{1, 2, 3, 4, 5, 6, 1},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.bucket.record(tt.bin)

			assertBuckets(t, tt.wantStart, tt.wantCounts, *tt.bucket, tt.name)
		})
	}
}

func TestScaleChange(t *testing.T) {
	type args struct {
		bin      int32
		startBin int32
		length   int
		maxSize  int
	}
	tests := []struct {
		name string
		args args
		want int32
	}{
		{
			name: "if length is 0, no rescale is needed",
			// [] -> [5] Length 1
			args: args{
				bin:      5,
				startBin: 0,
				length:   0,
				maxSize:  4,
			},
			want: 0,
		},
		{
			name: "if bin is between start, and the end, no rescale needed",
			// [-1, ..., 8] Length 10 -> [-1, ..., 5, ..., 8] Length 10
			args: args{
				bin:      5,
				startBin: -1,
				length:   10,
				maxSize:  20,
			},
			want: 0,
		},
		{
			name: "if len([bin,... end]) > maxSize, rescale needed",
			// [8,9,10] Length 3 -> [5, ..., 10] Length 6
			args: args{
				bin:      5,
				startBin: 8,
				length:   3,
				maxSize:  5,
			},
			want: 1,
		},
		{
			name: "if len([start, ..., bin]) > maxSize, rescale needed",
			// [2,3,4] Length 3 -> [2, ..., 7] Length 6
			args: args{
				bin:      7,
				startBin: 2,
				length:   3,
				maxSize:  5,
			},
			want: 1,
		},
		{
			name: "if len([start, ..., bin]) > maxSize, rescale needed",
			// [2,3,4] Length 3 -> [2, ..., 7] Length 12
			args: args{
				bin:      13,
				startBin: 2,
				length:   3,
				maxSize:  5,
			},
			want: 2,
		},
		{
			name: "It should not hang if it will never be able to rescale",
			args: args{
				bin:      1,
				startBin: -1,
				length:   1,
				maxSize:  1,
			},
			want: 31,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := newExpoHistogramDataPoint[float64](alice, tt.args.maxSize, 20, false, false)
			got := p.scaleChange(tt.args.bin, tt.args.startBin, tt.args.length)
			if got != tt.want {
				t.Errorf("scaleChange() = %v, want %v", got, tt.want)
			}
		})
	}
}

func BenchmarkPrepend(b *testing.B) {
	for i := 0; i < b.N; i++ {
		agg := newExpoHistogramDataPoint[float64](alice, 1024, 20, false, false)
		n := math.MaxFloat64
		for range 1024 {
			agg.record(n)
			n /= 2
		}
	}
}

func BenchmarkAppend(b *testing.B) {
	for i := 0; i < b.N; i++ {
		agg := newExpoHistogramDataPoint[float64](alice, 1024, 20, false, false)
		n := smallestNonZeroNormalFloat64
		for range 1024 {
			agg.record(n)
			n *= 2
		}
	}
}

func BenchmarkExponentialHistogram(b *testing.B) {
	const (
		maxSize  = 160
		maxScale = 20
		noMinMax = false
		noSum    = false
	)

	b.Run("Int64/Cumulative", benchmarkAggregate(func() (Measure[int64], ComputeAggregation) {
		return Builder[int64]{
			Temporality: metricdata.CumulativeTemporality,
		}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
	}))
	b.Run("Int64/Delta", benchmarkAggregate(func() (Measure[int64], ComputeAggregation) {
		return Builder[int64]{
			Temporality: metricdata.DeltaTemporality,
		}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
	}))
	b.Run("Float64/Cumulative", benchmarkAggregate(func() (Measure[float64], ComputeAggregation) {
		return Builder[float64]{
			Temporality: metricdata.CumulativeTemporality,
		}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
	}))
	b.Run("Float64/Delta", benchmarkAggregate(func() (Measure[float64], ComputeAggregation) {
		return Builder[float64]{
			Temporality: metricdata.DeltaTemporality,
		}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
	}))
}

func TestSubNormal(t *testing.T) {
	want := &expoHistogramDataPoint[float64]{
		attrs:   alice,
		maxSize: 4,
	}
	want.minMax.Update(math.SmallestNonzeroFloat64)
	want.sum.add(3 * math.SmallestNonzeroFloat64)
	want.scale.Store(20)
	want.posBuckets = *newBucket(-1126170625, []uint64{3})

	ehdp := newExpoHistogramDataPoint[float64](alice, 4, 20, false, false)
	ehdp.record(math.SmallestNonzeroFloat64)
	ehdp.record(math.SmallestNonzeroFloat64)
	ehdp.record(math.SmallestNonzeroFloat64)

	want.startTime = ehdp.startTime

	assert.Equal(t, want, ehdp)
}

func TestExponentialHistogramAggregation(t *testing.T) {
	c := new(clock)
	t.Cleanup(c.Register())

	t.Run("Int64/Delta", testDeltaExpoHist[int64]())
	c.Reset()

	t.Run("Float64/Delta", testDeltaExpoHist[float64]())
	c.Reset()

	t.Run("Int64/Cumulative", func(t *testing.T) {
		t.Setenv("OTEL_GO_X_PER_SERIES_START_TIMESTAMPS", "false")
		assert.False(t, x.PerSeriesStartTimestamps.Enabled())
		testCumulativeExpoHist[int64]()(t)
	})
	c.Reset()

	t.Run("Int64/Cumulative/PerSeriesStartTimeEnabled", func(t *testing.T) {
		t.Setenv("OTEL_GO_X_PER_SERIES_START_TIMESTAMPS", "true")
		assert.True(t, x.PerSeriesStartTimestamps.Enabled())
		testCumulativeExpoHist[int64]()(t)
	})
	c.Reset()

	t.Run("Float64/Cumulative", func(t *testing.T) {
		t.Setenv("OTEL_GO_X_PER_SERIES_START_TIMESTAMPS", "false")
		assert.False(t, x.PerSeriesStartTimestamps.Enabled())
		testCumulativeExpoHist[float64]()(t)
	})
	c.Reset()

	t.Run("Float64/Cumulative/PerSeriesStartTimeEnabled", func(t *testing.T) {
		t.Setenv("OTEL_GO_X_PER_SERIES_START_TIMESTAMPS", "true")
		assert.True(t, x.PerSeriesStartTimestamps.Enabled())
		testCumulativeExpoHist[float64]()(t)
	})
	c.Reset()
}

func testDeltaExpoHist[N int64 | float64]() func(t *testing.T) {
	in, out := Builder[N]{
		Temporality:      metricdata.DeltaTemporality,
		Filter:           attrFltr,
		AggregationLimit: 2,
	}.ExponentialBucketHistogram(4, 20, false, false)
	ctx := context.Background()
	return test[N](in, out, []teststep[N]{
		{
			input: []arg[N]{},
			expect: output{
				n: 0,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.DeltaTemporality,
					DataPoints:  []metricdata.ExponentialHistogramDataPoint[N]{},
				},
			},
		},
		{
			input: []arg[N]{
				{ctx, 4, alice},
				{ctx, 4, alice},
				{ctx, 4, alice},
				{ctx, 2, alice},
				{ctx, 16, alice},
				{ctx, 1, alice},
				{ctx, -1, alice},
			},
			expect: output{
				n: 1,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.DeltaTemporality,
					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
						{
							Attributes: fltrAlice,
							StartTime:  y2kPlus(1),
							Time:       y2kPlus(3),
							Count:      7,
							Min:        metricdata.NewExtrema[N](-1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        30,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 4, 1},
							},
							NegativeBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1},
							},
						},
					},
				},
			},
		},
		{
			// Delta sums are expected to reset.
			input: []arg[N]{},
			expect: output{
				n: 0,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.DeltaTemporality,
					DataPoints:  []metricdata.ExponentialHistogramDataPoint[N]{},
				},
			},
		},
		{
			input: []arg[N]{
				{ctx, 4, alice},
				{ctx, 4, alice},
				{ctx, 4, alice},
				{ctx, 2, alice},
				{ctx, 16, alice},
				{ctx, 1, alice},
				// These will exceed the cardinality limit.
				{ctx, 4, bob},
				{ctx, 4, bob},
				{ctx, 4, bob},
				{ctx, 2, carol},
				{ctx, 16, carol},
				{ctx, 1, dave},
				{ctx, -1, alice},
			},
			expect: output{
				n: 2,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.DeltaTemporality,
					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
						{
							Attributes: fltrAlice,
							StartTime:  y2kPlus(4),
							Time:       y2kPlus(7),
							Count:      7,
							Min:        metricdata.NewExtrema[N](-1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        30,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 4, 1},
							},
							NegativeBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1},
							},
						},
						{
							Attributes: overflowSet,
							StartTime:  y2kPlus(4),
							Time:       y2kPlus(7),
							Count:      6,
							Min:        metricdata.NewExtrema[N](1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        31,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 4, 1},
							},
						},
					},
				},
			},
		},
	})
}

func testCumulativeExpoHist[N int64 | float64]() func(t *testing.T) {
	in, out := Builder[N]{
		Temporality:      metricdata.CumulativeTemporality,
		Filter:           attrFltr,
		AggregationLimit: 2,
	}.ExponentialBucketHistogram(4, 20, false, false)

	aliceStartTime := y2kPlus(0)
	overflowStartTime := y2kPlus(0)

	if x.PerSeriesStartTimestamps.Enabled() {
		aliceStartTime = y2kPlus(2)
		overflowStartTime = y2kPlus(6)
	}

	ctx := context.Background()
	return test[N](in, out, []teststep[N]{
		{
			input: []arg[N]{},
			expect: output{
				n: 0,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints:  []metricdata.ExponentialHistogramDataPoint[N]{},
				},
			},
		},
		{
			input: []arg[N]{
				{ctx, 4, alice},
				{ctx, 4, alice},
				{ctx, 4, alice},
				{ctx, 2, alice},
				{ctx, 16, alice},
				{ctx, 1, alice},
				{ctx, -1, alice},
			},
			expect: output{
				n: 1,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
						{
							Attributes: fltrAlice,
							StartTime:  aliceStartTime,
							Time:       y2kPlus(3),
							Count:      7,
							Min:        metricdata.NewExtrema[N](-1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        30,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 4, 1},
							},
							NegativeBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1},
							},
						},
					},
				},
			},
		},
		{
			input: []arg[N]{
				{ctx, 2, alice},
				{ctx, 3, alice},
				{ctx, 8, alice},
			},
			expect: output{
				n: 1,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
						{
							Attributes: fltrAlice,
							StartTime:  aliceStartTime,
							Time:       y2kPlus(4),
							Count:      10,
							Min:        metricdata.NewExtrema[N](-1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        43,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 6, 2},
							},
							NegativeBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1},
							},
						},
					},
				},
			},
		},
		{
			input: []arg[N]{},
			expect: output{
				n: 1,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
						{
							Attributes: fltrAlice,
							StartTime:  aliceStartTime,
							Time:       y2kPlus(5),
							Count:      10,
							Min:        metricdata.NewExtrema[N](-1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        43,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 6, 2},
							},
							NegativeBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1},
							},
						},
					},
				},
			},
		},
		{
			input: []arg[N]{
				// These will exceed the cardinality limit.
				{ctx, 4, bob},
				{ctx, 4, bob},
				{ctx, 4, bob},
				{ctx, 2, carol},
				{ctx, 16, carol},
				{ctx, 1, dave},
			},
			expect: output{
				n: 2,
				agg: metricdata.ExponentialHistogram[N]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
						{
							Attributes: fltrAlice,
							StartTime:  aliceStartTime,
							Time:       y2kPlus(7),
							Count:      10,
							Min:        metricdata.NewExtrema[N](-1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        43,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 6, 2},
							},
							NegativeBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1},
							},
						},
						{
							Attributes: overflowSet,
							StartTime:  overflowStartTime,
							Time:       y2kPlus(7),
							Count:      6,
							Min:        metricdata.NewExtrema[N](1),
							Max:        metricdata.NewExtrema[N](16),
							Sum:        31,
							Scale:      -1,
							PositiveBucket: metricdata.ExponentialBucket{
								Offset: -1,
								Counts: []uint64{1, 4, 1},
							},
						},
					},
				},
			},
		},
	})
}

func TestExponentialHistogramAggregationConcurrentSafe(t *testing.T) {
	t.Run("Int64/Delta", testDeltaExpoHistConcurrentSafe[int64]())
	t.Run("Float64/Delta", testDeltaExpoHistConcurrentSafe[float64]())
	t.Run("Int64/Cumulative", testCumulativeExpoHistConcurrentSafe[int64]())
	t.Run("Float64/Cumulative", testCumulativeExpoHistConcurrentSafe[float64]())
}

func testDeltaExpoHistConcurrentSafe[N int64 | float64]() func(t *testing.T) {
	in, out := Builder[N]{
		Temporality:      metricdata.DeltaTemporality,
		Filter:           attrFltr,
		AggregationLimit: 3,
	}.ExponentialBucketHistogram(4, 20, false, false)
	return testAggregationConcurrentSafe[N](in, out, validateExponentialHistogram[N])
}

func testCumulativeExpoHistConcurrentSafe[N int64 | float64]() func(t *testing.T) {
	in, out := Builder[N]{
		Temporality:      metricdata.CumulativeTemporality,
		Filter:           attrFltr,
		AggregationLimit: 3,
	}.ExponentialBucketHistogram(4, 20, false, false)
	return testAggregationConcurrentSafe[N](in, out, validateExponentialHistogram[N])
}

func validateExponentialHistogram[N int64 | float64](t *testing.T, aggs []metricdata.Aggregation) {
	sums := make(map[attribute.Set]N)
	counts := make(map[attribute.Set]uint64)
	var isDelta bool
	for i, agg := range aggs {
		s, ok := agg.(metricdata.ExponentialHistogram[N])
		require.True(t, ok)
		if s.Temporality == metricdata.DeltaTemporality {
			isDelta = true
		}
		require.LessOrEqual(t, len(s.DataPoints), 3, "AggregationLimit of 3 exceeded in a single cycle")
		for _, dp := range s.DataPoints {
			assert.False(t,
				dp.Time.Before(dp.StartTime),
				"Timestamp %v must not be before start time %v", dp.Time, dp.StartTime,
			)

			if s.Temporality == metricdata.DeltaTemporality {
				sums[dp.Attributes] += dp.Sum
				counts[dp.Attributes] += dp.Count
			} else if i == len(aggs)-1 {
				sums[dp.Attributes] = dp.Sum
				counts[dp.Attributes] = dp.Count
			}

			var totalCount uint64
			for _, bc := range dp.PositiveBucket.Counts {
				totalCount += bc
			}
			for _, bc := range dp.NegativeBucket.Counts {
				totalCount += bc
			}
			assert.Equal(t, totalCount, dp.Count)
		}
	}

	var totalSum N
	var totalCount uint64
	for attr, sum := range sums {
		totalSum += sum
		count := counts[attr]
		totalCount += count

		expectedSingleSum := expectedConcurrentSum[N]() / N(concurrentNumGoroutines)
		expectedSingleCount := expectedConcurrentCount / uint64(concurrentNumGoroutines)

		if !isDelta {
			if attr == overflowSet {
				// The overflow set contains all the goroutines that didn't make the limit of 3
				assert.Equal(t, uint64(0), count%expectedSingleCount)
				assert.Equal(t, count/expectedSingleCount*uint64(expectedSingleSum), uint64(sum))
			} else {
				// Individual attributes should have exactly one goroutine's worth of data
				assert.Equal(t, expectedSingleSum, sum)
				assert.Equal(t, expectedSingleCount, count)
			}
		}
	}
	assertSumEqual[N](t, expectedConcurrentSum[N](), totalSum)
	assert.Equal(t, expectedConcurrentCount, totalCount)
}

func FuzzGetBin(f *testing.F) {
	values := []float64{
		2.0,
		0x1p35,
		0x1.0000000000001p35,
		0x1.fffffffffffffp34,
		0x1p300,
		0x1.0000000000001p300,
		0x1.fffffffffffffp299,
	}
	scales := []int32{0, 15, -5}

	for _, s := range scales {
		for _, v := range values {
			f.Add(v, s)
		}
	}

	f.Fuzz(func(t *testing.T, v float64, scale int32) {
		// GetBin only works on positive values.
		if math.Signbit(v) {
			v *= -1
		}
		// GetBin Doesn't work on zero.
		if v == 0.0 {
			t.Skip("skipping test for zero")
		}

		p := newExpoHistogramDataPoint[float64](alice, 4, 20, false, false)
		// scale range is -10 to 20.
		scaleValue := (scale%31+31)%31 - 10
		p.scale.Store(scaleValue)
		got := p.getBin(v)
		if v <= lowerBound(got, scaleValue) {
			t.Errorf(
				"v=%x scale =%d had bin %d, but was below lower bound %x",
				v,
				scaleValue,
				got,
				lowerBound(got, scaleValue),
			)
		}
		if v > lowerBound(got+1, scaleValue) {
			t.Errorf(
				"v=%x scale =%d had bin %d, but was above upper bound %x",
				v,
				scaleValue,
				got,
				lowerBound(got+1, scaleValue),
			)
		}
	})
}

func lowerBound(index, scale int32) float64 {
	// The lowerBound of the index of Math.SmallestNonzeroFloat64 at any scale
	// is always rounded down to 0.0.
	// For example lowerBound(getBin(Math.SmallestNonzeroFloat64, 7), 7) == 0.0
	// 2 ^ (index * 2 ^ (-scale))
	return math.Exp2(math.Ldexp(float64(index), -int(scale)))
}

func TestExponentialHistogramConcurrentSafeEdgeCases(t *testing.T) {
	t.Run("Int64/Delta", testExpoHistConcurrentSafeEdgeCases[int64](metricdata.DeltaTemporality))
	t.Run("Float64/Delta", testExpoHistConcurrentSafeEdgeCases[float64](metricdata.DeltaTemporality))
	t.Run("Int64/Cumulative", testExpoHistConcurrentSafeEdgeCases[int64](metricdata.CumulativeTemporality))
	t.Run("Float64/Cumulative", testExpoHistConcurrentSafeEdgeCases[float64](metricdata.CumulativeTemporality))
}

func testExpoHistConcurrentSafeEdgeCases[N int64 | float64](temporality metricdata.Temporality) func(t *testing.T) {
	return func(t *testing.T) {
		t.Run("ZeroValues", func(t *testing.T) {
			meas, comp := Builder[N]{
				Temporality:      temporality,
				Filter:           attrFltr,
				AggregationLimit: 3,
			}.ExponentialBucketHistogram(160, 20, false, false)

			ctx := t.Context()
			var wg sync.WaitGroup
			const numGoroutines = 10
			const numRecords = 100
			wg.Add(numGoroutines)
			for range numGoroutines {
				go func() {
					defer wg.Done()
					for range numRecords {
						meas(ctx, 0, alice)
					}
				}()
			}
			wg.Wait()

			dest := new(metricdata.Aggregation)
			comp(dest)
			h := (*dest).(metricdata.ExponentialHistogram[N])
			require.Len(t, h.DataPoints, 1)
			assert.Equal(t, uint64(numGoroutines*numRecords), h.DataPoints[0].ZeroCount)
			assert.Equal(t, uint64(numGoroutines*numRecords), h.DataPoints[0].Count)
		})

		t.Run("RescalingStress", func(t *testing.T) {
			meas, comp := Builder[N]{
				Temporality:      temporality,
				Filter:           attrFltr,
				AggregationLimit: 3,
			}.ExponentialBucketHistogram(160, 20, false, false)

			ctx := t.Context()
			var wg sync.WaitGroup
			const numGoroutines = 10
			const numRecords = 100

			// To verify exact outcome, we sequentially record the same to a reference.
			refMeas, refComp := Builder[N]{
				Temporality:      temporality,
				Filter:           attrFltr,
				AggregationLimit: 3,
			}.ExponentialBucketHistogram(160, 20, false, false)
			var m sync.Mutex

			wg.Add(numGoroutines)
			for i := range numGoroutines {
				go func(id int) {
					defer wg.Done()
					for j := range numRecords {
						// generate a mix of very large and very small powers of 2
						valFloat := math.Exp2((float64(j) / float64(numRecords)) * 60.0)
						if id%2 == 0 {
							valFloat = -valFloat
						}
						val := N(valFloat)
						// For integers, values less than 1 will truncate to 0. Mix things up.
						if id%3 == 0 {
							val = N(float64(id+1) * 100.0)
						}

						meas(ctx, val, alice)

						m.Lock()
						refMeas(ctx, val, alice)
						m.Unlock()
					}
				}(i)
			}
			wg.Wait()

			dest := new(metricdata.Aggregation)
			comp(dest)
			h := (*dest).(metricdata.ExponentialHistogram[N])
			require.Len(t, h.DataPoints, 1)

			refDest := new(metricdata.Aggregation)
			refComp(refDest)
			refH := (*refDest).(metricdata.ExponentialHistogram[N])
			require.Len(t, refH.DataPoints, 1)

			// StartTime/Time will differ slightly.
			h.DataPoints[0].StartTime = refH.DataPoints[0].StartTime
			h.DataPoints[0].Time = refH.DataPoints[0].Time

			// Float sums might be slightly slightly off due to summing wildly different magnitudes
			// in different orders concurrently versus sequentially.
			actualSum := float64(h.DataPoints[0].Sum)
			expectedSum := float64(refH.DataPoints[0].Sum)
			if actualSum != expectedSum {
				assert.InEpsilon(t, expectedSum, actualSum, 0.5, "Sum")
				// Force equality for the deep struct comparison below
				h.DataPoints[0].Sum = refH.DataPoints[0].Sum
			}

			// Normalize Exemplars to avoid nil vs empty slice comparison failures
			h.DataPoints[0].Exemplars = nil
			refH.DataPoints[0].Exemplars = nil

			assert.Equal(t, refH, h)
		})
	}
}
