package postprocess

import (
	"math"
	"reflect"
	"testing"

	"github.com/SigNoz/govaluate"
	v3 "go.signoz.io/signoz/pkg/query-service/model/v3"
)

func TestFindUniqueLabelSets(t *testing.T) {
	tests := []struct {
		name                string
		result              []*v3.Result
		want                []map[string]string
		queriesInExpression map[string]struct{}
	}{
		{
			name: "test1",
			result: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
						},
					},
				},
			},
			queriesInExpression: map[string]struct{}{
				"A": {},
				"B": {},
			},
			want: []map[string]string{
				{
					"service_name": "frontend",
					"operation":    "GET /api",
				},
				{
					"service_name": "redis",
				},
			},
		},
		{
			name: "test2",
			result: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
							},
						},
					},
				},
				{
					QueryName: "C",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"operation": "PUT /api",
							},
						},
					},
				},
				{
					QueryName: "D",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"http_status":  "200",
							},
						},
					},
				},
			},
			queriesInExpression: map[string]struct{}{
				"A": {},
				"B": {},
				"C": {},
				"D": {},
			},
			want: []map[string]string{
				{
					"service_name": "frontend",
					"operation":    "GET /api",
				},
				{
					"service_name": "frontend",
					"http_status":  "200",
				},
				{
					"operation": "PUT /api",
				},
			},
		},
		{
			name: "empty result",
			result: []*v3.Result{
				{
					QueryName: "A",
					Series:    []*v3.Series{},
				},
				{
					QueryName: "B",
					Series:    []*v3.Series{},
				},
			},
			queriesInExpression: map[string]struct{}{
				"A": {},
				"B": {},
			},
			want: []map[string]string{},
		},
		{
			name: "results with overlapping labels",
			result: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
						},
						{
							Labels: map[string]string{
								"service_name": "redis",
								"operation":    "GET /api",
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
						},
						{
							Labels: map[string]string{
								"service_name": "frontend",
							},
						},
					},
				},
			},
			queriesInExpression: map[string]struct{}{
				"A": {},
				"B": {},
			},
			want: []map[string]string{
				{
					"service_name": "frontend",
					"operation":    "GET /api",
				},
				{
					"service_name": "redis",
					"operation":    "GET /api",
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := findUniqueLabelSets(tt.result, tt.queriesInExpression)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("findUniqueLabelSets() = %v, want %v\n", got, tt.want)
			}
		})
	}
}

func TestProcessResults(t *testing.T) {
	tests := []struct {
		name    string
		results []*v3.Result
		want    *v3.Result
	}{
		{
			name: "test1",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     30,
								},
								{
									Timestamp: 3,
									Value:     40,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"service_name": "frontend",
							"operation":    "GET /api",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     10,
							},
							{
								Timestamp: 2,
								Value:     20,
							},
						},
					},
					{
						Labels: map[string]string{
							"service_name": "redis",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     30,
							},
							{
								Timestamp: 3,
								Value:     40,
							},
						},
					},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			expression, err := govaluate.NewEvaluableExpression("A + B")
			if err != nil {
				t.Errorf("Error parsing expression: %v", err)
			}
			canDefaultZero := map[string]bool{
				"A": true,
				"B": true,
			}
			got, err := processResults(tt.results, expression, canDefaultZero)
			if err != nil {
				t.Errorf("Error processing results: %v", err)
			}
			if len(got.Series) != len(tt.want.Series) {
				t.Errorf("processResults(): number of sereis - got = %v, want %v", len(got.Series), len(tt.want.Series))
			}

			for i := range got.Series {
				if len(got.Series[i].Points) != len(tt.want.Series[i].Points) {
					t.Errorf("processResults(): number of points - got = %v, want %v", got, tt.want)
				}
				for j := range got.Series[i].Points {
					if got.Series[i].Points[j].Value != tt.want.Series[i].Points[j].Value {
						t.Errorf("processResults(): got = %v, want %v", got.Series[i].Points[j].Value, tt.want.Series[i].Points[j].Value)
					}
				}
			}
		})
	}
}

