package downloader

import (
	
	

	
	
	
	

	

	
)

// meterName is the name of the meter of downloader metrics.
const meterName = "github.com/gotd/td/telegram/downloader"

// ErrFileNotFound means that a file reference can't be refreshed because the
// object that contains the file (message, story, photo) or the file itself is
// not found anymore.
//
// RefreshFunc should return an error that wraps it in this case, see package
// fileref.
var ErrFileNotFound = errors.New("file not found")

// Request kinds.
const (
	kindMaster = "master"
	kindCDN    = "cdn"
	kindWeb    = "web"
)

var requestKinds = [...]string{kindMaster, kindCDN, kindWeb}

// Request results.
const (
	resultOK        = "ok"
	resultFloodWait = "flood_wait"
	resultTimeout   = "timeout"
	resultCanceled  = "canceled"
	resultError     = "error"
)

var requestResults = [...]string{resultOK, resultFloodWait, resultTimeout, resultCanceled, resultError}

// File reference refresh results.
const (
	refreshOK       = "ok"
	refreshNotFound = "not_found"
	refreshError    = "error"
	refreshLimit    = "limit"
)

// Builder.Verify results.
const (
	verifyComplete = "complete"
	verifyPartial  = "partial"
	verifyNone     = "none"
	verifyError    = "error"
)

// observer reports downloader metrics and debug logs.
//
// A nil observer reports nothing: downloads without metrics and logger pay
// nothing for it.
// durationBuckets are histogram buckets in seconds, the same as of the
// telegram client: the SDK defaults are meant for milliseconds.
var durationBuckets = metric.WithExplicitBucketBoundaries( // nolint:gochecknoglobals
	0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60,
)

type observer struct {
	log log.Helper

	requests         metric.Int64Counter
	bytes            metric.Int64Counter
	duration         metric.Float64Histogram
	downloads        metric.Int64Counter
	resumes          metric.Int64Counter
	cdnRedirects     metric.Int64Counter
	cdnReuploads     metric.Int64Counter
	hashMismatches   metric.Int64Counter
	refreshes        metric.Int64Counter
	backoffs         metric.Int64Counter
	verify           metric.Int64Counter
	retries          metric.Int64Counter
	retriesExhausted metric.Int64Counter

	// requestAttrs[kind][result] and kindAttrs[kind] are pre-built, so
	// reporting a request does not allocate.
	requestAttrs [len(requestKinds)][len(requestResults)]metric.MeasurementOption
	kindAttrs    [len(requestKinds)]metric.MeasurementOption
}

func ( ...attribute.KeyValue) metric.MeasurementOption {
	return metric.WithAttributeSet(attribute.NewSet(...))
}

func ( metric.MeterProvider,  log.Logger) *observer {
	if  == nil {
		 = noop.NewMeterProvider()
	}
	 := .Meter(meterName)
	 := &observer{log: log.For()}

	// Instrument creation errors must not fail downloads: fall back to noop
	// instruments.
	 := noop.Meter{}
	 := func(, ,  string) metric.Int64Counter {
		,  := .Int64Counter(, metric.WithUnit(), metric.WithDescription())
		if  != nil {
			, _ = .Int64Counter()
		}
		return 
	}
	.requests = ("gotd.downloader.requests", "{request}",
		"Part requests by kind (master, cdn, web) and result")
	.bytes = ("gotd.downloader.bytes", "By", "Downloaded bytes by kind")
	.downloads = ("gotd.downloader.downloads", "{download}", "Finished downloads by result")
	.resumes = ("gotd.downloader.resumes", "{download}", "Downloads resumed from an offset")
	.cdnRedirects = ("gotd.downloader.cdn.redirects", "{redirect}", "Redirects to CDN DC")
	.cdnReuploads = ("gotd.downloader.cdn.reuploads", "{request}", "CDN file reupload requests")
	.hashMismatches = ("gotd.downloader.hash.mismatches", "{part}",
		"Parts that failed hash verification by kind (cdn, verify)")
	.refreshes = ("gotd.downloader.file_reference.refreshes", "{refresh}",
		"File reference refreshes by result (ok, not_found, error, limit)")
	.backoffs = ("gotd.downloader.scheduler.backoffs", "{backoff}",
		"Flood waits and timeouts reported to Scheduler by reason")
	.verify = ("gotd.downloader.verify", "{call}",
		"Builder.Verify calls by result (complete, partial, none, error)")
	.retries = ("gotd.downloader.retries", "{retry}", "Retried transient errors by operation")
	.retriesExhausted = ("gotd.downloader.retries.exhausted", "{request}",
		"Requests that failed after the retry limit by operation")

	,  := .Float64Histogram("gotd.downloader.request.duration",
		metric.WithUnit("s"),
		metric.WithDescription("Part request duration by kind"),
		durationBuckets,
	)
	if  != nil {
		, _ = .Float64Histogram("gotd.downloader.request.duration")
	}
	.duration = 

	for ,  := range requestKinds {
		.kindAttrs[] = attrOpt(attribute.String("kind", ))
		for ,  := range requestResults {
			.requestAttrs[][] = attrOpt(
				attribute.String("kind", ),
				attribute.String("result", ),
			)
		}
	}
	return 
}

