package trace

import (
	"context"
	"errors"
	"strings"

	"go.opentelemetry.io/otel/api/propagation"
)

	b3ContextHeader      = "b3"
	b3DebugFlagHeader    = "x-b3-flags"
	b3TraceIDHeader      = "x-b3-traceid"
	b3SpanIDHeader       = "x-b3-spanid"
	b3SampledHeader      = "x-b3-sampled"
	b3ParentSpanIDHeader = "x-b3-parentspanid"

	b3TraceIDPadding = "0000000000000000"

	separatorWidth      = 1       // Single "-" character.
	samplingWidth       = 1       // Single hex character.
	traceID64BitsWidth  = 64 / 4  // 16 hex character Trace ID.
	traceID128BitsWidth = 128 / 4 // 32 hex character Trace ID.
	spanIDWidth         = 16      // 16 hex character ID.
	parentSpanIDWidth   = 16      // 16 hex character ID.
)

var (
	empty = EmptySpanContext()

	errInvalidSampledByte        = errors.New("invalid B3 Sampled found")
	errInvalidSampledHeader      = errors.New("invalid B3 Sampled header found")
	errInvalidTraceIDHeader      = errors.New("invalid B3 TraceID header found")
	errInvalidSpanIDHeader       = errors.New("invalid B3 SpanID header found")
	errInvalidParentSpanIDHeader = errors.New("invalid B3 ParentSpanID header found")
	errInvalidScope              = errors.New("require either both TraceID and SpanID or none")
	errInvalidScopeParent        = errors.New("ParentSpanID requires both TraceID and SpanID to be available")
	errInvalidScopeParentSingle  = errors.New("ParentSpanID requires TraceID, SpanID and Sampled to be available")
	errEmptyContext              = errors.New("empty request context")
	errInvalidTraceIDValue       = errors.New("invalid B3 TraceID value found")
	errInvalidSpanIDValue        = errors.New("invalid B3 SpanID value found")
	errInvalidParentSpanIDValue  = errors.New("invalid B3 ParentSpanID value found")
)

type B3Encoding uint8

func (e B3Encoding) supports(o B3Encoding) bool {
	return e&o == o
}

	B3Unspecified B3Encoding = 0
)

	InjectEncoding B3Encoding
}

var _ propagation.HTTPPropagator = B3{}

func (b3 B3) Inject(ctx context.Context, supplier propagation.HTTPSupplier) {
	sc := SpanFromContext(ctx).SpanContext()

	if b3.InjectEncoding.supports(B3SingleHeader) {
		header := []string{}
		if sc.TraceID.IsValid() && sc.SpanID.IsValid() {
			header = append(header, sc.TraceID.String(), sc.SpanID.String())
		}

		if sc.isDebug() {
			header = append(header, "d")
		} else if !sc.isDeferred() {
			if sc.IsSampled() {
				header = append(header, "1")
			} else {
				header = append(header, "0")
			}
		}

		supplier.Set(b3ContextHeader, strings.Join(header, "-"))
	}

	if b3.InjectEncoding.supports(B3MultipleHeader) || b3.InjectEncoding == B3Unspecified {
		if sc.TraceID.IsValid() && sc.SpanID.IsValid() {
			supplier.Set(b3TraceIDHeader, sc.TraceID.String())
			supplier.Set(b3SpanIDHeader, sc.SpanID.String())
		}

			supplier.Set(b3DebugFlagHeader, "1")
		} else if !sc.isDeferred() {
			if sc.IsSampled() {
				supplier.Set(b3SampledHeader, "1")
			} else {
				supplier.Set(b3SampledHeader, "0")
			}
		}
	}
}

