const (
	DefaultCollectorPath     = "/_rpc/v1/reports/binary"
	DefaultPlainPort         = 80
	DefaultSecurePort        = 443
	DefaultGRPCCollectorHost = "collector-grpc.lightstep.com"

	DefaultSystemMetricsHost = "ingest.lightstep.com"

	DefaultSystemMetricsMeasurementFrequency = 30 * time.Second
	DefaultSystemMetricsTimeout              = 5 * time.Second

	DefaultMaxReportingPeriod = 2500 * time.Millisecond
	DefaultMinReportingPeriod = 500 * time.Millisecond
	DefaultMaxSpans           = 1000
	DefaultReportTimeout      = 30 * time.Second
	DefaultReconnectPeriod    = 5 * time.Minute

	DefaultMaxLogKeyLen   = 256
	DefaultMaxLogValueLen = 1024
	DefaultMaxLogsPerSpan = 500

	DefaultGRPCMaxCallSendMsgSizeBytes = math.MaxInt32
)

const (
	ParentSpanGUIDKey = "parent_span_guid"         // ParentSpanGUIDKey is the tag key used to record the relationship between child and parent spans.
	ComponentNameKey  = constants.ComponentNameKey // NOTE: these will be deprecated in favour of the constants package
	GUIDKey           = "lightstep.guid"           // <- runtime guid, not span guid
	HostnameKey       = constants.HostnameKey      // NOTE: these will be deprecated in favour of the constants package
	CommandLineKey    = "lightstep.command_line"
	ServiceVersionKey = constants.ServiceVersionKey // NOTE: these will be deprecated in favour of the constants package

	TracerPlatformKey        = "lightstep.tracer_platform"
	TracerPlatformValue      = "go"
	TracerPlatformVersionKey = "lightstep.tracer_platform_version"
	TracerVersionKey         = "lightstep.tracer_version" // Note: TracerVersionValue is generated from ./VERSION
)

const BinaryCarrier = opentracing.Binary

const LSMetaEvent_ExtractOperation = "lightstep.extract_span"

const LSMetaEvent_InjectOperation = "lightstep.inject_span"

const LSMetaEvent_MetaEventKey = "lightstep.meta_event"

const LSMetaEvent_PropagationFormatKey = "lightstep.propagation_format"

const LSMetaEvent_SpanFinishOperation = "lightstep.span_finish"

const LSMetaEvent_SpanIdKey = "lightstep.span_id"

const LSMetaEvent_SpanStartOperation = "lightstep.span_start"

const LSMetaEvent_TraceIdKey = "lightstep.trace_id"

const LSMetaEvent_TracerCreateOperation = "lightstep.tracer_create"

const LSMetaEvent_TracerGuidKey = "lightstep.tracer_guid"

const TracerVersionValue = "0.26.0"

var B3Propagator b3Propagator

var BinaryPropagator binaryPropagator

var LightStepPropagator lightstepPropagator

type Collector interface {
	Report(context.Context, *collectorpb.ReportRequest) (*collectorpb.ReportResponse, error)
}

type Connection interface {
	io.Closer
}

type ConnectorFactory func() (interface{}, Connection, error)

type Endpoint struct {
	Scheme           string `yaml:"scheme" json:"scheme" usage:"scheme to use for the endpoint, defaults to appropriate one if no custom one is required"`
	Host             string `yaml:"host" json:"host" usage:"host on which the endpoint is running"`
	Port             int    `yaml:"port" json:"port" usage:"port on which the endpoint is listening"`
	Plaintext        bool   `yaml:"plaintext" json:"plaintext" usage:"whether or not to encrypt data send to the endpoint"`
	CustomCACertFile string `yaml:"custom_ca_cert_file" json:"custom_ca_cert_file" usage:"path to a custom CA cert file, defaults to system defined certs if omitted"`
}

type ErrorEvent interface {
	Event
	error
	Err() error
}

type Event interface {
	Event()
	String() string
}

type EventConnectionError interface {
	ErrorEvent
	EventConnectionError()
}

type EventFlushError interface {
	ErrorEvent
	EventFlushError()
	State() EventFlushErrorState
}

type EventFlushErrorState string

const (
	FlushErrorTracerClosed   EventFlushErrorState = "flush failed, the tracer is closed."
	FlushErrorTracerDisabled EventFlushErrorState = "flush failed, the tracer is disabled."
	FlushErrorTransport      EventFlushErrorState = "flush failed, could not send report to Collector"
	FlushErrorReport         EventFlushErrorState = "flush failed, report contained errors"
	FlushErrorTranslate      EventFlushErrorState = "flush failed, could not translate report"
)

