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

package stdoutmetric_test // import "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric"

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"io"
	"strconv"
	"testing"
	"time"

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

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric"
	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/counter"
	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/observ"
	"go.opentelemetry.io/otel/sdk"
	"go.opentelemetry.io/otel/sdk/instrumentation"
	"go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
	"go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
	"go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
)

func testEncoderOption() stdoutmetric.Option {
	// Discard export output for testing.
	enc := json.NewEncoder(io.Discard)
	return stdoutmetric.WithEncoder(enc)
}

var errEnc = errors.New("encoding failed")

// failingEncoder always returns an error when Encode is called.
type failingEncoder struct{}

func (failingEncoder) Encode(any) error {
	return errEnc
}

func testCtxErrHonored(factory func(*testing.T) func(context.Context) error) func(t *testing.T) {
	return func(t *testing.T) {
		t.Helper()
		ctx := t.Context()

		t.Run("DeadlineExceeded", func(t *testing.T) {
			innerCtx, innerCancel := context.WithTimeout(ctx, time.Nanosecond)
			t.Cleanup(innerCancel)
			<-innerCtx.Done()

			f := factory(t)
			assert.ErrorIs(t, f(innerCtx), context.DeadlineExceeded)
		})

		t.Run("Canceled", func(t *testing.T) {
			innerCtx, innerCancel := context.WithCancel(ctx)
			innerCancel()

			f := factory(t)
			assert.ErrorIs(t, f(innerCtx), context.Canceled)
		})

		t.Run("NoError", func(t *testing.T) {
			f := factory(t)
			assert.NoError(t, f(ctx))
		})
	}
}

func testCtxErrIgnored(factory func(*testing.T) func(context.Context) error) func(t *testing.T) {
	return func(t *testing.T) {
		t.Helper()
		ctx := t.Context()

		t.Run("Canceled Ignored", func(t *testing.T) {
			innerCtx, innerCancel := context.WithCancel(ctx)
			innerCancel()

			f := factory(t)
			assert.NoError(t, f(innerCtx))
		})

		t.Run("NoError", func(t *testing.T) {
			f := factory(t)
			assert.NoError(t, f(ctx))
		})
	}
}

func TestExporterExportHonorsContextErrors(t *testing.T) {
	t.Run("Export", testCtxErrHonored(func(t *testing.T) func(context.Context) error {
		exp, err := stdoutmetric.New(testEncoderOption())
		require.NoError(t, err)
		return func(ctx context.Context) error {
			data := new(metricdata.ResourceMetrics)
			return exp.Export(ctx, data)
		}
	}))
}

func TestExporterForceFlushIgnoresContextErrors(t *testing.T) {
	t.Run("ForceFlush", testCtxErrIgnored(func(t *testing.T) func(context.Context) error {
		exp, err := stdoutmetric.New(testEncoderOption())
		require.NoError(t, err)
		return exp.ForceFlush
	}))
}

func TestExporterShutdownIgnoresContextErrors(t *testing.T) {
	t.Run("Shutdown", testCtxErrIgnored(func(t *testing.T) func(context.Context) error {
		exp, err := stdoutmetric.New(testEncoderOption())
		require.NoError(t, err)
		return exp.Shutdown
	}))
}

func TestShutdownExporterReturnsShutdownErrorOnExport(t *testing.T) {
	var (
		data     = new(metricdata.ResourceMetrics)
		ctx      = t.Context()
		exp, err = stdoutmetric.New(testEncoderOption())
	)
	require.NoError(t, err)
	require.NoError(t, exp.Shutdown(ctx))
	assert.EqualError(t, exp.Export(ctx, data), "exporter shutdown")
}

func deltaSelector(metric.InstrumentKind) metricdata.Temporality {
	return metricdata.DeltaTemporality
}