type observerKey struct{}

// with returns context carrying o, so that schemas can report events.
func ( *observer) ( context.Context) context.Context {
	if  == nil {
		return 
	}
	return context.WithValue(, observerKey{}, )
}

// observerFrom returns observer of the download, nil if not set.
func ( context.Context) *observer {
	,  := .Value(observerKey{}).(*observer)
	return 
}

func ( string) int {
	for ,  := range requestKinds {
		if  ==  {
			return 
		}
	}
	return 0
}

func ( context.Context,  error) int {
	switch {
	case  == nil:
		return 0
	case .Err() != nil:
		return 3
	}
	if ,  := tgerr.AsFloodWait();  {
		return 1
	}
	if isRetryableTimeout(, ) {
		return 2
	}
	return 4
}

// request reports a part request.
func ( *observer) ( context.Context,  string,  time.Time,  int,  error) {
	if  == nil {
		return
	}
	 := kindIndex()
	.requests.Add(, 1, .requestAttrs[][requestResult(, )])
	.duration.Record(, time.Since().Seconds(), .kindAttrs[])
	if  > 0 {
		.bytes.Add(, int64(), .kindAttrs[])
	}
}

// download reports a finished download.
func ( *observer) ( context.Context,  error) {
	if  == nil {
		return
	}
	 := resultOK
	if  != nil {
		 = resultError
		if .Err() != nil {
			 = resultCanceled
		}
	}
	.downloads.Add(, 1, attrOpt(attribute.String("result", )))
	if  != nil {
		.log.Debug(, "Download failed", log.Error())
	}
}

func ( *observer) ( context.Context,  int64) {
	if  == nil {
		return
	}
	.resumes.Add(, 1)
	.log.Debug(, "Resume download", log.Int64("offset", ))
}

func ( *observer) ( context.Context,  int) {
	if  == nil {
		return
	}
	.cdnRedirects.Add(, 1)
	.log.Debug(, "Redirected to CDN", log.Int("cdn_dc", ))
}

func ( *observer) ( context.Context,  int) {
	if  == nil {
		return
	}
	.cdnReuploads.Add(, 1)
	.log.Debug(, "CDN file reupload", log.Int("cdn_dc", ))
}

func ( *observer) ( context.Context,  string,  int64) {
	if  == nil {
		return
	}
	.hashMismatches.Add(, 1, attrOpt(attribute.String("kind", )))
	.log.Warn(, "Hash mismatch", log.String("kind", ), log.Int64("offset", ))
}

func ( *observer) ( context.Context,  string,  error) {
	if  == nil {
		return
	}
	.refreshes.Add(, 1, attrOpt(attribute.String("result", )))
	if  == refreshOK {
		.log.Debug(, "File reference refreshed")
		return
	}
	.log.Warn(, "File reference refresh failed", log.String("result", ), log.Error())
}

