package expr

import (
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
)

// TestValidateExpressionNode 测试表达式节点验证功能
func TestValidateExpressionNode(t *testing.T) {
	tests := []struct {
		name    string
		node    *ExprNode
		wantErr bool
	}{
		{
			"有效数字节点",
			&ExprNode{Type: TypeNumber, Value: "123"},
			false,
		},
		{
			"有效字段节点",
			&ExprNode{Type: TypeField, Value: "field1"},
			false,
		},
		{
			"有效字符串节点",
			&ExprNode{Type: TypeString, Value: "'hello'"},
			false,
		},
		{
			"有效运算符节点",
			&ExprNode{
				Type:  TypeOperator,
				Value: "+",
				Left:  &ExprNode{Type: TypeNumber, Value: "1"},
				Right: &ExprNode{Type: TypeNumber, Value: "2"},
			},
			false,
		},
		{
			"有效函数节点",
			&ExprNode{
				Type:  TypeFunction,
				Value: "abs",
				Args:  []*ExprNode{{Type: TypeNumber, Value: "1"}},
			},
			false,
		},
		{
			"有效CASE节点",
			&ExprNode{
				Type: TypeCase,
				CaseExpr: &CaseExpression{
					WhenClauses: []WhenClause{
						{
							Condition: &ExprNode{
								Type:  TypeOperator,
								Value: ">",
								Left:  &ExprNode{Type: TypeField, Value: "a"},
								Right: &ExprNode{Type: TypeNumber, Value: "0"},
							},
							Result: &ExprNode{Type: TypeNumber, Value: "1"},
						},
					},
					ElseResult: &ExprNode{Type: TypeNumber, Value: "0"},
				},
			},
			false,
		},
		// 错误情况
		{"空节点", nil, true},
		{"无效数字", &ExprNode{Type: TypeNumber, Value: "abc"}, true},
		{"无效字段名", &ExprNode{Type: TypeField, Value: "123field"}, true},
		{"无效字符串", &ExprNode{Type: TypeString, Value: "hello"}, true},
		{"运算符缺少左操作数", &ExprNode{
			Type:  TypeOperator,
			Value: "+",
			Right: &ExprNode{Type: TypeNumber, Value: "1"},
		}, true},
		{"运算符缺少右操作数", &ExprNode{
			Type:  TypeOperator,
			Value: "+",
			Left:  &ExprNode{Type: TypeNumber, Value: "1"},
		}, true},
		{"无效运算符", &ExprNode{
			Type:  TypeOperator,
			Value: "@",
			Left:  &ExprNode{Type: TypeNumber, Value: "1"},
			Right: &ExprNode{Type: TypeNumber, Value: "2"},
		}, true},
		{"无效函数", &ExprNode{
			Type:  TypeFunction,
			Value: "unknown",
			Args:  []*ExprNode{{Type: TypeNumber, Value: "1"}},
		}, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateExpression(tt.node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "验证不应该失败")
			}
		})
	}
}

// TestValidateExpression 测试公共表达式验证接口
func TestValidateExpression(t *testing.T) {
	tests := []struct {
		name    string
		expr    string
		wantErr bool
	}{
		// 有效表达式
		{"简单数字", "123", false},
		{"简单字段", "field1", false},
		{"算术表达式", "1 + 2", false},
		{"比较表达式", "field1 > 10", false},
		{"函数调用", "abs(-5)", false},
		{"复杂表达式", "(field1 + field2) * 2", false},
		{"字符串比较", "name = 'test'", false},
		{"CASE表达式", "CASE WHEN field1 > 0 THEN 1 ELSE 0 END", false},
		{"逻辑表达式", "field1 > 0 AND field2 < 100", false},
		{"嵌套函数", "max(abs(field1), abs(field2))", false},

		// 无效表达式
		{"空表达式", "", true},
		{"只有空格", "   ", true},
		{"括号不匹配1", "(1 + 2", true},
		{"括号不匹配2", "1 + 2)", true},
		{"连续运算符", "1 + + 2", true},
		{"运算符开头", "+ 1 + 2", true},
		{"运算符结尾", "1 + 2 +", true},
		{"空括号", "()", true},
		{"无效数字", "12.34.56", true},
		{"无效字符串", "'unclosed string", true},
		{"无效函数", "unknown_func(1)", true},
		{"无效字段名", "123field", true},
		{"tokenize错误", "field with invalid 'quote", true},
		{"解析错误", "(((", true},
		{"AST验证错误", "123abc", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateExpression(tt.expr)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "验证不应该失败")
			}
		})
	}
}

