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

// Package observ provides observability for stdout metric exporter.
// This is an experimental feature controlled by the x.Observability feature flag.
package observ // import "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/observ"

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal"
	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/x"
	"go.opentelemetry.io/otel/metric"
	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
	"go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
)

const (
	scope = "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/observ"

	// ComponentType is a name identifying the type of the OpenTelemetry
	// component. It is not a standardized OTel component type, so it uses the
	// Go package prefixed type name to ensure uniqueness and identity.
	ComponentType = "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric.exporter"

	// Version is the current version of this instrumentation.
	//
	// This matches the version of the exporter.
	Version = internal.Version
)

var (
	measureAttrsPool = &sync.Pool{
		New: func() any {
			// "component.name" + "component.type" + "error.type"
			const n = 1 + 1 + 1
			s := make([]attribute.KeyValue, 0, n)
			// Return a pointer to a slice instead of a slice itself
			// to avoid allocations on every call.
			return &s
		},
	}

	addOptsPool = &sync.Pool{
		New: func() any {
			const n = 1 // WithAttributeSet
			s := make([]metric.AddOption, 0, n)
			return &s
		},
	}

	recordOptsPool = &sync.Pool{
		New: func() any {
			const n = 1 // WithAttributeSet
			s := make([]metric.RecordOption, 0, n)
			return &s
		},
	}
)

func get[T any](p *sync.Pool) *[]T { return p.Get().(*[]T) }

func put[T any](p *sync.Pool, s *[]T) {
	*s = (*s)[:0] // Reset.
	p.Put(s)
}

// Instrumentation is the instrumentation for stdout metric exporter.
type Instrumentation struct {
	inflight metric.Int64UpDownCounter
	exported otelconv.SDKExporterMetricDataPointExported
	duration otelconv.SDKExporterOperationDuration

	attrs      []attribute.KeyValue
	addOpts    []metric.AddOption
	recordOpts []metric.RecordOption
}

// ExporterComponentName returns the component name attribute for the exporter
// with the provided ID.
func ExporterComponentName(id int64) attribute.KeyValue {
	componentName := fmt.Sprintf("%s/%d", ComponentType, id)
	return semconv.OTelComponentName(componentName)
}

// NewInstrumentation returns a new Instrumentation for the stdout metric exporter
// with the provided ID.
//
// If the experimental observability is disabled, nil is returned.
func NewInstrumentation(id int64) (*Instrumentation, error) {
	if !x.Observability.Enabled() {
		return nil, nil
	}
	attrs := []attribute.KeyValue{
		ExporterComponentName(id),
		semconv.OTelComponentTypeKey.String(ComponentType),
	}
	attrOpts := metric.WithAttributeSet(attribute.NewSet(attrs...))
	addOpts := []metric.AddOption{attrOpts}
	recordOpts := []metric.RecordOption{attrOpts}
	em := &Instrumentation{
		attrs:      attrs,
		addOpts:    addOpts,
		recordOpts: recordOpts,
	}
	mp := otel.GetMeterProvider()
	m := mp.Meter(
		scope,
		metric.WithInstrumentationVersion(Version),
		metric.WithSchemaURL(semconv.SchemaURL),
	)

	var err error
	inflightMetric, e := otelconv.NewSDKExporterMetricDataPointInflight(m)
	if e != nil {
		e = fmt.Errorf("failed to create metric_data_point inflight metric: %w", e)
		err = errors.Join(err, e)
	}
	em.inflight = inflightMetric.Inst()
	if em.exported, e = otelconv.NewSDKExporterMetricDataPointExported(m); e != nil {
		e = fmt.Errorf("failed to create metric_data_point exported metric: %w", e)
		err = errors.Join(err, e)
	}
	if em.duration, e = otelconv.NewSDKExporterOperationDuration(m); e != nil {
		e = fmt.Errorf("failed to create operation duration metric: %w", e)
		err = errors.Join(err, e)
	}
	return em, err
}

// ExportMetrics instruments the Export method of the exporter. It returns an
// ExportOp that needs to be ended with End() when the export operation completes.
func (i *Instrumentation) ExportMetrics(ctx context.Context, count int64) ExportOp {
	start := time.Now()

	// Avoid work when observability is disabled.
	if i.inflight.Enabled(ctx) {
		i.inflight.Add(ctx, count, i.addOpts...)
	}
	return ExportOp{
		ctx:     ctx,
		start:   start,
		nTraces: count,
		inst:    i,
	}
}

// ExportOp is an in-progress ExportMetrics operation.
type ExportOp struct {
	ctx     context.Context
	start   time.Time
	nTraces int64
	inst    *Instrumentation
}

// End ends the ExportMetrics operation, recording its duration.
//
// The err parameter indicates whether the operation failed. If err is not nil,
// it is added to metrics as attribute.
func (e ExportOp) End(err error) {
	inflightEnabled := e.inst.inflight.Enabled(e.ctx)
	exportedEnabled := e.inst.exported.Enabled(e.ctx)
	durationEnabled := e.inst.duration.Enabled(e.ctx)

	if !inflightEnabled && !exportedEnabled && !durationEnabled {
		return
	}

	var durationSeconds float64
	if durationEnabled {
		durationSeconds = time.Since(e.start).Seconds()
	}
	if inflightEnabled {
		e.inst.inflight.Add(e.ctx, -e.nTraces, e.inst.addOpts...)
	}
	if err == nil { // short circuit in case of success to avoid allocations
		if exportedEnabled {
			e.inst.exported.Inst().Add(e.ctx, e.nTraces, e.inst.addOpts...)
		}
		if durationEnabled {
			e.inst.duration.Inst().Record(e.ctx, durationSeconds, e.inst.recordOpts...)
		}
		return
	}

	if !exportedEnabled && !durationEnabled {
		return
	}

	attrs := get[attribute.KeyValue](measureAttrsPool)
	defer func() {
		put(measureAttrsPool, attrs)
	}()
	*attrs = append(*attrs, e.inst.attrs...)
	*attrs = append(*attrs, semconv.ErrorType(err))

	set := attribute.NewSet(*attrs...)
	attrOpt := metric.WithAttributeSet(set)

	if exportedEnabled {
		addOpts := get[metric.AddOption](addOptsPool)
		defer put(addOptsPool, addOpts)

		*addOpts = append(*addOpts, attrOpt)
		e.inst.exported.Inst().Add(e.ctx, e.nTraces, *addOpts...)
	}
	if durationEnabled {
		recordOpts := get[metric.RecordOption](recordOptsPool)
		defer put(recordOptsPool, recordOpts)

		*recordOpts = append(*recordOpts, attrOpt)
		e.inst.duration.Inst().Record(e.ctx, durationSeconds, *recordOpts...)
	}
}