package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"time"

	"strings"

	"net/http"
	"net/http/httptest"
	"net/http/pprof"

	"github.com/google/pprof/profile"
	"google.golang.org/grpc/metadata"
	"gopkg.in/DataDog/dd-trace-go.v1/ddtrace"
	"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/ext"
	"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
)

func main() {
	log.Printf("starting")
	go memProfile()
	go workload()
	time.Sleep(10 * time.Second)
	log.Printf("unable to reproduce issue, shutting down")
}

func workload() {
	prevCtx := context.Background()
	for {
		_, prevCtx = startSpanFromContext(prevCtx, "foo", "bar", "op", tracer.AnalyticsRate(100))
	}
}

func memProfile() {
	h := pprof.Handler("allocs")

	for {
		recorder := httptest.NewRecorder()
		request, err := http.NewRequest("GET", "/?seconds=1", nil)
		if err != nil {
			panic(err)
		}
		h.ServeHTTP(recorder, request)

		profData := recorder.Body.Bytes()
		prof, err := profile.ParseData(profData)
		if err != nil {
			panic(err)
		}

		for si, s := range prof.Sample {
			for i, v := range s.Value {
				if v < 0 && prof.SampleType[i].Type == "alloc_objects" {
					st := prof.SampleType[i]
					log.Printf("negative delta value for: %s/%s: %d\n", st.Type, st.Unit, v)
					printDetails(prof, si, s)

					log.Printf("writing profile to alloc.pprof")
					ioutil.WriteFile("alloc.pprof", profData, 0666)
					os.Exit(1)
				}
			}
		}
	}
}

func printDetails(prof *profile.Profile, negI int, negSample *profile.Sample) {
	printSample(negI, negSample)

	negativeKey := sampleKey(negSample)
	for si, otherSample := range prof.Sample {
		if otherSample == negSample {
			continue
		}

		otherKey := sampleKey(otherSample)
		if otherKey == negativeKey {
			fmt.Printf("\nfound another sample with the same addrs:\n\n")
			printSample(si, otherSample)
		}
	}
}

func printSample(idx int, s *profile.Sample) {
	fmt.Printf("sample %d values=%v labels=%#v numLabels=%#v\n", idx, s.Value, s.Label, s.NumLabel)
	for _, loc := range s.Location {
		for i, line := range loc.Line {
			fmt.Printf("loc %d addr %d line %d %s() %s:%d\n", loc.ID, loc.Address, i, line.Function.Name, line.Function.Filename, line.Line)
		}
	}
}

func sampleKey(s *profile.Sample) string {
	var addrs []string
	for _, loc := range s.Location {
		addrs = append(addrs, fmt.Sprintf("%d", loc.Address))
	}
	return strings.Join(addrs, ",")
}

func startSpanFromContext(
	ctx context.Context, method, operation, service string, opts ...tracer.StartSpanOption,
) (ddtrace.Span, context.Context) {
	opts = append(opts,
		tracer.ServiceName(service),
		tracer.ResourceName(method),
		tracer.Tag("method", method),
		tracer.SpanType(ext.AppTypeRPC),
	)
	metadata.FromIncomingContext(ctx) // nil is ok
	return tracer.StartSpanFromContext(ctx, operation, opts...)
}

type MDCarrier metadata.MD

var _ tracer.TextMapWriter = (*MDCarrier)(nil)
var _ tracer.TextMapReader = (*MDCarrier)(nil)

// Get will return the first entry in the metadata at the given key.
func (mdc MDCarrier) Get(key string) string {
	if m := mdc[key]; len(m) > 0 {
		return m[0]
	}
	return ""
}

// Set will add the given value to the values found at key. Key will be lowercased to match
// the metadata implementation.
func (mdc MDCarrier) Set(key, val string) {
	k := strings.ToLower(key) // as per google.golang.org/grpc/metadata/metadata.go
	mdc[k] = append(mdc[k], val)
}

// ForeachKey will iterate over all key/value pairs in the metadata.
func (mdc MDCarrier) ForeachKey(handler func(key, val string) error) error {
	for k, vs := range mdc {
		for _, v := range vs {
			if err := handler(k, v); err != nil {
				return err
			}
		}
	}
	return nil
}