// TestValidateNumberNode 测试数字节点验证
func TestValidateNumberNode(t *testing.T) {
	tests := []struct {
		name    string
		value   string
		wantErr bool
	}{
		{"正整数", "123", false},
		{"负整数", "-123", false},
		{"零", "0", false},
		{"正小数", "3.14", false},
		{"负小数", "-3.14", false},
		{"科学计数法", "1.5e10", false},
		{"负科学计数法", "-1.5e-3", false},
		{"小数点开头", ".5", false},
		{"小数点结尾", "5.", false},
		// 错误情况
		{"空字符串", "", true},
		{"字母", "abc", true},
		{"多个小数点", "3.14.15", true},
		{"多个负号", "--5", true},
		{"负号在中间", "3-5", true},
		{"只有小数点", ".", true},
		{"只有负号", "-", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			node := &ExprNode{Type: TypeNumber, Value: tt.value}
			err := validateNumberNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "数字验证不应该失败")
			}
		})
	}
}

// TestValidateStringNode 测试字符串节点验证
func TestValidateStringNode(t *testing.T) {
	tests := []struct {
		name    string
		value   string
		wantErr bool
	}{
		{"单引号字符串", "'hello'", false},
		{"双引号字符串", "\"world\"", false},
		{"空字符串", "''", false},
		{"空双引号字符串", "\"\"", false},
		{"包含转义的字符串", "'hello\\world'", false},
		{"包含单引号的双引号字符串", "\"hello'world\"", false},
		{"包含双引号的单引号字符串", "'hello\"world'", false},
		// 错误情况
		{"未闭合单引号", "'hello", true},
		{"未闭合双引号", "\"hello", true},
		{"没有引号", "hello", true},
		{"空值", "", true},
		{"只有单引号", "'", true},
		{"只有双引号", "\"", true},
		{"引号不匹配", "'hello\"", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			node := &ExprNode{Type: TypeString, Value: tt.value}
			err := validateStringNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "字符串验证不应该失败")
			}
		})
	}
}

// TestValidateFieldNode 测试字段节点验证
func TestValidateFieldNode(t *testing.T) {
	tests := []struct {
		name    string
		value   string
		wantErr bool
	}{
		{"简单字段名", "field1", false},
		{"下划线开头", "_field", false},
		{"包含数字", "field123", false},
		{"驼峰命名", "fieldName", false},
		{"蛇形命名", "field_name", false},
		{"大写字段", "FIELD", false},
		{"反引号字段", "`field name`", false},
		{"反引号包含特殊字符", "`user.name`", false},
		{"反引号包含空格", "`user name`", false},
		// 错误情况
		{"空字段名", "", true},
		{"数字开头", "123field", true},
		{"包含特殊字符", "field-name", true},
		{"包含空格", "field name", true},
		{"包含点号", "field.name", true},
		{"未闭合反引号", "`field", true},
		{"只有反引号", "`", true},
		{"空反引号", "``", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			node := &ExprNode{Type: TypeField, Value: tt.value}
			err := validateFieldNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "字段验证不应该失败")
			}
		})
	}
}