func TestExportWithOptions(t *testing.T) {
	var (
		data = new(metricdata.ResourceMetrics)
		ctx  = t.Context()
	)

	for _, tt := range []struct {
		name string
		opts []stdoutmetric.Option

		expectedData string
	}{
		{
			name:         "with no options",
			expectedData: "{\"Resource\":null,\"ScopeMetrics\":null}\n",
		},
		{
			name: "with pretty print",
			opts: []stdoutmetric.Option{
				stdoutmetric.WithPrettyPrint(),
			},
			expectedData: "{\n\t\"Resource\": null,\n\t\"ScopeMetrics\": null\n}\n",
		},
	} {
		t.Run(tt.name, func(t *testing.T) {
			var b bytes.Buffer
			opts := append(tt.opts, stdoutmetric.WithWriter(&b))

			exp, err := stdoutmetric.New(opts...)
			require.NoError(t, err)
			require.NoError(t, exp.Export(ctx, data))

			assert.Equal(t, tt.expectedData, b.String())
		})
	}
}

func TestTemporalitySelector(t *testing.T) {
	exp, err := stdoutmetric.New(
		testEncoderOption(),
		stdoutmetric.WithTemporalitySelector(deltaSelector),
	)
	require.NoError(t, err)

	var unknownKind metric.InstrumentKind
	assert.Equal(t, metricdata.DeltaTemporality, exp.Temporality(unknownKind))
}

func dropSelector(metric.InstrumentKind) metric.Aggregation {
	return metric.AggregationDrop{}
}

func TestAggregationSelector(t *testing.T) {
	exp, err := stdoutmetric.New(
		testEncoderOption(),
		stdoutmetric.WithAggregationSelector(dropSelector),
	)
	require.NoError(t, err)

	var unknownKind metric.InstrumentKind
	assert.Equal(t, metric.AggregationDrop{}, exp.Aggregation(unknownKind))
}

