package exporter

import (
	"fmt"
	"time"

	"github.com/appscode/go-hetzner"
	"github.com/go-kit/kit/log"
	"github.com/go-kit/kit/log/level"
	"github.com/prometheus/client_golang/prometheus"
)

// TransactionCollector collects metrics about the SSH keys.
type TransactionCollector struct {
	client   *hetzner.Client
	logger   log.Logger
	failures *prometheus.CounterVec
	duration *prometheus.HistogramVec
	timeout  time.Duration

	Dummy *prometheus.Desc
}

// NewTransactionCollector returns a new TransactionCollector.
func NewTransactionCollector(logger log.Logger, client *hetzner.Client, failures *prometheus.CounterVec, duration *prometheus.HistogramVec, timeout time.Duration) *TransactionCollector {
	failures.WithLabelValues("transaction").Add(0)

	labels := []string{"id"}
	return &TransactionCollector{
		client:   client,
		logger:   logger,
		failures: failures,
		duration: duration,
		timeout:  timeout,

		Dummy: prometheus.NewDesc(
			"hetzner_transaction_dummy",
			"Dummy help",
			labels,
			nil,
		),
	}
}

// Describe sends the super-set of all possible descriptors of metrics collected by this Collector.
func (c *TransactionCollector) Describe(ch chan<- *prometheus.Desc) {
	ch <- c.Dummy
}

// Collect is called by the Prometheus registry when collecting metrics.
func (c *TransactionCollector) Collect(ch chan<- prometheus.Metric) {
	now := time.Now()
	transactions, _, err := c.client.WithTimeout(c.timeout).Ordering.ListTransactions()
	c.duration.WithLabelValues("transaction").Observe(time.Since(now).Seconds())

	if err != nil {
		level.Error(c.logger).Log(
			"msg", "Failed to fetch transactions",
			"err", err,
		)

		c.failures.WithLabelValues("transaction").Inc()
		return
	}

	level.Debug(c.logger).Log(
		"msg", "Fetched transactions",
		"count", len(transactions),
	)

	for _, transaction := range transactions {

		level.Debug(c.logger).Log(
			"record", fmt.Sprintf("%+v", transaction),
		)

		labels := []string{
			transaction.ID,
		}

		ch <- prometheus.MustNewConstMetric(
			c.Dummy,
			prometheus.GaugeValue,
			0.0,
			labels...,
		)
	}
}

package exporter

import (
	"fmt"
	"strconv"
	"time"

	"github.com/appscode/go-hetzner"
	"github.com/go-kit/kit/log"
	"github.com/go-kit/kit/log/level"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/dustin/go-humanize"
)

// ProductCollector collects metrics about the SSH keys.
type ProductCollector struct {
	client   *hetzner.Client
	logger   log.Logger
	failures *prometheus.CounterVec
	duration *prometheus.HistogramVec
	timeout  time.Duration

	Up *prometheus.Desc
	Traffic *prometheus.Desc
	SetupVat *prometheus.Desc
	Setup *prometheus.Desc
	PriceVat *prometheus.Desc
	Price *prometheus.Desc
}

// NewProductCollector returns a new ProductCollector.
func NewProductCollector(logger log.Logger, client *hetzner.Client, failures *prometheus.CounterVec, duration *prometheus.HistogramVec, timeout time.Duration) *ProductCollector {
	failures.WithLabelValues("product").Add(0)

	labels := []string{"id", "name"}
	return &ProductCollector{
		client:   client,
		logger:   logger,
		failures: failures,
		duration: duration,
		timeout:  timeout,

		Up: prometheus.NewDesc(
			"hetzner_product_up",
			"1 if the product is available",
			labels,
			nil,
		),
		Traffic: prometheus.NewDesc(
			"hetzner_product_traffic_bytes",
			"Show the inclusive traffic for this product",
			labels,
			nil,
		),
		SetupVat: prometheus.NewDesc(
			"hetzner_product_setup_vat_euro",
			"Setup VAT for the product in €",
			labels,
			nil,
		),
		Setup: prometheus.NewDesc(
			"hetzner_product_setup_euro",
			"Setup fee for the product in €",
			labels,
			nil,
		),
		PriceVat: prometheus.NewDesc(
			"hetzner_product_price_vat_euro",
			"Monthly VAT for the product in €",
			labels,
			nil,
		),
		Price: prometheus.NewDesc(
			"hetzner_product_price_euro",
			"Monthly fee for the product in €",
			labels,
			nil,
		),
	}
}

// Describe sends the super-set of all possible descriptors of metrics collected by this Collector.
func (c *ProductCollector) Describe(ch chan<- *prometheus.Desc) {
	ch <- c.Up
	ch <- c.Traffic
	ch <- c.SetupVat
	ch <- c.Setup
	ch <- c.PriceVat
	ch <- c.Price
}

// Collect is called by the Prometheus registry when collecting metrics.
func (c *ProductCollector) Collect(ch chan<- prometheus.Metric) {
	now := time.Now()
	products, _, err := c.client.WithTimeout(c.timeout).Ordering.ListProducts()
	c.duration.WithLabelValues("product").Observe(time.Since(now).Seconds())

	if err != nil {
		level.Error(c.logger).Log(
			"msg", "Failed to fetch products",
			"err", err,
		)

		c.failures.WithLabelValues("product").Inc()
		return
	}

	level.Debug(c.logger).Log(
		"msg", "Fetched products",
		"count", len(products),
	)

	for _, product := range products {
		var (
			traffic float64
			setup float64
			setupVat float64
			price float64
			priceVat float64
		)

		labels := []string{
			product.ID,
			product.Name,
		}

		ch <- prometheus.MustNewConstMetric(
			c.Up,
			prometheus.GaugeValue,
			1.0,
			labels...,
		)

		if num, err := humanize.ParseBytes(product.Traffic); err == nil {
			traffic = float64(num)
		}

		ch <- prometheus.MustNewConstMetric(
			c.Traffic,
			prometheus.GaugeValue,
			traffic,
			labels...,
		)

		if num, err := strconv.ParseFloat(product.PriceSetup, 64); err == nil {
			setup = num
		}

		ch <- prometheus.MustNewConstMetric(
			c.Setup,
			prometheus.GaugeValue,
			setup,
			labels...,
		)

		if num, err := strconv.ParseFloat(product.PriceSetupVat, 64); err == nil {
			setupVat = num
		}

		ch <- prometheus.MustNewConstMetric(
			c.SetupVat,
			prometheus.GaugeValue,
			setupVat,
			labels...,
		)

		if num, err := strconv.ParseFloat(product.Price, 64); err == nil {
			price = num
		}

		ch <- prometheus.MustNewConstMetric(
			c.Price,
			prometheus.GaugeValue,
			price,
			labels...,
		)

		if num, err := strconv.ParseFloat(product.PriceVat, 64); err == nil {
			priceVat = num
		}

		ch <- prometheus.MustNewConstMetric(
			c.PriceVat,
			prometheus.GaugeValue,
			priceVat,
			labels...,
		)
	}
}