package plugin

import (
	"context"
	"fmt"
	"math"
	"time"

	"github.com/evcc-io/evcc/util"
	"github.com/evcc-io/evcc/util/request"
	"github.com/evcc-io/evcc/util/transport"
	"github.com/prometheus/client_golang/api"
	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
	"github.com/prometheus/common/model"
)

// Prometheus provider
type Prometheus struct {
	log     *util.Logger
	api     v1.API
	query   string
	timeout time.Duration
}

func init() {
	registry.Add("prometheus", NewPrometheusFromConfig)
}

func NewPrometheusFromConfig(other map[string]interface{}) (Plugin, error) {
	cc := struct {
		Uri, Query string
		Timeout    time.Duration
	}{
		Timeout: request.Timeout,
	}

	if err := util.DecodeOther(other, &cc); err != nil {
		return nil, err
	}

	log := util.NewLogger("prometheus")

	config := api.Config{
		Address:      cc.Uri,
		RoundTripper: transport.Default(),
	}

	client, err := api.NewClient(config)
	if err != nil {
		return nil, err
	}

	p := NewPrometheus(log, client, cc.Query, cc.Timeout)

	return p, nil
}

func NewPrometheus(log *util.Logger, client api.Client, query string, timeout time.Duration) *Prometheus {
	p := &Prometheus{
		log:     log,
		api:     v1.NewAPI(client),
		query:   query,
		timeout: timeout,
	}

	return p
}

func (p *Prometheus) Query() (model.Value, error) {
	ctx, cancel := context.WithTimeout(context.Background(), p.timeout)
	defer cancel()

	res, warn, err := p.api.Query(ctx, p.query, time.Now())
	if err != nil {
		return nil, err
	}

	p.log.TRACE.Printf("query %q: %+v", p.query, res)
	if len(warn) > 0 {
		p.log.WARN.Printf("query %q returned warnings: %v", p.query, warn)
	}

	return res, nil
}

var _ FloatGetter = (*Prometheus)(nil)

// FloatGetter expects scalar value from query response as float
func (p *Prometheus) FloatGetter() (func() (float64, error), error) {
	return func() (float64, error) {
		res, err := p.Query()
		if err != nil {
			return 0, err
		}

		if res.Type() == model.ValScalar {
			scalarVal := res.(*model.Scalar)
			return float64(scalarVal.Value), nil
		}

		if res.Type() == model.ValVector {
			vectorVal := res.(model.Vector)
			if vectorVal.Len() != 1 {
				return 0, fmt.Errorf("query must return exactly 1 metric, got %d instead", vectorVal.Len())
			}
			metric := vectorVal[0]
			if metric.Histogram != nil {
				return 0, fmt.Errorf("query returned histogram, expected value")
			}
			return float64(metric.Value), nil
		}

		return 0, fmt.Errorf("query returned value of type %q, expected %q or %q", res.Type().String(), model.ValScalar.String(), model.ValVector.String())
	}, nil
}

var _ IntGetter = (*Prometheus)(nil)

// IntGetter expects scalar value from query response as int
func (p *Prometheus) IntGetter() (func() (int64, error), error) {
	g, err := p.FloatGetter()
	return func() (int64, error) {
		float, err := g()
		return int64(math.Round(float)), err
	}, err
}