type EventHandler func(Event)

type EventMissingService interface {
	Event
	EventMissingService()
}

type EventStartError interface {
	ErrorEvent
	EventStartError()
}

type EventStatusReport interface {
	Event
	EventStatusReport()

	// StartTime is the earliest time a span was added to the report buffer.
	StartTime() time.Time

	// FinishTime is the latest time a span was added to the report buffer.
	FinishTime() time.Time

	// Duration is time between StartTime and FinishTime.
	Duration() time.Duration

	// SentSpans is the number of spans sent in the report buffer.
	SentSpans() int

	// DroppedSpans is the number of spans dropped that did not make it into
	// the report buffer.
	DroppedSpans() int

	// EncodingErrors is the number of encoding errors that occurred while
	// building the report buffer.
	EncodingErrors() int

	// FlushDuration is the time it took to send the report, including encoding,
	// buffer rotation, and network time.
	FlushDuration() time.Duration
}

type EventSystemMetricsMeasurementFailed interface {
	ErrorEvent
}

type EventTracerDisabled interface {
	Event
	EventTracerDisabled()
}

type EventUnsupportedTracer interface {
	ErrorEvent
	EventUnsupportedTracer()
	Tracer() opentracing.Tracer
}

type EventUnsupportedValue interface {
	ErrorEvent
	EventUnsupportedValue()
	Key() string
	Value() interface{}
}

type MetricEventStatusReport interface {
	Event
	MetricEventStatusReport()

	// StartTime is the earliest time a span was added to the report buffer.
	StartTime() time.Time

	// FinishTime is the latest time a span was added to the report buffer.
	FinishTime() time.Time

	// SentMetrics is the number of metrics sent in the report buffer.
	SentMetrics() int
}

type Options struct {
	// AccessToken is the unique API key for your LightStep project.  It is
	// available on your account page at https://app.lightstep.com/account
	AccessToken string `yaml:"access_token" usage:"access token for reporting to LightStep"`

	// Collector is the host, port, and plaintext option to use
	// for the collector.
	Collector Endpoint `yaml:"collector"`

	// Tags are arbitrary key-value pairs that apply to all spans generated by
	// this Tracer.
	Tags opentracing.Tags

	// LightStep is the host, port, and plaintext option to use
	// for the LightStep web API.
	LightStepAPI Endpoint `yaml:"lightstep_api"`

	// MaxBufferedSpans is the maximum number of spans that will be buffered
	// before sending them to a collector.
	MaxBufferedSpans int `yaml:"max_buffered_spans"`

	// MaxLogKeyLen is the maximum allowable size (in characters) of an
	// OpenTracing logging key. Longer keys are truncated.
	MaxLogKeyLen int `yaml:"max_log_key_len"`

	// MaxLogValueLen is the maximum allowable size (in characters) of an
	// OpenTracing logging value. Longer values are truncated. Only applies to
	// variable-length value types (strings, interface{}, etc).
	MaxLogValueLen int `yaml:"max_log_value_len"`

	// MaxLogsPerSpan limits the number of logs in a single span.
	MaxLogsPerSpan int `yaml:"max_logs_per_span"`

	// GRPCMaxCallSendMsgSizeBytes limits the size in bytes of grpc messages
	// sent by a client.
	GRPCMaxCallSendMsgSizeBytes int `yaml:"grpc_max_call_send_msg_size_bytes"`

	// ReportingPeriod is the maximum duration of time between sending spans
	// to a collector.  If zero, the default will be used.
	ReportingPeriod time.Duration `yaml:"reporting_period"`

	// MinReportingPeriod is the minimum duration of time between sending spans
	// to a collector.  If zero, the default will be used. It is strongly
	// recommended to use the default.
	MinReportingPeriod time.Duration `yaml:"min_reporting_period"`

	ReportTimeout time.Duration `yaml:"report_timeout"`

	// DropSpanLogs turns log events on all Spans into no-ops.
	DropSpanLogs bool `yaml:"drop_span_logs"`

	// DEPRECATED: The LightStep library prints the first error to stdout by default.
	// See the documentation on the SetGlobalEventHandler function for guidance on
	// how to integrate tracer diagnostics with your application's logging and
	// metrics systems.
	Verbose bool `yaml:"verbose"`

	// Force the use of a specific transport protocol. If multiple are set to true,
	// the following order is used to select for the first option: http, grpc.
	// If none are set to true, HTTP is defaulted to.
	UseHttp bool `yaml:"use_http"`
	UseGRPC bool `yaml:"usegrpc"`

	// Propagators allow inject/extract to use custom propagators for different formats. This
	// package includes a `B3Propagator` that supports B3 headers on text maps and http headers.
	// Defaults:
	//   opentracing.HTTPHeaders: LightStepPropagator
	//   opentracing.TextMap: LightStepPropagator,
	//   opentracing.Binary: LightStepPropagator
	Propagators map[opentracing.BuiltinFormat]Propagator `yaml:"-"`

	// CustomCollector allows customizing the Protobuf transport.
	// This is an advanced feature that avoids reconnect logic.
	CustomCollector Collector `yaml:"-" json:"-"`

	ReconnectPeriod time.Duration `yaml:"reconnect_period"`

	// DialOptions allows customizing the grpc dial options passed to the grpc.Dial(...) call.
	// This is an advanced feature added to allow for a custom balancer or middleware.
	// It can be safely ignored if you have no custom dialing requirements.
	// If UseGRPC is not set, these dial options are ignored.
	DialOptions []grpc.DialOption `yaml:"-" json:"-"`

	// A hook for receiving finished span events
	Recorder SpanRecorder `yaml:"-" json:"-"`

	// For testing purposes only
	ConnFactory ConnectorFactory `yaml:"-" json:"-"`

	// Enable LightStep Meta Event Logging
	MetaEventReportingEnabled bool `yaml:"meta_event_reporting_enabled" json:"meta_event_reporting_enabled"`

	SystemMetrics SystemMetricsOptions `yaml:"system_metrics"`
}

