// Copyright 2013 Prometheus Team
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package extraction

import (
	"encoding/json"
	"fmt"
	"io"

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

// Processor002 is responsible for decoding payloads from protocol version
// 0.0.2.
var Processor002 = new(processor002)

type histogram002 struct {
	Labels map[string]string            `json:"labels"`
	Values map[string]model.SampleValue `json:"value"`
}

type counter002 struct {
	Labels map[string]string `json:"labels"`
	Value  model.SampleValue `json:"value"`
}

type processor002 struct{}

func (p *processor002) ProcessSingle(in io.Reader, out Ingester, o *ProcessOptions) error {
	// Processor for telemetry schema version 0.0.2.
	// container for telemetry data
	var entities []struct {
		BaseLabels map[string]string `json:"baseLabels"`
		Docstring  string            `json:"docstring"`
		Metric     struct {
			Type   string          `json:"type"`
			Values json.RawMessage `json:"value"`
		} `json:"metric"`
	}

	if err := json.NewDecoder(in).Decode(&entities); err != nil {
		return err
	}

	pendingSamples := model.Samples{}
	for _, entity := range entities {
		switch entity.Metric.Type {
		case "counter", "gauge":
			var values []counter002

			if err := json.Unmarshal(entity.Metric.Values, &values); err != nil {
				err := fmt.Errorf("Could not extract %s value: %s", entity.Metric.Type, err)
				if err := out.Ingest(&Result{Err: err}); err != nil {
					return err
				}
				continue
			}

			for _, counter := range values {
				entityLabels := labelSet(entity.BaseLabels).Merge(labelSet(counter.Labels))
				labels := mergeTargetLabels(entityLabels, o.BaseLabels)

				pendingSamples = append(pendingSamples, &model.Sample{
					Metric:    model.Metric(labels),
					Timestamp: o.Timestamp,
					Value:     counter.Value,
				})
			}

		case "histogram":
			var values []histogram002

			if err := json.Unmarshal(entity.Metric.Values, &values); err != nil {
				err := fmt.Errorf("Could not extract %s value: %s", entity.Metric.Type, err)
				if err := out.Ingest(&Result{Err: err}); err != nil {
					return err
				}
				continue
			}

			for _, histogram := range values {
				for percentile, value := range histogram.Values {
					entityLabels := labelSet(entity.BaseLabels).Merge(labelSet(histogram.Labels))
					entityLabels[model.LabelName("percentile")] = model.LabelValue(percentile)
					labels := mergeTargetLabels(entityLabels, o.BaseLabels)

					pendingSamples = append(pendingSamples, &model.Sample{
						Metric:    model.Metric(labels),
						Timestamp: o.Timestamp,
						Value:     value,
					})
				}
			}

		default:
			err := fmt.Errorf("Unknown metric type %q", entity.Metric.Type)
			if err := out.Ingest(&Result{Err: err}); err != nil {
				return err
			}
		}
	}

	if len(pendingSamples) > 0 {
		return out.Ingest(&Result{Samples: pendingSamples})
	}

	return nil
}