// TestValidateOperatorNode 测试运算符节点验证
func TestValidateOperatorNode(t *testing.T) {
	tests := []struct {
		name     string
		operator string
		left     *ExprNode
		right    *ExprNode
		wantErr  bool
	}{
		{
			"有效加法",
			"+",
			&ExprNode{Type: TypeNumber, Value: "1"},
			&ExprNode{Type: TypeNumber, Value: "2"},
			false,
		},
		{
			"有效比较",
			">",
			&ExprNode{Type: TypeField, Value: "a"},
			&ExprNode{Type: TypeNumber, Value: "0"},
			false,
		},
		{
			"有效逻辑运算",
			"AND",
			&ExprNode{
				Type:  TypeOperator,
				Value: ">",
				Left:  &ExprNode{Type: TypeField, Value: "a"},
				Right: &ExprNode{Type: TypeNumber, Value: "0"},
			},
			&ExprNode{
				Type:  TypeOperator,
				Value: "<",
				Left:  &ExprNode{Type: TypeField, Value: "b"},
				Right: &ExprNode{Type: TypeNumber, Value: "10"},
			},
			false,
		},
		{
			"有效NOT运算（单操作数）",
			"NOT",
			&ExprNode{
				Type:  TypeOperator,
				Value: ">",
				Left:  &ExprNode{Type: TypeField, Value: "a"},
				Right: &ExprNode{Type: TypeNumber, Value: "0"},
			},
			nil,
			false,
		},
		// 错误情况
		{"无效运算符", "@", &ExprNode{Type: TypeNumber, Value: "1"}, &ExprNode{Type: TypeNumber, Value: "2"}, true},
		{"缺少左操作数", "+", nil, &ExprNode{Type: TypeNumber, Value: "2"}, true},
		{"缺少右操作数（双操作数运算符）", "+", &ExprNode{Type: TypeNumber, Value: "1"}, nil, true},
		{"NOT运算符有右操作数", "NOT", &ExprNode{Type: TypeNumber, Value: "1"}, &ExprNode{Type: TypeNumber, Value: "2"}, true},
		{"左操作数验证失败", "+", &ExprNode{Type: TypeNumber, Value: "abc"}, &ExprNode{Type: TypeNumber, Value: "2"}, true},
		{"右操作数验证失败", "+", &ExprNode{Type: TypeNumber, Value: "1"}, &ExprNode{Type: TypeNumber, Value: "abc"}, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			node := &ExprNode{
				Type:  TypeOperator,
				Value: tt.operator,
				Left:  tt.left,
				Right: tt.right,
			}
			err := validateOperatorNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "运算符验证不应该失败")
			}
		})
	}
}

// TestValidateFunctionNode 测试函数节点验证
func TestValidateFunctionNode(t *testing.T) {
	// 测试函数Value为空的情况
	t.Run("函数名为空", func(t *testing.T) {
		node := &ExprNode{
			Type:  TypeFunction,
			Value: "",
			Args:  []*ExprNode{{Type: TypeNumber, Value: "1"}},
		}
		err := validateFunctionNode(node)
		assert.Error(t, err, "函数名为空时应该返回错误")
		assert.Contains(t, err.Error(), "function node has empty value")
	})

	tests := []struct {
		name     string
		funcName string
		args     []*ExprNode
		wantErr  bool
	}{
		{
			"ABS函数",
			"abs",
			[]*ExprNode{{Type: TypeNumber, Value: "1"}},
			false,
		},
		{
			"MAX函数",
			"max",
			[]*ExprNode{
				{Type: TypeNumber, Value: "1"},
				{Type: TypeNumber, Value: "2"},
				{Type: TypeNumber, Value: "3"},
			},
			false,
		},
		{
			"POW函数",
			"pow",
			[]*ExprNode{
				{Type: TypeNumber, Value: "2"},
				{Type: TypeNumber, Value: "3"},
			},
			false,
		},
		{
			"COUNT函数（无参数）",
			"count",
			[]*ExprNode{},
			false,
		},
		// 错误情况
		{"未知函数", "unknown", []*ExprNode{{Type: TypeNumber, Value: "1"}}, true},
		{"ABS参数数量错误", "abs", []*ExprNode{}, true},
		{"POW参数数量错误", "pow", []*ExprNode{{Type: TypeNumber, Value: "2"}}, true},
		{"参数验证失败", "abs", []*ExprNode{{Type: TypeNumber, Value: "abc"}}, true},
		{"参数表达式验证失败", "abs", []*ExprNode{{Type: TypeField, Value: "invalid field name!"}}, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			node := &ExprNode{
				Type:  TypeFunction,
				Value: tt.funcName,
				Args:  tt.args,
			}
			err := validateFunctionNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "函数验证不应该失败")
			}
		})
	}
}

