package metrics

import (
	"sync"
	"sync/atomic"

	"github.com/prometheus/client_golang/prometheus"
)

type (
	// httpAPIStats holds statistics information about
	// the API given in the requests.
	httpAPIStats struct {
		apiStats map[string]int
		sync.RWMutex
	}

	// httpStats holds statistics information about
	// HTTP requests made by all clients.
	httpStats struct {
		currentS3Requests httpAPIStats
		totalS3Requests   httpAPIStats
		totalS3Errors     httpAPIStats

		totalInputBytes  uint64
		totalOutputBytes uint64

		currentS3RequestsDesc *prometheus.Desc
		totalS3RequestsDesc   *prometheus.Desc
		totalS3ErrorsDesc     *prometheus.Desc
		txBytesTotalDesc      *prometheus.Desc
		rxBytesTotalDesc      *prometheus.Desc
	}

	APIStatMetrics struct {
		stats                *httpStats
		httpRequestsDuration *prometheus.HistogramVec
	}
)

const (
	statisticSubsystem = "statistic"
)

const (
	requestsSecondsMetric = "requests_seconds"
	requestsCurrentMetric = "requests_current"
	requestsTotalMetric   = "requests_total"
	errorsTotalMetric     = "errors_total"
	txBytesTotalMetric    = "tx_bytes_total"
	rxBytesTotalMetric    = "rx_bytes_total"
)

func newAPIStatMetrics() *APIStatMetrics {
	histogramDesc := appMetricsDesc[statisticSubsystem][requestsSecondsMetric]

	return &APIStatMetrics{
		stats: newHTTPStats(),
		httpRequestsDuration: prometheus.NewHistogramVec(
			prometheus.HistogramOpts{
				Namespace:   histogramDesc.Namespace,
				Subsystem:   histogramDesc.Subsystem,
				Name:        histogramDesc.Name,
				Help:        histogramDesc.Name,
				ConstLabels: histogramDesc.ConstLabelsMap(),
				Buckets:     []float64{.05, .1, .25, .5, 1, 2.5, 5, 10},
			},
			histogramDesc.VariableLabels,
		),
	}
}

func (a *APIStatMetrics) register() {
	if a == nil {
		return
	}
	prometheus.MustRegister(a.stats)
	prometheus.MustRegister(a.httpRequestsDuration)
}

func (a *APIStatMetrics) unregister() {
	if a == nil {
		return
	}
	prometheus.Unregister(a.stats)
	prometheus.Unregister(a.httpRequestsDuration)
}

func (a *APIStatMetrics) CurrentS3RequestsInc(api string) {
	if a == nil {
		return
	}

	a.stats.currentS3Requests.Inc(api)
}

func (a *APIStatMetrics) CurrentS3RequestsDec(api string) {
	if a == nil {
		return
	}
	a.stats.currentS3Requests.Dec(api)
}

func (a *APIStatMetrics) TotalS3RequestsInc(api string) {
	if a == nil {
		return
	}
	a.stats.totalS3Requests.Inc(api)
}

func (a *APIStatMetrics) TotalS3ErrorsInc(api string) {
	if a == nil {
		return
	}
	a.stats.totalS3Errors.Inc(api)
}

func (a *APIStatMetrics) TotalInputBytesAdd(val uint64) {
	if a == nil {
		return
	}
	atomic.AddUint64(&a.stats.totalInputBytes, val)
}

func (a *APIStatMetrics) TotalOutputBytesAdd(val uint64) {
	if a == nil {
		return
	}
	atomic.AddUint64(&a.stats.totalOutputBytes, val)
}

func (a *APIStatMetrics) RequestDurationsUpdate(api string, durationSecs float64) {
	if a == nil {
		return
	}
	a.httpRequestsDuration.With(prometheus.Labels{"api": api}).Observe(durationSecs)
}

func (a *APIStatMetrics) Describe(ch chan<- *prometheus.Desc) {
	if a == nil {
		return
	}
	a.stats.Describe(ch)
	a.httpRequestsDuration.Describe(ch)
}

func (a *APIStatMetrics) Collect(ch chan<- prometheus.Metric) {
	if a == nil {
		return
	}
	a.stats.Collect(ch)
	a.httpRequestsDuration.Collect(ch)
}

func newHTTPStats() *httpStats {
	return &httpStats{
		currentS3RequestsDesc: newDesc(appMetricsDesc[statisticSubsystem][requestsCurrentMetric]),
		totalS3RequestsDesc:   newDesc(appMetricsDesc[statisticSubsystem][requestsTotalMetric]),
		totalS3ErrorsDesc:     newDesc(appMetricsDesc[statisticSubsystem][errorsTotalMetric]),
		txBytesTotalDesc:      newDesc(appMetricsDesc[statisticSubsystem][txBytesTotalMetric]),
		rxBytesTotalDesc:      newDesc(appMetricsDesc[statisticSubsystem][rxBytesTotalMetric]),
	}
}

func (s *httpStats) Describe(desc chan<- *prometheus.Desc) {
	desc <- s.currentS3RequestsDesc
	desc <- s.totalS3RequestsDesc
	desc <- s.totalS3ErrorsDesc
	desc <- s.txBytesTotalDesc
	desc <- s.rxBytesTotalDesc
}

func (s *httpStats) Collect(ch chan<- prometheus.Metric) {
	for api, value := range s.currentS3Requests.Load() {
		ch <- prometheus.MustNewConstMetric(s.currentS3RequestsDesc, prometheus.CounterValue, float64(value), api)
	}

	for api, value := range s.totalS3Requests.Load() {
		ch <- prometheus.MustNewConstMetric(s.totalS3RequestsDesc, prometheus.CounterValue, float64(value), api)
	}

	for api, value := range s.totalS3Errors.Load() {
		ch <- prometheus.MustNewConstMetric(s.totalS3ErrorsDesc, prometheus.CounterValue, float64(value), api)
	}

	// Network Sent/Received Bytes (Outbound)
	ch <- prometheus.MustNewConstMetric(s.txBytesTotalDesc, prometheus.CounterValue, float64(s.getInputBytes()))
	ch <- prometheus.MustNewConstMetric(s.rxBytesTotalDesc, prometheus.CounterValue, float64(s.getOutputBytes()))
}

// Inc increments the api stats counter.
func (s *httpAPIStats) Inc(api string) {
	if s == nil {
		return
	}
	s.Lock()
	defer s.Unlock()
	if s.apiStats == nil {
		s.apiStats = make(map[string]int)
	}
	s.apiStats[api]++
}

// Dec increments the api stats counter.
func (s *httpAPIStats) Dec(api string) {
	if s == nil {
		return
	}
	s.Lock()
	defer s.Unlock()
	if val, ok := s.apiStats[api]; ok && val > 0 {
		s.apiStats[api]--
	}
}

// Load returns the recorded stats.
func (s *httpAPIStats) Load() map[string]int {
	s.Lock()
	defer s.Unlock()
	var apiStats = make(map[string]int, len(s.apiStats))
	for k, v := range s.apiStats {
		apiStats[k] = v
	}
	return apiStats
}

func (s *httpStats) getInputBytes() uint64 {
	return atomic.LoadUint64(&s.totalInputBytes)
}

func (s *httpStats) getOutputBytes() uint64 {
	return atomic.LoadUint64(&s.totalOutputBytes)
}