type Propagator interface {
	Inject(opentracing.SpanContext, interface{}) error
	Extract(interface{}) (opentracing.SpanContext, error)
}

type PropagatorStack struct {
	// contains filtered or unexported fields
}

type RawSpan struct {
	// Those recording the RawSpan should also record the contents of its
	// SpanContext.
	Context SpanContext

	// The SpanID of this SpanContext's first intra-trace reference (i.e.,
	// "parent"), or 0 if there is no parent.
	ParentSpanID uint64

	// The name of the "operation" this span is an instance of. (Called a "span
	// name" in some implementations)
	Operation string

	// We store <start, duration> rather than <start, end> so that only
	// one of the timestamps has global clock uncertainty issues.
	Start    time.Time
	Duration time.Duration

	// Essentially an extension mechanism. Can be used for many purposes,
	// not to be enumerated here.
	Tags opentracing.Tags

	// The span's "microlog".
	Logs []opentracing.LogRecord
}

type SetParentSpanID uint64

type SetSampled string

type SetSpanID uint64

type SetTraceID uint64

type SpanContext struct {
	// A probabilistically unique identifier for a [multi-span] trace.
	TraceID uint64

	// Most significant bits of a 128-bit TraceID
	TraceIDUpper uint64

	// A probabilistically unique identifier for a span.
	SpanID uint64

	// Propagates sampling decision
	Sampled string

	// The span's associated baggage.
	Baggage map[string]string // initialized on first use
}

type SpanRecorder interface {
	RecordSpan(RawSpan)
}

type SystemMetricsOptions struct {
	Disabled             bool          `yaml:"disabled"`
	Endpoint             Endpoint      `yaml:"endpoint"`
	MeasurementFrequency time.Duration `yaml:"measurement_frequency"`
	Timeout              time.Duration `yaml:"timeout"`
}

type Tracer interface {
	opentracing.Tracer

	// Close flushes and then terminates the LightStep collector
	Close(context.Context)
	// Flush sends all spans currently in the buffer to the LighStep collector
	Flush(context.Context)
	// Options gets the Options used in New() or NewWithOptions().
	Options() Options
	// Disable prevents the tracer from recording spans or flushing
	Disable()
}

type Tracerv0_14 interface {
	opentracing.Tracer

	// DEPRECATED: error is always nil. Equivalent to Tracer.Close(context.Background())
	Close() error
	// DEPRECATED: error is always nil. Equivalent to Tracer.Flush(context.Background())
	Flush() error
	// Options gets the Options used in New().
	Options() Options
	// Disable prevents the tracer from recording spans or flushing.
	Disable()
}