// TestValidateFunctionArgs 测试函数参数验证
func TestValidateFunctionArgs(t *testing.T) {
	tests := []struct {
		name     string
		funcName string
		args     []*ExprNode
		wantErr  bool
	}{
		// 单参数函数
		{"ABS正确参数", "abs", []*ExprNode{{Type: TypeNumber, Value: "1"}}, false},
		{"ABS参数过少", "abs", []*ExprNode{}, true},
		{"ABS参数过多", "abs", []*ExprNode{{Type: TypeNumber, Value: "1"}, {Type: TypeNumber, Value: "2"}}, true},

		// 双参数函数
		{"POW正确参数", "pow", []*ExprNode{{Type: TypeNumber, Value: "2"}, {Type: TypeNumber, Value: "3"}}, false},
		{"POW参数过少", "pow", []*ExprNode{{Type: TypeNumber, Value: "2"}}, true},
		{"POW参数过多", "pow", []*ExprNode{{Type: TypeNumber, Value: "2"}, {Type: TypeNumber, Value: "3"}, {Type: TypeNumber, Value: "4"}}, true},

		// 可变参数函数
		{"MAX单参数", "max", []*ExprNode{{Type: TypeNumber, Value: "1"}}, false},
		{"MAX多参数", "max", []*ExprNode{{Type: TypeNumber, Value: "1"}, {Type: TypeNumber, Value: "2"}, {Type: TypeNumber, Value: "3"}}, false},
		{"MAX无参数", "max", []*ExprNode{}, true},

		// 无参数函数（如果有的话）
		{"COUNT无参数", "count", []*ExprNode{}, false},
		{"COUNT有参数", "count", []*ExprNode{{Type: TypeNumber, Value: "1"}}, false}, // COUNT可以有参数

		// 未知函数
		{"未知函数", "unknown", []*ExprNode{{Type: TypeNumber, Value: "1"}}, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// 创建一个函数节点来测试
			node := &ExprNode{
				Type:  TypeFunction,
				Value: tt.funcName,
				Args:  tt.args,
			}
			// 使用validateFunctionNode来验证函数名和参数数量
			err := validateFunctionNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "函数参数验证不应该失败")
			}
		})
	}
}