func TestExporterExportObservability(t *testing.T) {
	componentNameAttr := observ.ExporterComponentName(0)
	componentTypeAttr := semconv.OTelComponentTypeKey.String(observ.ComponentType)

	tests := []struct {
		name                  string
		exporterOpts          []stdoutmetric.Option
		observabilityEnabled  bool
		expectedExportedCount int64
		inflightAttrs         attribute.Set
		attributes            attribute.Set
		wantErr               error
	}{
		{
			name:                  "Enabled",
			exporterOpts:          []stdoutmetric.Option{testEncoderOption()},
			observabilityEnabled:  true,
			expectedExportedCount: expectedDataPointCount,
			inflightAttrs:         attribute.NewSet(componentNameAttr, componentTypeAttr),
			attributes:            attribute.NewSet(componentNameAttr, componentTypeAttr),
		},
		{
			name:                  "Disabled",
			exporterOpts:          []stdoutmetric.Option{testEncoderOption()},
			observabilityEnabled:  false,
			expectedExportedCount: 0,
		},
		{
			name:                  "EncodingError",
			exporterOpts:          []stdoutmetric.Option{stdoutmetric.WithEncoder(failingEncoder{})},
			observabilityEnabled:  true,
			expectedExportedCount: expectedDataPointCount,
			inflightAttrs:         attribute.NewSet(componentNameAttr, componentTypeAttr),
			attributes: attribute.NewSet(
				componentNameAttr,
				componentTypeAttr,
				semconv.ErrorType(errEnc),
			),
			wantErr: errEnc,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Setenv("OTEL_GO_X_OBSERVABILITY", strconv.FormatBool(tt.observabilityEnabled))

			// Reset the exporter ID counter to ensure consistent component names
			_ = counter.SetExporterID(0)

			reader := metric.NewManualReader()
			mp := metric.NewMeterProvider(metric.WithReader(reader))
			origMp := otel.GetMeterProvider()
			otel.SetMeterProvider(mp)
			t.Cleanup(func() { otel.SetMeterProvider(origMp) })

			exp, err := stdoutmetric.New(tt.exporterOpts...)
			require.NoError(t, err)
			rm := &metricdata.ResourceMetrics{ScopeMetrics: scopeMetrics()}

			ctx := t.Context()
			err = exp.Export(ctx, rm)
			if tt.wantErr != nil {
				assert.ErrorIs(t, err, tt.wantErr)
			} else {
				assert.NoError(t, err)
			}

			var metrics metricdata.ResourceMetrics
			err = reader.Collect(ctx, &metrics)
			require.NoError(t, err)

			if !tt.observabilityEnabled {
				assert.Empty(t, metrics.ScopeMetrics)
				return
			}

			expectedMetrics := metricdata.ScopeMetrics{
				Scope: instrumentation.Scope{
					Name:      "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/observ",
					Version:   sdk.Version(),
					SchemaURL: semconv.SchemaURL,
				},
				Metrics: []metricdata.Metrics{
					{
						Name:        otelconv.SDKExporterMetricDataPointInflight{}.Name(),
						Description: otelconv.SDKExporterMetricDataPointInflight{}.Description(),
						Unit:        otelconv.SDKExporterMetricDataPointInflight{}.Unit(),
						Data: metricdata.Sum[int64]{
							DataPoints: []metricdata.DataPoint[int64]{
								{
									Value:      0,
									Attributes: tt.inflightAttrs,
								},
							},
							Temporality: metricdata.CumulativeTemporality,
						},
					},
					{
						Name:        otelconv.SDKExporterMetricDataPointExported{}.Name(),
						Description: otelconv.SDKExporterMetricDataPointExported{}.Description(),
						Unit:        otelconv.SDKExporterMetricDataPointExported{}.Unit(),
						Data: metricdata.Sum[int64]{
							DataPoints: []metricdata.DataPoint[int64]{
								{
									Value:      tt.expectedExportedCount,
									Attributes: tt.attributes,
								},
							},
							Temporality: metricdata.CumulativeTemporality,
							IsMonotonic: true,
						},
					},
					{
						Name:        otelconv.SDKExporterOperationDuration{}.Name(),
						Description: otelconv.SDKExporterOperationDuration{}.Description(),
						Unit:        otelconv.SDKExporterOperationDuration{}.Unit(),
						Data: metricdata.Histogram[float64]{
							DataPoints: []metricdata.HistogramDataPoint[float64]{
								{
									Attributes: tt.attributes,
								},
							},
							Temporality: metricdata.CumulativeTemporality,
						},
					},
				},
			}
			require.Len(t, metrics.ScopeMetrics, 1)
			assert.Equal(t, expectedMetrics.Scope, metrics.ScopeMetrics[0].Scope)
			require.Len(t, expectedMetrics.Metrics, 3)
			metricdatatest.AssertEqual(
				t,
				expectedMetrics.Metrics[0],
				metrics.ScopeMetrics[0].Metrics[0],
				metricdatatest.IgnoreTimestamp(),
			)
			metricdatatest.AssertEqual(
				t,
				expectedMetrics.Metrics[1],
				metrics.ScopeMetrics[0].Metrics[1],
				metricdatatest.IgnoreTimestamp(),
			)
			metricdatatest.AssertEqual(
				t,
				expectedMetrics.Metrics[2],
				metrics.ScopeMetrics[0].Metrics[2],
				metricdatatest.IgnoreTimestamp(),
				metricdatatest.IgnoreValue(),
			)
		})
	}
}

const expectedDataPointCount = 19

