package metrics

import (
	"fmt"
	"sort"
	"strings"
	"time"

	log "github.com/hotstar/persona-commons/logging"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/push"
	"go.uber.org/zap"
)

type PrometheusPushGatewayClient struct {
	pushGateWayClient *push.Pusher
	isInitialised     bool
	separator         string
	counterMap        map[string]prometheus.Counter
	gaugeMap          map[string]prometheus.Gauge
	histogramMap      map[string]prometheus.Histogram
}

func NewPrometheusPushGatewayClient(endpoint, jobName string) *PrometheusPushGatewayClient {
	pushGateWayClient := push.New(endpoint, jobName)

	ticker := time.NewTicker(10 * time.Second)
	go func() {
		for {
			select {
			case <-ticker.C:
				if err := pushGateWayClient.Add(); err != nil {
					log.Error("Could not push to push gateway ", zap.Error(err))
				}
			}
		}
	}()

	return &PrometheusPushGatewayClient{
		pushGateWayClient: pushGateWayClient,
		isInitialised:     true,
		separator:         "_",
		counterMap:        make(map[string]prometheus.Counter),
		gaugeMap:          make(map[string]prometheus.Gauge),
		histogramMap:      make(map[string]prometheus.Histogram),
	}
}

func (c *PrometheusPushGatewayClient) IsInitialised() bool {
	return c.isInitialised
}

func (c *PrometheusPushGatewayClient) Increment(key string) {
	var incrementCollector prometheus.Counter
	FQName := c.formatKeys(key)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.counterMap[FQName]; ok {
		incrementCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		incrementCollector = prometheus.NewCounter(prometheus.CounterOpts{
			Name: FQName,
		})
		c.counterMap[FQName] = incrementCollector
		c.pushGateWayClient.Collector(incrementCollector)
	}
	incrementCollector.Inc()
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Counter)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) IncrementWithTags(key string, tags []string) {
	var incrementCollector prometheus.Counter
	tagMap := c.formatTags(tags)
	formattedKeys := c.formatKeys(key)
	FQName := formattedKeys + generateLabels(tagMap)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.counterMap[FQName]; ok {
		incrementCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		incrementCollector = prometheus.NewCounter(prometheus.CounterOpts{
			Name:        formattedKeys,
			ConstLabels: tagMap,
		})
		c.counterMap[FQName] = incrementCollector
		c.pushGateWayClient.Collector(incrementCollector)
	}
	incrementCollector.Inc()
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Counter)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) Timing(key string, since time.Time) {
	var timeCollector prometheus.Histogram
	FQName := c.formatKeys(key)
	duration := float64(time.Since(since))
	buckets := prometheus.ExponentialBuckets(float64(exponentialDurationBucketStart), exponentialBucketFactor, exponentialBucketCount)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.histogramMap[FQName]; ok {
		timeCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		timeCollector = prometheus.NewHistogram(prometheus.HistogramOpts{
			Name:    FQName,
			Buckets: buckets,
		})
		c.histogramMap[FQName] = timeCollector
		c.pushGateWayClient.Collector(timeCollector)
	}
	timeCollector.Observe(duration)
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Histogram)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) TimingWithTags(key string, since time.Time, tags []string) {
	var timeCollector prometheus.Histogram
	tagMap := c.formatTags(tags)
	formattedKeys := c.formatKeys(key)
	FQName := formattedKeys + generateLabels(tagMap)
	duration := float64(time.Since(since))
	buckets := prometheus.ExponentialBuckets(float64(exponentialDurationBucketStart), exponentialBucketFactor, exponentialBucketCount)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.histogramMap[FQName]; ok {
		timeCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		timeCollector = prometheus.NewHistogram(prometheus.HistogramOpts{
			Name:        formattedKeys,
			Buckets:     buckets,
			ConstLabels: tagMap,
		})
		c.histogramMap[FQName] = timeCollector
		c.pushGateWayClient.Collector(timeCollector)
	}
	timeCollector.Observe(duration)
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Histogram)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) Gauge(key string, value float64) {
	var gaugeCollector prometheus.Gauge
	FQName := c.formatKeys(key)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.gaugeMap[FQName]; ok {
		gaugeCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		gaugeCollector = prometheus.NewGauge(prometheus.GaugeOpts{
			Name: FQName,
		})
		c.gaugeMap[FQName] = gaugeCollector
		c.pushGateWayClient.Collector(gaugeCollector)
	}
	gaugeCollector.Set(value)
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Gauge)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) GaugeWithTags(key string, value float64, tags []string) {
	var gaugeCollector prometheus.Gauge
	tagMap := c.formatTags(tags)
	formattedKeys := c.formatKeys(key)
	FQName := formattedKeys + generateLabels(tagMap)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.gaugeMap[FQName]; ok {
		gaugeCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		gaugeCollector = prometheus.NewGauge(prometheus.GaugeOpts{
			Name:        formattedKeys,
			ConstLabels: tagMap,
		})
		c.gaugeMap[FQName] = gaugeCollector
		c.pushGateWayClient.Collector(gaugeCollector)
	}
	gaugeCollector.Set(value)
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Gauge)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) Count(key string, value int64) {
	var countCollector prometheus.Counter
	FQName := c.formatKeys(key)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.counterMap[FQName]; ok {
		countCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		countCollector = prometheus.NewCounter(prometheus.CounterOpts{
			Name: FQName,
		})
		c.counterMap[FQName] = countCollector
		c.pushGateWayClient.Collector(countCollector)
	}
	countCollector.Add(float64(value))
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Counter)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