// TestValidateCaseNode 测试CASE节点验证
func TestValidateCaseNode(t *testing.T) {
	tests := []struct {
		name     string
		caseExpr *CaseExpression
		wantErr  bool
	}{
		{
			"有效CASE表达式",
			&CaseExpression{
				WhenClauses: []WhenClause{
					{
						Condition: &ExprNode{
							Type:  TypeOperator,
							Value: ">",
							Left:  &ExprNode{Type: TypeField, Value: "a"},
							Right: &ExprNode{Type: TypeNumber, Value: "0"},
						},
						Result: &ExprNode{Type: TypeNumber, Value: "1"},
					},
				},
				ElseResult: &ExprNode{Type: TypeNumber, Value: "0"},
			},
			false,
		},
		{
			"简单CASE表达式（带Value）",
			&CaseExpression{
				Value: &ExprNode{Type: TypeField, Value: "status"},
				WhenClauses: []WhenClause{
					{
						Condition: &ExprNode{Type: TypeString, Value: "'active'"},
						Result: &ExprNode{Type: TypeNumber, Value: "1"},
					},
					{
						Condition: &ExprNode{Type: TypeString, Value: "'inactive'"},
						Result: &ExprNode{Type: TypeNumber, Value: "0"},
					},
				},
				ElseResult: &ExprNode{Type: TypeNumber, Value: "-1"},
			},
			false,
		},
		{
			"多个WHEN子句",
			&CaseExpression{
				WhenClauses: []WhenClause{
					{
						Condition: &ExprNode{
							Type:  TypeOperator,
							Value: ">",
							Left:  &ExprNode{Type: TypeField, Value: "a"},
							Right: &ExprNode{Type: TypeNumber, Value: "0"},
						},
						Result: &ExprNode{Type: TypeNumber, Value: "1"},
					},
					{
						Condition: &ExprNode{
							Type:  TypeOperator,
							Value: "<",
							Left:  &ExprNode{Type: TypeField, Value: "a"},
							Right: &ExprNode{Type: TypeNumber, Value: "0"},
						},
						Result: &ExprNode{Type: TypeNumber, Value: "-1"},
					},
				},
				ElseResult: &ExprNode{Type: TypeNumber, Value: "0"},
			},
			false,
		},
		{
			"没有ELSE子句",
			&CaseExpression{
				WhenClauses: []WhenClause{
					{
						Condition: &ExprNode{
							Type:  TypeOperator,
							Value: ">",
							Left:  &ExprNode{Type: TypeField, Value: "a"},
							Right: &ExprNode{Type: TypeNumber, Value: "0"},
						},
						Result: &ExprNode{Type: TypeNumber, Value: "1"},
					},
				},
				ElseResult: nil,
			},
			false,
		},
		// 错误情况
		{"没有WHEN子句", &CaseExpression{WhenClauses: []WhenClause{}, ElseResult: &ExprNode{Type: TypeNumber, Value: "0"}}, true},
		{"WHEN条件为空", &CaseExpression{
			WhenClauses: []WhenClause{
				{Condition: nil, Result: &ExprNode{Type: TypeNumber, Value: "1"}},
			},
		}, true},
		{"WHEN结果为空", &CaseExpression{
			WhenClauses: []WhenClause{
				{Condition: &ExprNode{Type: TypeField, Value: "a"}, Result: nil},
			},
		}, true},
		{"WHEN条件验证失败", &CaseExpression{
			WhenClauses: []WhenClause{
				{Condition: &ExprNode{Type: TypeNumber, Value: "abc"}, Result: &ExprNode{Type: TypeNumber, Value: "1"}},
			},
		}, true},
		{"WHEN结果验证失败", &CaseExpression{
			WhenClauses: []WhenClause{
				{Condition: &ExprNode{Type: TypeField, Value: "a"}, Result: &ExprNode{Type: TypeNumber, Value: "abc"}},
			},
		}, true},
		{"ELSE结果验证失败", &CaseExpression{
			WhenClauses: []WhenClause{
				{Condition: &ExprNode{Type: TypeField, Value: "a"}, Result: &ExprNode{Type: TypeNumber, Value: "1"}},
			},
			ElseResult: &ExprNode{Type: TypeNumber, Value: "abc"},
		}, true},
		{"简单CASE的Value验证失败", &CaseExpression{
			Value: &ExprNode{Type: TypeNumber, Value: "invalid_number"},
			WhenClauses: []WhenClause{
				{Condition: &ExprNode{Type: TypeString, Value: "'test'"}, Result: &ExprNode{Type: TypeNumber, Value: "1"}},
			},
		}, true},
	}

	// 添加CaseExpr为nil的测试用例
	t.Run("CaseExpr为nil", func(t *testing.T) {
		node := &ExprNode{Type: TypeCase, CaseExpr: nil}
		err := validateCaseNode(node)
		assert.Error(t, err, "CaseExpr为nil时应该返回错误")
		assert.Contains(t, err.Error(), "CASE expression is missing")
	})

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			node := &ExprNode{Type: TypeCase, CaseExpr: tt.caseExpr}
			err := validateCaseNode(node)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "CASE节点验证不应该失败")
			}
		})
	}
}

