package main

import (
	"context"
	"fmt"
	"os/signal"
	"syscall"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

var (
	tracer = otel.Tracer("otelgen")
)

func main() {
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	res := makeResource(ctx)
	shutdown := initOpenTelemetry(ctx, res, "localhost:4317")

	ticker := time.NewTicker(10 * time.Second)

loop:
	for {
		select {
		case <-ctx.Done():
			shutdown(context.TODO())
			break loop
		case <-ticker.C:
			genSpan(ctx)
		}
	}
}

func genSpan(ctx context.Context) {
	ctx, span := tracer.Start(ctx, "generate")
	defer span.End()

	span.AddEvent("example span event")
}

func initOpenTelemetry(ctx context.Context, res *resource.Resource, endpoint string) func(ctx context.Context) error {
	exporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithEndpoint(endpoint), otlptracegrpc.WithInsecure())
	if err != nil {
		panic(fmt.Errorf("failed to create OTLP exporter: %w", err))
	}

	bsp := sdktrace.NewBatchSpanProcessor(exporter)
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithSampler(sdktrace.ParentBased(sdktrace.AlwaysSample())),
		sdktrace.WithResource(res),
		sdktrace.WithSpanProcessor(bsp),
	)

	otel.SetTracerProvider(tp)
	otel.SetTextMapPropagator(propagation.TraceContext{})

	return tp.Shutdown
}

func makeResource(ctx context.Context) *resource.Resource {
	res, err := resource.New(ctx,
		resource.WithFromEnv(),
		resource.WithHost(),
		resource.WithOS(),
		resource.WithProcess(),
		resource.WithTelemetrySDK(),
	)

	if err != nil {
		panic(fmt.Errorf("failed to create resource: %w", err))
	}

	return res
}