func scopeMetrics() []metricdata.ScopeMetrics {
	return []metricdata.ScopeMetrics{
		{
			Metrics: []metricdata.Metrics{
				{
					Name: "gauge_int64",
					Data: metricdata.Gauge[int64]{
						DataPoints: []metricdata.DataPoint[int64]{{Value: 1}, {Value: 2}},
					},
				},
				{
					Name: "gauge_float64",
					Data: metricdata.Gauge[float64]{
						DataPoints: []metricdata.DataPoint[float64]{
							{Value: 1.0},
							{Value: 2.0},
							{Value: 3.0},
						},
					},
				},
				{
					Name: "sum_int64",
					Data: metricdata.Sum[int64]{
						DataPoints: []metricdata.DataPoint[int64]{{Value: 10}},
					},
				},
				{
					Name: "sum_float64",
					Data: metricdata.Sum[float64]{
						DataPoints: []metricdata.DataPoint[float64]{{Value: 10.5}, {Value: 20.5}},
					},
				},
				{
					Name: "histogram_int64",
					Data: metricdata.Histogram[int64]{
						DataPoints: []metricdata.HistogramDataPoint[int64]{
							{Count: 1},
							{Count: 2},
							{Count: 3},
						},
					},
				},
				{
					Name: "histogram_float64",
					Data: metricdata.Histogram[float64]{
						DataPoints: []metricdata.HistogramDataPoint[float64]{{Count: 1}},
					},
				},
				{
					Name: "exponential_histogram_int64",
					Data: metricdata.ExponentialHistogram[int64]{
						DataPoints: []metricdata.ExponentialHistogramDataPoint[int64]{
							{Count: 1},
							{Count: 2},
						},
					},
				},
				{
					Name: "exponential_histogram_float64",
					Data: metricdata.ExponentialHistogram[float64]{
						DataPoints: []metricdata.ExponentialHistogramDataPoint[float64]{
							{Count: 1},
							{Count: 2},
							{Count: 3},
							{Count: 4},
						},
					},
				},
				{
					Name: "summary",
					Data: metricdata.Summary{
						DataPoints: []metricdata.SummaryDataPoint{{Count: 1}},
					},
				},
			},
		},
	}
}

func TestExporterExportEncodingErrorTracking(t *testing.T) {
	t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
	reader := metric.NewManualReader()
	mp := metric.NewMeterProvider(metric.WithReader(reader))
	origMp := otel.GetMeterProvider()
	otel.SetMeterProvider(mp)
	t.Cleanup(func() { otel.SetMeterProvider(origMp) })

	exp, err := stdoutmetric.New(stdoutmetric.WithEncoder(failingEncoder{}))
	assert.NoError(t, err)

	rm := &metricdata.ResourceMetrics{
		ScopeMetrics: []metricdata.ScopeMetrics{
			{
				Metrics: []metricdata.Metrics{
					{
						Name: "test_gauge",
						Data: metricdata.Gauge[int64]{
							DataPoints: []metricdata.DataPoint[int64]{{Value: 1}, {Value: 2}},
						},
					},
				},
			},
		},
	}

	ctx := t.Context()
	err = exp.Export(ctx, rm)
	assert.ErrorIs(t, err, errEnc)

	var metrics metricdata.ResourceMetrics
	err = reader.Collect(ctx, &metrics)
	require.NoError(t, err)

	var foundErrorType bool
	for _, sm := range metrics.ScopeMetrics {
		for _, m := range sm.Metrics {
			x := otelconv.SDKExporterMetricDataPointExported{}.Name()
			if m.Name == x {
				if sum, ok := m.Data.(metricdata.Sum[int64]); ok {
					for _, dp := range sum.DataPoints {
						var attr attribute.Value
						attr, foundErrorType = dp.Attributes.Value(semconv.ErrorTypeKey)
						assert.Equal(t, "*errors.errorString", attr.AsString())
					}
				}
			}
		}
	}
	assert.True(t, foundErrorType)
}

func BenchmarkExporterExport(b *testing.B) {
	rm := &metricdata.ResourceMetrics{ScopeMetrics: scopeMetrics()}

	run := func(b *testing.B) {
		ex, err := stdoutmetric.New(stdoutmetric.WithWriter(io.Discard))
		if err != nil {
			b.Fatalf("failed to create exporter: %v", err)
		}

		b.ReportAllocs()
		b.ResetTimer()
		for b.Loop() {
			err = ex.Export(b.Context(), rm)
		}
		_ = err
	}

	b.Run("Observability", func(b *testing.B) {
		b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
		run(b)
	})

	b.Run("NoObservability", run)
}