// TestIsValidFieldName 测试字段名验证
func TestIsValidFieldName(t *testing.T) {
	tests := []struct {
		name      string
		fieldName string
		expected  bool
	}{
		// 有效情况
		{"简单字段名", "field", true},
		{"下划线开头", "_field", true},
		{"包含数字", "field123", true},
		{"驼峰命名", "fieldName", true},
		{"蛇形命名", "field_name", true},
		{"大写字段", "FIELD", true},
		{"单字符字段", "a", true},
		{"单下划线", "_", true},
		{"反引号字段", "`field name`", true},
		{"反引号包含特殊字符", "`user.name`", true},
		{"反引号包含数字开头", "`123field`", true},
		{"反引号包含连字符", "`field-name`", true},
		{"反引号包含各种符号", "`field@#$%^&*()`", true},

		// 无效情况
		{"空字段名", "", false},
		{"数字开头", "123field", false},
		{"包含连字符", "field-name", false},
		{"包含空格（无反引号）", "field name", false},
		{"包含点号（无反引号）", "field.name", false},
		{"包含特殊字符@", "field@name", false},
		{"包含特殊字符#", "field#name", false},
		{"包含特殊字符$", "field$name", false},
		{"包含特殊字符%", "field%name", false},
		{"未闭合反引号", "`field", false},
		{"空反引号", "``", false},
		{"反引号内包含反引号", "`field`name`", false},
		{"只有反引号开头", "`", false},
		{"非ASCII字符", "字段名", false},
		{"包含非ASCII字符", "field字段", false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := isValidFieldName(tt.fieldName)
			assert.Equal(t, tt.expected, result, "字段名验证结果应该正确")
		})
	}
}

// TestValidateTokens 测试标记列表验证
func TestValidateTokens(t *testing.T) {
	tests := []struct {
		name    string
		tokens  []string
		wantErr bool
	}{
		{"有效标记列表", []string{"a", "+", "b"}, false},
		{"有效函数调用", []string{"abs", "(", "x", ")"}, false},
		{"有效CASE表达式", []string{"CASE", "WHEN", "a", ">", "0", "THEN", "1", "ELSE", "0", "END"}, false},
		// 错误情况
		{"空标记列表", []string{}, true},
		{"括号不匹配", []string{"(", "a", "+", "b"}, true},
		{"连续运算符", []string{"a", "+", "+", "b"}, true},
		{"运算符开头", []string{"+", "a"}, true},
		{"运算符结尾", []string{"a", "+"}, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateTokens(tt.tokens)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "标记验证不应该失败")
			}
		})
	}
}

// TestValidateParentheses 测试括号验证
func TestValidateParentheses(t *testing.T) {
	tests := []struct {
		name    string
		tokens  []string
		wantErr bool
	}{
		{"匹配的括号", []string{"(", "a", "+", "b", ")"}, false},
		{"嵌套括号", []string{"(", "(", "a", "+", "b", ")", "*", "c", ")"}, false},
		{"函数括号", []string{"abs", "(", "x", ")"}, false},
		{"无括号", []string{"a", "+", "b"}, false},
		// 错误情况
		{"缺少右括号", []string{"(", "a", "+", "b"}, true},
		{"缺少左括号", []string{"a", "+", "b", ")"}, true},
		{"括号顺序错误", []string{")", "a", "+", "b", "("}, true},
		{"嵌套不匹配", []string{"(", "(", "a", "+", "b", ")"}, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateParentheses(tt.tokens)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "括号验证不应该失败")
			}
		})
	}
}

// TestValidateTokenOrder 测试标记顺序验证
func TestValidateTokenOrder(t *testing.T) {
	tests := []struct {
		name    string
		tokens  []string
		wantErr bool
	}{
		{"正确顺序", []string{"a", "+", "b"}, false},
		{"函数调用", []string{"abs", "(", "x", ")"}, false},
		{"复杂表达式", []string{"a", "+", "b", "*", "c"}, false},
		// 错误情况
		{"连续运算符", []string{"a", "+", "+", "b"}, true},
		{"运算符开头", []string{"+", "a"}, true},
		{"运算符结尾", []string{"a", "+"}, true},
		{"连续操作数", []string{"a", "b", "+", "c"}, true},
		{"CASE关键字组合", []string{"CASE", "WHEN", "field", "THEN", "value", "END"}, false},
		{"操作符后跟一元操作符", []string{"a", "AND", "NOT", "b"}, false},
		{"连续二元操作符", []string{"a", "+", "*", "b"}, true},
		{"以一元操作符开始", []string{"NOT", "a"}, false},
		{"以二元操作符开始", []string{"-", "a"}, true},
		{"逗号分隔的参数", []string{"func", "(", "a", ",", "b", ")"}, false},
		{"括号和操作数混合", []string{"(", "a", ")", "+", "b"}, false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateTokenOrder(tt.tokens)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "标记顺序验证不应该失败")
			}
		})
	}
}

