package main

import (
	"bytes"
	"context"
	"fmt"
	"log"
	"net/http"
	"time"

	"go.opentelemetry.io/collector/pdata/pcommon"
	"go.opentelemetry.io/collector/pdata/plog"
	"go.opentelemetry.io/collector/pdata/pmetric"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
	"go.opentelemetry.io/otel/trace"
)

func main() {
	ctx := context.Background()

	fmt.Println("Testing OTLP Debug Receiver...")
	fmt.Println("Make sure the receiver is running on ports 8080 (HTTP) and 4317 (gRPC)")
	fmt.Println()

	// Test HTTP endpoint
	fmt.Println("Testing HTTP endpoint...")
	testHTTPTraces(ctx)

	time.Sleep(1 * time.Second)

	// Test gRPC endpoint
	fmt.Println("Testing gRPC endpoint...")
	testGRPCTraces(ctx)

	time.Sleep(1 * time.Second)

	// Test HTTP metrics
	fmt.Println("Testing HTTP metrics...")
	testHTTPMetrics()

	time.Sleep(1 * time.Second)

	// Test HTTP logs
	fmt.Println("Testing HTTP logs...")
	testHTTPLogs()

	fmt.Println()
	fmt.Println("Test completed! Check the receiver logs and web interface at http://localhost:8080")
	fmt.Println("You should see traces, metrics, and logs from both HTTP and gRPC clients.")
}

func testHTTPTraces(ctx context.Context) {
	// Create OTLP HTTP exporter
	exporter, err := otlptracehttp.New(ctx,
		otlptracehttp.WithEndpoint("localhost:8080"),
		otlptracehttp.WithInsecure(),
	)
	if err != nil {
		log.Fatalf("failed to create HTTP exporter: %v", err)
	}

	// Create tracer provider
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceNameKey.String("test-client-http"),
			semconv.ServiceVersionKey.String("1.0.0"),
		)),
	)
	defer func() {
		if err := tp.Shutdown(ctx); err != nil {
			log.Printf("failed to shutdown tracer provider: %v", err)
		}
	}()

	otel.SetTracerProvider(tp)

	// Create tracer
	tracer := tp.Tracer("test-tracer")

	// Create some sample spans
	for i := 0; i < 3; i++ {
		_, span := tracer.Start(ctx, fmt.Sprintf("http-test-span-%d", i),
			trace.WithAttributes(
				attribute.String("test.key", fmt.Sprintf("test-value-%d", i)),
				attribute.Int("test.number", i),
			),
		)

		// Add an event
		span.AddEvent("test event", trace.WithAttributes(
			attribute.String("event.key", "event.value"),
		))

		// Simulate some work
		time.Sleep(10 * time.Millisecond)

		span.End()
	}

	// Force flush
	if err := tp.ForceFlush(ctx); err != nil {
		log.Printf("failed to flush: %v", err)
	}

	fmt.Println("HTTP traces sent successfully")
}

func testGRPCTraces(ctx context.Context) {
	// Create OTLP gRPC exporter
	exporter, err := otlptracegrpc.New(ctx,
		otlptracegrpc.WithEndpoint("localhost:4317"),
		otlptracegrpc.WithInsecure(),
	)
	if err != nil {
		log.Fatalf("failed to create gRPC exporter: %v", err)
	}

	// Create tracer provider
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceNameKey.String("test-client-grpc"),
			semconv.ServiceVersionKey.String("1.0.0"),
		)),
	)
	defer func() {
		if err := tp.Shutdown(ctx); err != nil {
			log.Printf("failed to shutdown tracer provider: %v", err)
		}
	}()

	otel.SetTracerProvider(tp)

	// Create tracer
	tracer := tp.Tracer("test-tracer-grpc")

	// Create some sample spans
	for i := 0; i < 3; i++ {
		_, span := tracer.Start(ctx, fmt.Sprintf("grpc-test-span-%d", i),
			trace.WithAttributes(
				attribute.String("test.key", fmt.Sprintf("grpc-test-value-%d", i)),
				attribute.Int("test.number", i*10),
			),
		)

		// Add an event
		span.AddEvent("grpc test event", trace.WithAttributes(
			attribute.String("grpc.event.key", "grpc.event.value"),
		))

		// Simulate some work
		time.Sleep(10 * time.Millisecond)

		span.End()
	}

	// Force flush
	if err := tp.ForceFlush(ctx); err != nil {
		log.Printf("failed to flush: %v", err)
	}

	fmt.Println("gRPC traces sent successfully")
}

func testHTTPMetrics() {
	md := pmetric.NewMetrics()
	resourceMetrics := md.ResourceMetrics().AppendEmpty()
	resourceMetrics.Resource().Attributes().PutStr("service.name", "test-client-metric")
	scopeMetrics := resourceMetrics.ScopeMetrics().AppendEmpty()
	scopeMetrics.Scope().SetName("test-meter")
	metric := scopeMetrics.Metrics().AppendEmpty()
	metric.SetName("test_counter")
	gauge := metric.SetEmptyGauge()
	dataPoint := gauge.DataPoints().AppendEmpty()
	dataPoint.SetIntValue(42)
	dataPoint.Attributes().PutStr("test.key", "test-value")
	marshaler := &pmetric.ProtoMarshaler{}
	buf, err := marshaler.MarshalMetrics(md)
	if err != nil {
		log.Printf("failed to marshal metrics: %v", err)
		return
	}
	resp, err := http.Post("http://localhost:8080/v1/metrics", "application/x-protobuf", bytes.NewReader(buf))
	if err != nil {
		log.Printf("failed to post metrics: %v", err)
		return
	}
	resp.Body.Close()
	fmt.Println("HTTP metrics sent successfully")
}

func testHTTPLogs() {
	ld := plog.NewLogs()
	resourceLogs := ld.ResourceLogs().AppendEmpty()
	resourceLogs.Resource().Attributes().PutStr("service.name", "test-client-log")
	scopeLogs := resourceLogs.ScopeLogs().AppendEmpty()
	scopeLogs.Scope().SetName("test-logger")
	logRecord := scopeLogs.LogRecords().AppendEmpty()
	logRecord.Body().SetStr("test log message")
	logRecord.SetTimestamp(pcommon.NewTimestampFromTime(time.Now()))
	logRecord.Attributes().PutStr("test.key", "test-value")
	marshaler := &plog.ProtoMarshaler{}
	buf, err := marshaler.MarshalLogs(ld)
	if err != nil {
		log.Printf("failed to marshal logs: %v", err)
		return
	}
	resp, err := http.Post("http://localhost:8080/v1/logs", "application/x-protobuf", bytes.NewReader(buf))
	if err != nil {
		log.Printf("failed to post logs: %v", err)
		return
	}
	resp.Body.Close()
	fmt.Println("HTTP logs sent successfully")
}