func TestProcessResultsErrorRate(t *testing.T) {
	tests := []struct {
		name    string
		results []*v3.Result
		want    *v3.Result
	}{
		{
			name: "test1",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
							},
						},
						{
							Labels: map[string]string{
								"service_name": "route",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     2,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     6,
								},
								{
									Timestamp: 2,
									Value:     9,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"service_name": "frontend",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0,
							},
							{
								Timestamp: 2,
								Value:     0,
							},
						},
					},
					{
						Labels: map[string]string{
							"service_name": "redis",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0.5,
							},
							{
								Timestamp: 2,
								Value:     0.2,
							},
						},
					},
					{
						Labels: map[string]string{
							"service_name": "route",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0,
							},
							{
								Timestamp: 2,
								Value:     0,
							},
						},
					},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			expression, err := govaluate.NewEvaluableExpression("B/A")
			if err != nil {
				t.Errorf("Error parsing expression: %v", err)
			}
			canDefaultZero := map[string]bool{
				"A": true,
				"B": true,
			}
			got, err := processResults(tt.results, expression, canDefaultZero)
			if err != nil {
				t.Errorf("Error processing results: %v", err)
			}
			if len(got.Series) != len(tt.want.Series) {
				t.Errorf("processResults(): number of sereis - got = %v, want %v", len(got.Series), len(tt.want.Series))
			}

			for i := range got.Series {
				if len(got.Series[i].Points) != len(tt.want.Series[i].Points) {
					t.Errorf("processResults(): number of points - got = %v, want %v", got, tt.want)
				}
				for j := range got.Series[i].Points {
					if got.Series[i].Points[j].Value != tt.want.Series[i].Points[j].Value {
						t.Errorf("processResults(): got = %v, want %v", got.Series[i].Points[j].Value, tt.want.Series[i].Points[j].Value)
					}
				}
			}
		})
	}
}