// TestValidateSyntax 测试语法验证
func TestValidateParenthesisNode(t *testing.T) {
	tests := []struct {
		name     string
		node     *ExprNode
		wantErr  bool
		errMsg   string
	}{
		{
			name: "有效的括号表达式",
			node: &ExprNode{
				Type: TypeParenthesis,
				Left: &ExprNode{
					Type:  TypeField,
					Value: "field1",
				},
			},
			wantErr: false,
		},
		{
			name: "括号内为空",
			node: &ExprNode{
				Type: TypeParenthesis,
				Left: nil,
			},
			wantErr: true,
			errMsg:  "parenthesis node missing inner expression",
		},
		{
			name: "括号内表达式无效",
			node: &ExprNode{
				Type: TypeParenthesis,
				Left: &ExprNode{
					Type:  TypeField,
					Value: "", // 空字段名
				},
			},
			wantErr: true,
			errMsg:  "field node has empty value",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateParenthesisNode(tt.node)
			if tt.wantErr {
				if err == nil {
					t.Errorf("validateParenthesisNode() expected error, got nil")
				} else if !strings.Contains(err.Error(), tt.errMsg) {
					t.Errorf("validateParenthesisNode() error = %v, want error containing %v", err, tt.errMsg)
				}
			} else {
				if err != nil {
					t.Errorf("validateParenthesisNode() error = %v, want nil", err)
				}
			}
		})
	}
}

func TestValidateSyntax(t *testing.T) {
	tests := []struct {
		name    string
		expr    string
		wantErr bool
	}{
		// 有效表达式
		{"有效算术表达式", "a + b", false},
		{"有效函数调用", "abs(x)", false},
		{"有效CASE表达式", "CASE WHEN a > 0 THEN 1 END", false},
		{"有效比较表达式", "field >= 10", false},
		{"有效逻辑表达式", "a != b", false},
		{"有效不等于表达式", "a <> b", false},
		{"有效小于等于表达式", "a <= b", false},
		{"复杂表达式", "a + b * c", false},

		// 错误情况
		{"空表达式", "", true},
		{"只有空格", "   ", true},
		{"空括号", "()", true},
		{"括号不匹配1", "(a + b", true},
		{"括号不匹配2", "a + b)", true},
		{"连续运算符（空格分隔）", "a + + b", true},
		{"连续运算符（直接相邻）", "a+-b", true},
		{"运算符开头", "+ a + b", true},
		{"运算符结尾", "a + b +", true},
		{"乘法运算符开头", "* a + b", true},
		{"除法运算符结尾", "a + b /", true},
		{"模运算符开头", "% a + b", true},
		{"幂运算符结尾", "a + b ^", true},
		{"等号运算符开头", "= a + b", true},
		{"不等号运算符结尾", "a + b !=", true},
		{"大于号运算符开头", "> a + b", true},
		{"小于号运算符结尾", "a + b <", true},
		{"大于等于运算符开头", ">= a + b", true},
		{"小于等于运算符结尾", "a + b <=", true},
		{"不等于运算符开头", "<> a + b", true},
		{"多个连续运算符组合1", "a + * b", true},
		{"多个连续运算符组合2", "a / % b", true},
		{"多个连续运算符组合3", "a ^ + b", true},
		{"多个连续运算符组合4", "a = > b", true},
		{"多个连续运算符组合5", "a < = b", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateSyntax(tt.expr)
			if tt.wantErr {
				assert.Error(t, err, "应该返回错误")
			} else {
				assert.NoError(t, err, "语法验证不应该失败")
			}
		})
	}
}