func (c *PrometheusPushGatewayClient) CountWithTags(key string, value int64, tags []string) {
	var countCollector prometheus.Counter
	tagMap := c.formatTags(tags)
	formattedKeys := c.formatKeys(key)
	FQName := formattedKeys + generateLabels(tagMap)
	log.Warn("FQName: ", zap.Any("FQName: ", FQName))
	if collector, ok := c.counterMap[FQName]; ok {
		countCollector = collector
		log.Warn("Found old collector", zap.Any("Collector: ", collector.Desc().String()))
	} else {
		countCollector = prometheus.NewCounter(prometheus.CounterOpts{
			Name:        formattedKeys,
			ConstLabels: tagMap,
		})
		c.counterMap[FQName] = countCollector
		c.pushGateWayClient.Collector(countCollector)
	}
	countCollector.Add(float64(value))
	//if err := c.pushGateWayClient.Add(); err != nil {
	//	log.Error("Could not push to push gateway ", zap.Error(err))
	//	if err, ok := err.(prometheus.AlreadyRegisteredError); ok {
	//		oldCollector := err.ExistingCollector.(prometheus.Counter)
	//		log.Error(oldCollector.Desc().String())
	//	}
	//}
}

// ShutDownClient No shutdown function present.
func (c *PrometheusPushGatewayClient) ShutDownClient() {
}

func (c *PrometheusPushGatewayClient) formatKeys(key string) string {
	s := strings.Replace(key, ".", c.separator, -1)
	return strings.Replace(s, "-", c.separator, -1)
}

func (c *PrometheusPushGatewayClient) formatTags(tags []string) map[string]string {
	tagMap := make(map[string]string)
	for _, v := range tags {
		tagSplit := strings.Split(v, ":")
		tagKey := c.formatKeys(tagSplit[0])
		tagValue := tagSplit[1]
		if tagValue == "" {
			tagValue = "nil"
		}
		tagMap[tagKey] = tagValue
	}
	return tagMap
}

type LabelPair struct {
	name  string
	value string
}

func generateLabels(tagMap map[string]string) string {
	if len(tagMap) == 0 {
		return ""
	}
	labelPairSlice := make([]LabelPair, 0)
	for tagKey, tagValue := range tagMap {
		labelPairSlice = append(labelPairSlice, LabelPair{name: tagKey, value: tagValue})
	}
	sort.Slice(labelPairSlice, func(i, j int) bool {
		return labelPairSlice[i].name < labelPairSlice[j].name
	})
	var sb strings.Builder
	sb.WriteRune('{')
	for _, label := range labelPairSlice {
		sb.WriteString(fmt.Sprintf(`%v="%v"`, label.name, label.value))
		sb.WriteRune(',')
	}
	str := sb.String()
	str = str[:len(str)-1]
	str += "}"
	return str
}