package lexpr

import (
	"context"
	"reflect"
	"testing"
)

func TestLexpr_Eval(t *testing.T) {
	type fields struct {
		operators map[string]Operator
		functions map[string]func(ts *TokenStack) error
		variables map[string]any
	}
	type args struct {
		expression string
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    any
		wantErr bool
	}{
		{
			name: "simple math",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{},
			},
			args:    args{expression: "2 + 2 * 2"},
			want:    6,
			wantErr: false,
		},
		{
			name: "complex equal",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{},
			},
			args:    args{expression: "min(3, 2) * max(10, 20) == 40"},
			want:    1,
			wantErr: false,
		},
		{
			name: "complex neql",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{},
			},
			args:    args{expression: "min(3, 2) * max(10, 20) != 40"},
			want:    0,
			wantErr: false,
		},
		{
			name: "variables",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{
					"svar": "test",
					"ivar": int(123),
					"fvar": 321.0,
				},
			},
			args: args{
				expression: "len(svar) + ivar + fvar",
			},
			want:    448,
			wantErr: false,
		},
		{
			name: "invalid1",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{},
			},
			args:    args{expression: ")("},
			want:    nil,
			wantErr: true,
		},
		{
			name: "invalid2",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{},
			},
			args:    args{expression: "var1 + var2"},
			want:    nil,
			wantErr: true,
		},
		{
			name: "invalid3",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{},
			},
			args:    args{expression: "3 @ 4"},
			want:    nil,
			wantErr: true,
		},
		{
			name: "dot notation",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{
					"j": `{ "one" : { "four": {"five": "six"} }, "two": "three" }`,
				},
			},
			args: args{
				expression: `j.one.four.five`,
			},
			want:    `six`,
			wantErr: false,
		},
		{
			name: "dot notation with arrays",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{
					"j": `{ "one" : { "four": ["five", "six", "seven"] }, "two": "three" }`,
				},
			},
			args: args{
				expression: `j.one.four.1`,
			},
			want:    `six`,
			wantErr: false,
		},
		{
			name: "dot notation with arrays and variables",
			fields: fields{
				operators: Operators,
				functions: Functions,
				variables: map[string]any{
					"j":    `{ "one" : { "four": ["five", "six", "seven"] }, "two": "three" }`,
					"key1": "one",
					"key2": 1,
				},
			},
			args: args{
				expression: `j.key1.four.key2`,
			},
			want:    `six`,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			l := &Lexpr{
				operators: tt.fields.operators,
				functions: tt.fields.functions,
				variables: tt.fields.variables,
			}
			gotCh := l.Eval(context.Background(), tt.args.expression)
			res := <-gotCh
			got := res.Value
			err := res.Error
			if (err != nil) != tt.wantErr {
				t.Errorf("Lexpr.Eval() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Lexpr.Eval() = %v, want %v", got, tt.want)
			}
		})
	}
}