package victoriametrics

import (
	"io"
	"time"

	"github.com/VictoriaMetrics/metrics"
	"go.unistack.org/micro/v4/meter"
	xpool "go.unistack.org/micro/v4/util/xpool"
)

type victoriametricsMeter struct {
	set              *metrics.Set
	opts             meter.Options
	prometheusCompat bool
	builderPool      *xpool.StringsPool
}

func NewMeter(opts ...meter.Option) meter.Meter {
	m := &victoriametricsMeter{
		set:         metrics.NewSet(),
		opts:        meter.NewOptions(opts...),
		builderPool: xpool.NewStringsPool(256),
	}
	if v, ok := m.opts.Context.Value(prometheusCompatKey{}).(bool); ok && v {
		m.prometheusCompat = v
	}
	return m
}

func (r *victoriametricsMeter) Name() string {
	return r.opts.Name
}

func (r *victoriametricsMeter) Unregister(name string, labels ...string) bool {
	return r.set.UnregisterMetric(r.buildName(name, labels...))
}

func (r *victoriametricsMeter) Clone(opts ...meter.Option) meter.Meter {
	options := r.opts
	for _, o := range opts {
		o(&options)
	}
	m := &victoriametricsMeter{set: r.set, opts: options}
	if v, ok := m.opts.Context.Value(prometheusCompatKey{}).(bool); ok && v {
		m.prometheusCompat = v
	}
	return m
}

func (r *victoriametricsMeter) buildName(name string, labels ...string) string {
	nl := len(r.opts.Labels) + len(labels)
	if nl == 0 {
		return name
	}

	b := r.builderPool.Get()
	defer r.builderPool.Put(b)

	b.WriteString(name)
	b.WriteByte('{')

	for i := 0; i < len(r.opts.Labels); i += 2 {
		if i > 0 {
			b.WriteByte(',')
		}
		b.WriteString(r.opts.Labels[i])
		b.WriteString(`="`)
		b.WriteString(r.opts.Labels[i+1])
		b.WriteByte('"')
	}

	for i := 0; i < len(labels); i += 2 {
		if i > 0 || len(r.opts.Labels) > 0 {
			b.WriteByte(',')
		}
		b.WriteString(labels[i])
		b.WriteString(`="`)
		b.WriteString(labels[i+1])
		b.WriteByte('"')
	}

	b.WriteByte('}')
	return b.String()
}

func (r *victoriametricsMeter) Counter(name string, labels ...string) meter.Counter {
	return r.set.GetOrCreateCounter(r.buildName(name, labels...))
}

func (r *victoriametricsMeter) FloatCounter(name string, labels ...string) meter.FloatCounter {
	return r.set.GetOrCreateFloatCounter(r.buildName(name, labels...))
}

func (r *victoriametricsMeter) Gauge(name string, f func() float64, labels ...string) meter.Gauge {
	return r.set.GetOrCreateGauge(r.buildName(name, labels...), f)
}

func (r *victoriametricsMeter) Histogram(name string, labels ...string) meter.Histogram {
	if r.prometheusCompat {
		return r.set.GetOrCreatePrometheusHistogramExt(r.buildName(name, labels...), r.opts.Quantiles)
	}
	return r.set.GetOrCreateHistogram(r.buildName(name, labels...))
}

func (r *victoriametricsMeter) HistogramExt(name string, quantiles []float64, labels ...string) meter.Histogram {
	if r.prometheusCompat {
		return r.set.GetOrCreatePrometheusHistogramExt(r.buildName(name, labels...), quantiles)
	}
	return r.set.GetOrCreateHistogram(r.buildName(name, labels...))
}

func (r *victoriametricsMeter) Summary(name string, labels ...string) meter.Summary {
	return r.set.GetOrCreateSummary(r.buildName(name, labels...))
}

func (r *victoriametricsMeter) SummaryExt(name string, window time.Duration, quantiles []float64, labels ...string) meter.Summary {
	return r.set.GetOrCreateSummaryExt(r.buildName(name, labels...), window, quantiles)
}

func (r *victoriametricsMeter) Set(opts ...meter.Option) meter.Meter {
	m := &victoriametricsMeter{opts: r.opts, prometheusCompat: r.prometheusCompat}
	for _, o := range opts {
		o(&m.opts)
	}
	m.set = metrics.NewSet()
	return m
}

func (r *victoriametricsMeter) Init(opts ...meter.Option) error {
	for _, o := range opts {
		o(&r.opts)
	}
	if v, ok := r.opts.Context.Value(prometheusCompatKey{}).(bool); ok && v {
		r.prometheusCompat = v
	}
	if r.opts.Quantiles == nil {
		r.opts.Quantiles = meter.DefaultQuantiles
	}
	return nil
}

func (r *victoriametricsMeter) Write(w io.Writer, opts ...meter.Option) error {
	options := r.opts
	for _, o := range opts {
		o(&options)
	}

	r.set.WritePrometheus(w)
	if options.WriteProcessMetrics {
		metrics.WriteProcessMetrics(w)
	}
	if options.WriteFDMetrics {
		metrics.WriteFDMetrics(w)
	}
	return nil
}

func (r *victoriametricsMeter) Options() meter.Options {
	return r.opts
}

func (r *victoriametricsMeter) String() string {
	return "victoriametrics"
}

type prometheusCompatKey struct{}

func PrometheusCompat(b bool) meter.Option {
	return meter.SetOption(prometheusCompatKey{}, b)
}