package ocagent

import (
	"encoding/json"
	"reflect"
	"testing"
	"time"

	"golang.org/x/tools/internal/telemetry"
	"golang.org/x/tools/internal/telemetry/export/ocagent/wire"
	"golang.org/x/tools/internal/telemetry/metric"
)

func TestDataToMetricDescriptor(t *testing.T) {
	tests := []struct {
		name string
		data telemetry.MetricData
		want *wire.MetricDescriptor
	}{
		{
			"nil data",
			nil,
			nil,
		},
		{
			"Int64Data gauge",
			&metric.Int64Data{
				Info: &metric.Scalar{
					Name:        "int",
					Description: "int metric",
					Keys:        []interface{}{"hello"},
				},
				IsGauge: true,
			},
			&wire.MetricDescriptor{
				Name:        "int",
				Description: "int metric",
				Type:        wire.MetricDescriptor_GAUGE_INT64,
				LabelKeys: []*wire.LabelKey{
					&wire.LabelKey{
						Key: "hello",
					},
				},
			},
		},
		{
			"Float64Data cumulative",
			&metric.Float64Data{
				Info: &metric.Scalar{
					Name:        "float",
					Description: "float metric",
					Keys:        []interface{}{"world"},
				},
				IsGauge: false,
			},
			&wire.MetricDescriptor{
				Name:        "float",
				Description: "float metric",
				Type:        wire.MetricDescriptor_CUMULATIVE_DOUBLE,
				LabelKeys: []*wire.LabelKey{
					&wire.LabelKey{
						Key: "world",
					},
				},
			},
		},
		{
			"HistogramInt64",
			&metric.HistogramInt64Data{
				Info: &metric.HistogramInt64{
					Name:        "histogram int",
					Description: "histogram int metric",
					Keys:        []interface{}{"hello"},
				},
			},
			&wire.MetricDescriptor{
				Name:        "histogram int",
				Description: "histogram int metric",
				Type:        wire.MetricDescriptor_CUMULATIVE_DISTRIBUTION,
				LabelKeys: []*wire.LabelKey{
					&wire.LabelKey{
						Key: "hello",
					},
				},
			},
		},
		{
			"HistogramFloat64",
			&metric.HistogramFloat64Data{
				Info: &metric.HistogramFloat64{
					Name:        "histogram float",
					Description: "histogram float metric",
					Keys:        []interface{}{"hello"},
				},
			},
			&wire.MetricDescriptor{
				Name:        "histogram float",
				Description: "histogram float metric",
				Type:        wire.MetricDescriptor_CUMULATIVE_DISTRIBUTION,
				LabelKeys: []*wire.LabelKey{
					&wire.LabelKey{
						Key: "hello",
					},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := dataToMetricDescriptor(tt.data)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func TestGetDescription(t *testing.T) {
	tests := []struct {
		name string
		data telemetry.MetricData
		want string
	}{
		{
			"nil data",
			nil,
			"",
		},
		{
			"Int64Data description",
			&metric.Int64Data{
				Info: &metric.Scalar{
					Description: "int metric",
				},
			},
			"int metric",
		},
		{
			"Float64Data description",
			&metric.Float64Data{
				Info: &metric.Scalar{
					Description: "float metric",
				},
			},
			"float metric",
		},
		{
			"HistogramInt64Data description",
			&metric.HistogramInt64Data{
				Info: &metric.HistogramInt64{
					Description: "histogram int metric",
				},
			},
			"histogram int metric",
		},
		{
			"HistogramFloat64Data description",
			&metric.HistogramFloat64Data{
				Info: &metric.HistogramFloat64{
					Description: "histogram float metric",
				},
			},
			"histogram float metric",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := getDescription(tt.data)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}

}

func TestGetLabelKeys(t *testing.T) {
	tests := []struct {
		name string
		data telemetry.MetricData
		want []*wire.LabelKey
	}{
		{
			"nil label keys",
			nil,
			nil,
		},
		{
			"Int64Data label keys",
			&metric.Int64Data{
				Info: &metric.Scalar{
					Keys: []interface{}{
						"hello",
					},
				},
			},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "hello",
				},
			},
		},
		{
			"Float64Data label keys",
			&metric.Float64Data{
				Info: &metric.Scalar{
					Keys: []interface{}{
						"world",
					},
				},
			},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "world",
				},
			},
		},
		{
			"HistogramInt64Data label keys",
			&metric.HistogramInt64Data{
				Info: &metric.HistogramInt64{
					Keys: []interface{}{
						"hello",
					},
				},
			},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "hello",
				},
			},
		},
		{
			"HistogramFloat64Data label keys",
			&metric.HistogramFloat64Data{
				Info: &metric.HistogramFloat64{
					Keys: []interface{}{
						"hello",
					},
				},
			},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "hello",
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := getLabelKeys(tt.data)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func TestDataToMetricDescriptorType(t *testing.T) {
	tests := []struct {
		name string
		data telemetry.MetricData
		want wire.MetricDescriptor_Type
	}{
		{
			"Nil data",
			nil,
			wire.MetricDescriptor_UNSPECIFIED,
		},
		{
			"Gauge Int64",
			&metric.Int64Data{
				IsGauge: true,
			},
			wire.MetricDescriptor_GAUGE_INT64,
		},
		{
			"Cumulative Int64",
			&metric.Int64Data{
				IsGauge: false,
			},
			wire.MetricDescriptor_CUMULATIVE_INT64,
		},
		{
			"Gauge Float64",
			&metric.Float64Data{
				IsGauge: true,
			},
			wire.MetricDescriptor_GAUGE_DOUBLE,
		},
		{
			"Cumulative Float64",
			&metric.Float64Data{
				IsGauge: false,
			},
			wire.MetricDescriptor_CUMULATIVE_DOUBLE,
		},
		{
			"HistogramInt64",
			&metric.HistogramInt64Data{},
			wire.MetricDescriptor_CUMULATIVE_DISTRIBUTION,
		},
		{
			"HistogramFloat64",
			&metric.HistogramFloat64Data{},
			wire.MetricDescriptor_CUMULATIVE_DISTRIBUTION,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := dataToMetricDescriptorType(tt.data)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func TestDataToTimeseries(t *testing.T) {
	epoch := time.Unix(0, 0)
	epochTimestamp := convertTimestamp(epoch)

	end := time.Unix(30, 0)
	endTimestamp := convertTimestamp(end)

	tests := []struct {
		name  string
		data  telemetry.MetricData
		start time.Time
		want  []*wire.TimeSeries
	}{
		{
			"nil data",
			nil,
			time.Time{},
			nil,
		},
		{
			"Int64Data",
			&metric.Int64Data{
				Rows: []int64{
					1,
					2,
					3,
				},
				EndTime: &end,
			},
			epoch,
			[]*wire.TimeSeries{
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value:     wire.PointInt64Value{Int64Value: 1},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value:     wire.PointInt64Value{Int64Value: 2},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value:     wire.PointInt64Value{Int64Value: 3},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
			},
		},
		{
			"Float64Data",
			&metric.Float64Data{
				Rows: []float64{
					1.5,
					4.5,
				},
				EndTime: &end,
			},
			epoch,
			[]*wire.TimeSeries{
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value:     wire.PointDoubleValue{DoubleValue: 1.5},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value:     wire.PointDoubleValue{DoubleValue: 4.5},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
			},
		},
		{
			"HistogramInt64Data",
			&metric.HistogramInt64Data{
				Rows: []*metric.HistogramInt64Row{
					{
						Count: 6,
						Sum:   40,
						Values: []int64{
							1,
							2,
							3,
						},
					},
				},
				Info: &metric.HistogramInt64{
					Buckets: []int64{
						0, 5, 10,
					},
				},
				EndTime: &end,
			},
			epoch,
			[]*wire.TimeSeries{
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value: wire.PointDistributionValue{
								DistributionValue: &wire.DistributionValue{
									Count: 6,
									Sum:   40,
									Buckets: []*wire.Bucket{
										{
											Count: 1,
										},
										{
											Count: 2,
										},
										{
											Count: 3,
										},
									},
									BucketOptions: &wire.BucketOptionsExplicit{
										Bounds: []float64{
											0, 5, 10,
										},
									},
								},
							},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
			},
		},
		{
			"HistogramFloat64Data",
			&metric.HistogramFloat64Data{
				Rows: []*metric.HistogramFloat64Row{
					{
						Count: 3,
						Sum:   10,
						Values: []int64{
							1,
							2,
						},
					},
				},
				Info: &metric.HistogramFloat64{
					Buckets: []float64{
						0, 5,
					},
				},
				EndTime: &end,
			},
			epoch,
			[]*wire.TimeSeries{
				&wire.TimeSeries{
					Points: []*wire.Point{
						&wire.Point{
							Value: wire.PointDistributionValue{
								DistributionValue: &wire.DistributionValue{
									Count: 3,
									Sum:   10,
									Buckets: []*wire.Bucket{
										{
											Count: 1,
										},
										{
											Count: 2,
										},
									},
									BucketOptions: &wire.BucketOptionsExplicit{
										Bounds: []float64{
											0, 5,
										},
									},
								},
							},
							Timestamp: &endTimestamp,
						},
					},
					StartTimestamp: &epochTimestamp,
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := dataToTimeseries(tt.data, tt.start)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func TestNumRows(t *testing.T) {
	tests := []struct {
		name string
		data telemetry.MetricData
		want int
	}{
		{
			"nil data",
			nil,
			0,
		},
		{
			"1 row Int64Data",
			&metric.Int64Data{
				Rows: []int64{
					0,
				},
			},
			1,
		},
		{
			"2 row Float64Data",
			&metric.Float64Data{
				Rows: []float64{
					0,
					1.0,
				},
			},
			2,
		},
		{
			"1 row HistogramInt64Data",
			&metric.HistogramInt64Data{
				Rows: []*metric.HistogramInt64Row{
					{},
				},
			},
			1,
		},
		{
			"3 row HistogramFloat64Data",
			&metric.HistogramFloat64Data{
				Rows: []*metric.HistogramFloat64Row{
					{},
					{},
					{},
				},
			},
			3,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := numRows(tt.data)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func TestDataToPoints(t *testing.T) {
	end := time.Unix(30, 0)
	endTimestamp := convertTimestamp(end)

	int64Data := &metric.Int64Data{
		Rows: []int64{
			0,
			10,
		},
		EndTime: &end,
	}

	float64Data := &metric.Float64Data{
		Rows: []float64{
			0.5,
			0.25,
		},
		EndTime: &end,
	}

	histogramInt64Data := &metric.HistogramInt64Data{
		Rows: []*metric.HistogramInt64Row{
			{
				Count: 6,
				Sum:   40,
				Values: []int64{
					1,
					2,
					3,
				},
			},
			{
				Count: 12,
				Sum:   80,
				Values: []int64{
					2,
					4,
					6,
				},
			},
		},
		Info: &metric.HistogramInt64{
			Buckets: []int64{
				0, 5, 10,
			},
		},
		EndTime: &end,
	}

	histogramFloat64Data := &metric.HistogramFloat64Data{
		Rows: []*metric.HistogramFloat64Row{
			{
				Count: 6,
				Sum:   40,
				Values: []int64{
					1,
					2,
					3,
				},
			},
			{
				Count: 18,
				Sum:   80,
				Values: []int64{
					3,
					6,
					9,
				},
			},
		},
		Info: &metric.HistogramFloat64{
			Buckets: []float64{
				0, 5, 10,
			},
		},
		EndTime: &end,
	}

	tests := []struct {
		name string
		data telemetry.MetricData
		i    int
		want []*wire.Point
	}{
		{
			"nil data",
			nil,
			0,
			nil,
		},
		{
			"Int64data index 0",
			int64Data,
			0,
			[]*wire.Point{
				{
					Value: wire.PointInt64Value{
						Int64Value: 0,
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"Int64data index 1",
			int64Data,
			1,
			[]*wire.Point{
				{
					Value: wire.PointInt64Value{
						Int64Value: 10,
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"Float64Data index 0",
			float64Data,
			0,
			[]*wire.Point{
				{
					Value: wire.PointDoubleValue{
						DoubleValue: 0.5,
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"Float64Data index 1",
			float64Data,
			1,
			[]*wire.Point{
				{
					Value: wire.PointDoubleValue{
						DoubleValue: 0.25,
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"HistogramInt64Data index 0",
			histogramInt64Data,
			0,
			[]*wire.Point{
				{
					Value: wire.PointDistributionValue{
						DistributionValue: &wire.DistributionValue{
							Count: 6,
							Sum:   40,
							Buckets: []*wire.Bucket{
								{
									Count: 1,
								},
								{
									Count: 2,
								},
								{
									Count: 3,
								},
							},
							BucketOptions: &wire.BucketOptionsExplicit{
								Bounds: []float64{
									0, 5, 10,
								},
							},
						},
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"HistogramInt64Data index 1",
			histogramInt64Data,
			1,
			[]*wire.Point{
				{
					Value: wire.PointDistributionValue{
						DistributionValue: &wire.DistributionValue{
							Count: 12,
							Sum:   80,
							Buckets: []*wire.Bucket{
								{
									Count: 2,
								},
								{
									Count: 4,
								},
								{
									Count: 6,
								},
							},
							BucketOptions: &wire.BucketOptionsExplicit{
								Bounds: []float64{
									0, 5, 10,
								},
							},
						},
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"HistogramFloat64Data index 0",
			histogramFloat64Data,
			0,
			[]*wire.Point{
				{
					Value: wire.PointDistributionValue{
						DistributionValue: &wire.DistributionValue{
							Count: 6,
							Sum:   40,
							Buckets: []*wire.Bucket{
								{
									Count: 1,
								},
								{
									Count: 2,
								},
								{
									Count: 3,
								},
							},
							BucketOptions: &wire.BucketOptionsExplicit{
								Bounds: []float64{
									0, 5, 10,
								},
							},
						},
					},
					Timestamp: &endTimestamp,
				},
			},
		},
		{
			"HistogramFloat64Data index 1",
			histogramFloat64Data,
			1,
			[]*wire.Point{
				{
					Value: wire.PointDistributionValue{
						DistributionValue: &wire.DistributionValue{
							Count: 18,
							Sum:   80,
							Buckets: []*wire.Bucket{
								{
									Count: 3,
								},
								{
									Count: 6,
								},
								{
									Count: 9,
								},
							},
							BucketOptions: &wire.BucketOptionsExplicit{
								Bounds: []float64{
									0, 5, 10,
								},
							},
						},
					},
					Timestamp: &endTimestamp,
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := dataToPoints(tt.data, tt.i)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func TestDistributionToPoints(t *testing.T) {
	end := time.Unix(30, 0)
	endTimestamp := convertTimestamp(end)

	tests := []struct {
		name    string
		counts  []int64
		count   int64
		sum     float64
		buckets []float64
		end     time.Time
		want    []*wire.Point
	}{
		{
			name: "3 buckets",
			counts: []int64{
				1,
				2,
				3,
			},
			count: 6,
			sum:   40,
			buckets: []float64{
				0, 5, 10,
			},
			end: end,
			want: []*wire.Point{
				{
					Value: wire.PointDistributionValue{
						DistributionValue: &wire.DistributionValue{
							Count: 6,
							Sum:   40,
							// TODO: SumOfSquaredDeviation?
							Buckets: []*wire.Bucket{
								&wire.Bucket{
									Count: 1,
								},
								&wire.Bucket{
									Count: 2,
								},
								&wire.Bucket{
									Count: 3,
								},
							},
							BucketOptions: &wire.BucketOptionsExplicit{
								Bounds: []float64{
									0, 5, 10,
								},
							},
						},
					},
					Timestamp: &endTimestamp,
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := distributionToPoints(tt.counts, tt.count, tt.sum, tt.buckets, tt.end)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}

}

func TestInfoKeysToLabelKeys(t *testing.T) {
	tests := []struct {
		name     string
		infoKeys []interface{}
		want     []*wire.LabelKey
	}{
		{
			"empty infoKeys",
			[]interface{}{},
			[]*wire.LabelKey{},
		},
		{
			"empty string infoKey",
			[]interface{}{""},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "",
				},
			},
		},
		{
			"non-empty string infoKey",
			[]interface{}{"hello"},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "hello",
				},
			},
		},
		{
			"multiple element infoKey",
			[]interface{}{"hello", "world"},
			[]*wire.LabelKey{
				&wire.LabelKey{
					Key: "hello",
				},
				&wire.LabelKey{
					Key: "world",
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := infoKeysToLabelKeys(tt.infoKeys)
			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("Got:\n%s\nWant:\n%s", marshaled(got), marshaled(tt.want))
			}
		})
	}
}

func marshaled(v interface{}) string {
	blob, _ := json.MarshalIndent(v, "", "  ")
	return string(blob)
}