func ( *observer) ( context.Context,  error) {
	if  == nil {
		return
	}
	 := resultTimeout
	if ,  := tgerr.AsFloodWait();  {
		 = resultFloodWait
	}
	.backoffs.Add(, 1, attrOpt(attribute.String("reason", )))
	.log.Debug(, "Scheduler backoff", log.String("reason", ))
}

func ( *observer) ( context.Context, ,  int64,  error) {
	if  == nil {
		return
	}
	 := verifyPartial
	switch {
	case  != nil:
		 = verifyError
	case  >= :
		 = verifyComplete
	case  == 0:
		 = verifyNone
	}
	.verify.Add(, 1, attrOpt(attribute.String("result", )))
	.log.Debug(, "Verified local file",
		log.String("result", ),
		log.Int64("verified", ),
		log.Int64("size", ),
	)
}

func ( *observer) ( RetryEvent) {
	if  == nil {
		return
	}
	 := context.Background()
	.retries.Add(, 1, attrOpt(attribute.String("operation", .Operation)))
	.log.Debug(, "Retry",
		log.String("operation", .Operation),
		log.Int("attempt", .Attempt),
		log.Error(.Err),
	)
}

func ( *observer) ( context.Context,  string,  error) {
	if  == nil {
		return
	}
	.retriesExhausted.Add(, 1, attrOpt(attribute.String("operation", )))
	.log.Warn(, "Retry limit reached", log.String("operation", ), log.Error())
}

// wrapRetry returns RetryHandler that reports retries before calling h.
func ( *observer) ( RetryHandler) RetryHandler {
	if  == nil {
		return 
	}
	return func( RetryEvent) {
		.retry()
		if  != nil {
			()
		}
	}
}

// WithMeterProvider sets meter provider for downloader metrics. Metrics are
// not collected by default.
func ( *Downloader) ( metric.MeterProvider) *Downloader {
	.meterProvider = 
	.obs = newObserver(.meterProvider, .logger)
	return 
}

// WithLogger sets logger for downloader debug logs. No logs by default.
func ( *Downloader) ( log.Logger) *Downloader {
	.logger = 
	.obs = newObserver(.meterProvider, .logger)
	return 
}

// Instrument registers observable instruments of Scheduler state on m:
// gotd.downloader.scheduler.window, .in_flight and .waiting gauges and the
// .decreases counter, with given attributes (e.g. DC).
//
// Unregister the returned registration when the Scheduler is not used
// anymore.
func ( *Scheduler) ( metric.Meter,  ...attribute.KeyValue) (metric.Registration, error) {
	,  := .Int64ObservableGauge("gotd.downloader.scheduler.window",
		metric.WithUnit("{request}"),
		metric.WithDescription("Scheduler limit of in-flight part requests"),
	)
	if  != nil {
		return nil, errors.Wrap(, "window")
	}
	,  := .Int64ObservableGauge("gotd.downloader.scheduler.in_flight",
		metric.WithUnit("{request}"),
		metric.WithDescription("Scheduler in-flight part requests"),
	)
	if  != nil {
		return nil, errors.Wrap(, "in flight")
	}
	,  := .Int64ObservableGauge("gotd.downloader.scheduler.waiting",
		metric.WithUnit("{worker}"),
		metric.WithDescription("Workers waiting for a Scheduler slot"),
	)
	if  != nil {
		return nil, errors.Wrap(, "waiting")
	}
	,  := .Int64ObservableCounter("gotd.downloader.scheduler.decreases",
		metric.WithUnit("{decrease}"),
		metric.WithDescription("Scheduler window decreases"),
	)
	if  != nil {
		return nil, errors.Wrap(, "decreases")
	}

	 := attrOpt(...)
	,  := .RegisterCallback(func( context.Context,  metric.Observer) error {
		 := .Snapshot()
		.ObserveInt64(, int64(.Window), )
		.ObserveInt64(, int64(.InFlight), )
		.ObserveInt64(, int64(.Waiting), )
		.ObserveInt64(, .Decreases, )
		return nil
	}, , , , )
	if  != nil {
		return nil, errors.Wrap(, "register callback")
	}
	return , nil
}