func TestFormula(t *testing.T) {
	tests := []struct {
		name       string
		expression string
		results    []*v3.Result
		want       *v3.Result
	}{
		{
			name:       "No group keys on the left side",
			expression: "B/A",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"service_name": "frontend",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     2.2,
							},
							{
								Timestamp: 2,
								Value:     3.25,
							},
						},
					},
					{
						Labels: map[string]string{
							"service_name": "redis",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     1.8333333333333333,
							},
							{
								Timestamp: 2,
								Value:     1.4444444444444444,
							},
						},
					},
				},
			},
		},
		{
			name:       "No group keys on the right side",
			expression: "A/B",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-1",
							"state":     "running",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0.45454545454545453,
							},
							{
								Timestamp: 2,
								Value:     0.3076923076923077,
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-2",
							"state":     "idle",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0.5454545454545454,
							},
							{
								Timestamp: 2,
								Value:     0.6923076923076923,
							},
						},
					},
				},
			},
		},
		{
			name:       "Group keys on both sides are the same",
			expression: "A/B",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
								{
									Timestamp: 7,
									Value:     70,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-1",
							"state":     "running",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     float64(10) / float64(22),
							},
							{
								Timestamp: 2,
								Value:     0.3076923076923077,
							},
							{
								Timestamp: 3,
								Value:     0,
							},
							{
								Timestamp: 4,
								Value:     1,
							},
							{
								Timestamp: 5,
								Value:     1,
							},
							{
								Timestamp: 7,
								Value:     math.Inf(1),
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-2",
							"state":     "idle",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0.5454545454545454,
							},
							{
								Timestamp: 2,
								Value:     0.6923076923076923,
							},
							{
								Timestamp: 3,
								Value:     math.Inf(1),
							},
							{
								Timestamp: 4,
								Value:     1,
							},
							{
								Timestamp: 5,
								Value:     1,
							},
						},
					},
				},
			},
		},
		{
			name:       "Group keys on both sides are same but different values",
			expression: "A/B",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
								{
									Timestamp: 7,
									Value:     70,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "not_running_chalamet",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "busy",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-1",
							"state":     "running",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 2,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 4,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 5,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 7,
								Value:     math.Inf(0),
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-2",
							"state":     "idle",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 2,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 3,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 4,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 5,
								Value:     math.Inf(0),
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-1",
							"state":     "not_running_chalamet",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0,
							},
							{
								Timestamp: 2,
								Value:     0,
							},
							{
								Timestamp: 3,
								Value:     0,
							},
							{
								Timestamp: 4,
								Value:     0,
							},
							{
								Timestamp: 5,
								Value:     0,
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-2",
							"state":     "busy",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0,
							},
							{
								Timestamp: 2,
								Value:     0,
							},
							{
								Timestamp: 4,
								Value:     0,
							},
							{
								Timestamp: 5,
								Value:     0,
							},
						},
					},
				},
			},
		},
		{
			name:       "Group keys on the left side are a superset of the right side",
			expression: "A/B",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
								"os.type":   "linux",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
								{
									Timestamp: 7,
									Value:     70,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
								"os.type":   "linux",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"state":   "running",
								"os.type": "linux",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
						{
							Labels: map[string]string{
								"state":   "busy",
								"os.type": "linux",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-1",
							"state":     "running",
							"os.type":   "linux",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     float64(10) / float64(22),
							},
							{
								Timestamp: 2,
								Value:     0.3076923076923077,
							},
							{
								Timestamp: 3,
								Value:     0,
							},
							{
								Timestamp: 4,
								Value:     1,
							},
							{
								Timestamp: 5,
								Value:     1,
							},
							{
								Timestamp: 7,
								Value:     math.Inf(1),
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-2",
							"state":     "idle",
							"os.type":   "linux",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 2,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 3,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 4,
								Value:     math.Inf(0),
							},
							{
								Timestamp: 5,
								Value:     math.Inf(0),
							},
						},
					},
					{
						Labels: map[string]string{
							"state":   "busy",
							"os.type": "linux",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     0,
							},
							{
								Timestamp: 2,
								Value:     0,
							},
							{
								Timestamp: 4,
								Value:     0,
							},
							{
								Timestamp: 5,
								Value:     0,
							},
						},
					},
				},
			},
		},
		{
			name:       "Group keys are subsets, A is a subset of B and their result is a subset of C",
			expression: "A/B + C",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"state": "running",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
								{
									Timestamp: 7,
									Value:     70,
								},
							},
						},
						{
							Labels: map[string]string{
								"state": "idle",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     22,
								},
								{
									Timestamp: 2,
									Value:     65,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
				{
					QueryName: "C",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-1",
								"state":     "running",
								"os.type":   "linux",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
								{
									Timestamp: 7,
									Value:     70,
								},
							},
						},
						{
							Labels: map[string]string{
								"host_name": "ip-10-420-69-2",
								"state":     "idle",
								"os.type":   "linux",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     12,
								},
								{
									Timestamp: 2,
									Value:     45,
								},
								{
									Timestamp: 3,
									Value:     30,
								},
								{
									Timestamp: 4,
									Value:     40,
								},
								{
									Timestamp: 5,
									Value:     50,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-1",
							"state":     "running",
							"os.type":   "linux",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     10.45454545454545453,
							},
							{
								Timestamp: 2,
								Value:     20.3076923076923077,
							},
							{
								Timestamp: 3,
								Value:     0,
							},
							{
								Timestamp: 4,
								Value:     41,
							},
							{
								Timestamp: 5,
								Value:     51,
							},
							{
								Timestamp: 7,
								Value:     math.Inf(1),
							},
						},
					},
					{
						Labels: map[string]string{
							"host_name": "ip-10-420-69-2",
							"state":     "idle",
							"os.type":   "linux",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     12.5454545454545454,
							},
							{
								Timestamp: 2,
								Value:     45.6923076923076923,
							},
							{
								Timestamp: 3,
								Value:     math.Inf(1),
							},
							{
								Timestamp: 4,
								Value:     41,
							},
							{
								Timestamp: 5,
								Value:     51,
							},
						},
					},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			expression, err := govaluate.NewEvaluableExpression(tt.expression)
			if err != nil {
				t.Errorf("Error parsing expression: %v", err)
				return
			}
			canDefaultZero := map[string]bool{
				"A": true,
				"B": true,
				"C": true,
			}
			got, err := processResults(tt.results, expression, canDefaultZero)
			if err != nil {
				t.Errorf("Error processing results: %v", err)
				return
			}
			if len(got.Series) != len(tt.want.Series) {
				t.Errorf("processResults(): number of series - got = %v, want %v", len(got.Series), len(tt.want.Series))
				return
			}

			for i := range got.Series {
				if len(got.Series[i].Points) != len(tt.want.Series[i].Points) {
					t.Errorf("processResults(): number of points - got = %v, want %v", len(got.Series[i].Points), len(tt.want.Series[i].Points))
					return
				}
				for j := range got.Series[i].Points {
					if got.Series[i].Points[j].Value != tt.want.Series[i].Points[j].Value {
						t.Errorf("processResults(): got = %v, want %v", got.Series[i].Points[j].Value, tt.want.Series[i].Points[j].Value)
					}
				}
			}
		})
	}
}