func (b3 B3) Extract(ctx context.Context, supplier propagation.HTTPSupplier) context.Context {
	var (
		sc  SpanContext
		err error
	)

	if h := supplier.Get(b3ContextHeader); h != "" {
		sc, err = extractSingle(h)
		if err == nil && sc.IsValid() {
			return ContextWithRemoteSpanContext(ctx, sc)

	}

	var (
		traceID      = supplier.Get(b3TraceIDHeader)
		spanID       = supplier.Get(b3SpanIDHeader)
		parentSpanID = supplier.Get(b3ParentSpanIDHeader)
		sampled      = supplier.Get(b3SampledHeader)
		debugFlag    = supplier.Get(b3DebugFlagHeader)
	)
	sc, err = extractMultiple(traceID, spanID, parentSpanID, sampled, debugFlag)
	if err != nil || !sc.IsValid() {
		return ctx
	}
	return ContextWithRemoteSpanContext(ctx, sc)
}

func (b3 B3) GetAllKeys() []string {
	header := []string{}
	if b3.InjectEncoding.supports(B3SingleHeader) {
		header = append(header, b3ContextHeader)
	}
	if b3.InjectEncoding.supports(B3MultipleHeader) || b3.InjectEncoding == B3Unspecified {
		header = append(header, b3TraceIDHeader, b3SpanIDHeader, b3SampledHeader, b3DebugFlagHeader)
	}
	return header
}

func extractMultiple(traceID, spanID, parentSpanID, sampled, flags string) (SpanContext, error) {
	var (
		err           error
		requiredCount int
		sc            = SpanContext{}
	)

	switch strings.ToLower(sampled) {

	case "1", "true":
		sc.TraceFlags = FlagsSampled
	case "":
		sc.TraceFlags = FlagsDeferred
	default:
		return empty, errInvalidSampledHeader
	}

	if flags == "1" {
		sc.TraceFlags |= FlagsDebug
	}

	if traceID != "" {
		requiredCount++
		id := traceID

			id = b3TraceIDPadding + traceID
		}
		if sc.TraceID, err = IDFromHex(id); err != nil {
			return empty, errInvalidTraceIDHeader
		}
	}

	if spanID != "" {
		requiredCount++
		if sc.SpanID, err = SpanIDFromHex(spanID); err != nil {
			return empty, errInvalidSpanIDHeader
		}
	}

	if requiredCount != 0 && requiredCount != 2 {
		return empty, errInvalidScope
	}

	if parentSpanID != "" {
		if requiredCount == 0 {
			return empty, errInvalidScopeParent

		if _, err = SpanIDFromHex(parentSpanID); err != nil {
			return empty, errInvalidParentSpanIDHeader
		}
	}

	return sc, nil
}

func extractSingle(contextHeader string) (SpanContext, error) {
	if contextHeader == "" {
		return empty, errEmptyContext
	}

	var (
		sc       = SpanContext{}
		sampling string
	)

	headerLen := len(contextHeader)

	if headerLen == samplingWidth {
		sampling = contextHeader

		return empty, errInvalidScope
	} else if headerLen >= traceID64BitsWidth+spanIDWidth+separatorWidth {
		pos := 0
		var traceID string

			pos += traceID64BitsWidth // {traceID}
			traceID = b3TraceIDPadding + string(contextHeader[0:pos])

			pos += traceID128BitsWidth // {traceID}
			traceID = string(contextHeader[0:pos])
		} else {
			return empty, errInvalidTraceIDValue
		}
		var err error
		sc.TraceID, err = IDFromHex(traceID)
		if err != nil {
			return empty, errInvalidTraceIDValue
		}
		pos += separatorWidth // {traceID}-

		sc.SpanID, err = SpanIDFromHex(contextHeader[pos : pos+spanIDWidth])
		if err != nil {
			return empty, errInvalidSpanIDValue
		}
		pos += spanIDWidth // {traceID}-{spanID}

		if headerLen > pos {

				return empty, errInvalidSampledByte
			}
			pos += separatorWidth // {traceID}-{spanID}-

			if headerLen == pos+samplingWidth {
				sampling = string(contextHeader[pos])

				return empty, errInvalidScopeParentSingle
			} else if headerLen == pos+samplingWidth+separatorWidth+parentSpanIDWidth {
				sampling = string(contextHeader[pos])
				pos += samplingWidth + separatorWidth // {traceID}-{spanID}-{sampling}-

				_, err = SpanIDFromHex(contextHeader[pos:])
				if err != nil {
					return empty, errInvalidParentSpanIDValue
				}
			} else {
				return empty, errInvalidParentSpanIDValue
			}
		}
	} else {
		return empty, errInvalidTraceIDValue
	}
	switch sampling {
	case "":
		sc.TraceFlags = FlagsDeferred
	case "d":
		sc.TraceFlags = FlagsDebug
	case "1":
		sc.TraceFlags = FlagsSampled

	default:
		return empty, errInvalidSampledByte
	}

	return sc, nil