func TestProcessResultsNoDefaultZero(t *testing.T) {
	tests := []struct {
		name    string
		results []*v3.Result
		want    *v3.Result
	}{
		{
			name: "test1",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     30,
								},
								{
									Timestamp: 3,
									Value:     40,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			expression, err := govaluate.NewEvaluableExpression("A + B")
			if err != nil {
				t.Errorf("Error parsing expression: %v", err)
			}
			canDefaultZero := map[string]bool{
				"A": false,
				"B": false,
			}
			got, err := processResults(tt.results, expression, canDefaultZero)
			if err != nil {
				t.Errorf("Error processing results: %v", err)
			}
			if len(got.Series) != len(tt.want.Series) {
				t.Errorf("processResults(): number of sereis - got = %v, want %v", len(got.Series), len(tt.want.Series))
			}

			for i := range got.Series {
				if len(got.Series[i].Points) != len(tt.want.Series[i].Points) {
					t.Errorf("processResults(): number of points - got = %v, want %v", got, tt.want)
				}
				for j := range got.Series[i].Points {
					if got.Series[i].Points[j].Value != tt.want.Series[i].Points[j].Value {
						t.Errorf("processResults(): got = %v, want %v", got.Series[i].Points[j].Value, tt.want.Series[i].Points[j].Value)
					}
				}
			}
		})
	}
}

func TestProcessResultsMixedQueries(t *testing.T) {
	tests := []struct {
		name    string
		results []*v3.Result
		want    *v3.Result
	}{
		{
			name: "test1",
			results: []*v3.Result{
				{
					QueryName: "A",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
					},
				},
				{
					QueryName: "B",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "frontend",
								"operation":    "GET /api",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     10,
								},
								{
									Timestamp: 2,
									Value:     20,
								},
							},
						},
					},
				},
				{
					QueryName: "C",
					Series: []*v3.Series{
						{
							Labels: map[string]string{
								"service_name": "redis",
							},
							Points: []v3.Point{
								{
									Timestamp: 1,
									Value:     30,
								},
								{
									Timestamp: 2,
									Value:     50,
								},
								{
									Timestamp: 3,
									Value:     45,
								},
							},
						},
					},
				},
			},
			want: &v3.Result{
				Series: []*v3.Series{
					{
						Labels: map[string]string{
							"service_name": "frontend",
							"operation":    "GET /api",
						},
						Points: []v3.Point{
							{
								Timestamp: 1,
								Value:     1,
							},
							{
								Timestamp: 2,
								Value:     1,
							},
						},
					},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			expression, err := govaluate.NewEvaluableExpression("A / B")
			if err != nil {
				t.Errorf("Error parsing expression: %v", err)
			}
			canDefaultZero := map[string]bool{
				"A": true,
				"B": true,
				"C": true,
			}
			got, err := processResults(tt.results, expression, canDefaultZero)
			if err != nil {
				t.Errorf("Error processing results: %v", err)
			}
			if len(got.Series) != len(tt.want.Series) {
				t.Errorf("processResults(): number of sereis - got = %v, want %v", len(got.Series), len(tt.want.Series))
			}

			for i := range got.Series {
				if len(got.Series[i].Points) != len(tt.want.Series[i].Points) {
					t.Errorf("processResults(): number of points - got = %v, want %v", got, tt.want)
				}
				for j := range got.Series[i].Points {
					if got.Series[i].Points[j].Value != tt.want.Series[i].Points[j].Value {
						t.Errorf("processResults(): got = %v, want %v", got.Series[i].Points[j].Value, tt.want.Series[i].Points[j].Value)
					}
				}
			}
		})
	}
}