bugfix_test.go

// SPDX-License-Identifier: Apache-2.0

// Tests for bug fixes discovered during BST Monitoring app session (2026-03-13).
package executor

import (
	"fmt"
	"strings"
	"testing"

	"github.com/mendixlabs/mxcli/mdl/ast"
	"github.com/mendixlabs/mxcli/mdl/visitor"
)

// TestValidateDuplicateVariableDeclareRetrieve verifies that DECLARE followed by
// RETRIEVE for the same variable is caught as a duplicate (CE0111).
// Bug #3: mxcli check passed but mx check reported CE0111.
func TestValidateDuplicateVariableDeclareRetrieve(t *testing.T) {
	input := `create microflow Test.MF_DuplicateVar ()
begin
  declare $Count Integer = 0;
  retrieve $Count from Test.TestItem;
  return $Count;
end;`

	errors := validateMicroflowFromMDL(t, input)

	found := false
	for _, e := range errors {
		if strings.Contains(e, "duplicate") && strings.Contains(e, "Count") {
			found = true
			break
		}
	}
	if !found {
		t.Errorf("Expected duplicate variable error for $Count, got errors: %v", errors)
	}
}

// TestValidateDuplicateVariableDeclareOnly verifies that two DECLARE statements
// for the same variable are caught as duplicate.
func TestValidateDuplicateVariableDeclareOnly(t *testing.T) {
	input := `create microflow Test.MF_DoubleDeclare ()
begin
  declare $X Integer = 0;
  declare $X String = 'hello';
end;`

	errors := validateMicroflowFromMDL(t, input)

	found := false
	for _, e := range errors {
		if strings.Contains(e, "duplicate") && strings.Contains(e, "X") {
			found = true
			break
		}
	}
	if !found {
		t.Errorf("Expected duplicate variable error for $X, got errors: %v", errors)
	}
}

// TestValidateNoDuplicateWhenRetrieveOnly verifies that a single RETRIEVE
// (without prior DECLARE) does not trigger a false positive.
func TestValidateNoDuplicateWhenRetrieveOnly(t *testing.T) {
	input := `create microflow Test.MF_RetrieveOnly ()
begin
  retrieve $Items from Test.SomeEntity;
end;`

	errors := validateMicroflowFromMDL(t, input)

	for _, e := range errors {
		if strings.Contains(e, "duplicate") {
			t.Errorf("Unexpected duplicate variable error: %s", e)
		}
	}
}

// TestValidateDuplicateVariableDeclareCreate verifies that DECLARE followed by
// CREATE for the same variable is caught as a duplicate (CE0111).
func TestValidateDuplicateVariableDeclareCreate(t *testing.T) {
	input := `create microflow Test.MF_DeclareCreate ()
begin
  declare $NewTodo Test.Todo;
  $NewTodo = create Test.Todo();
end;`

	errors := validateMicroflowFromMDL(t, input)

	found := false
	for _, e := range errors {
		if strings.Contains(e, "duplicate") && strings.Contains(e, "NewTodo") {
			found = true
			break
		}
	}
	if !found {
		t.Errorf("Expected duplicate variable error for $NewTodo, got errors: %v", errors)
	}
}

// TestValidateEntityReservedAttributeName verifies that persistent entity attributes
// using reserved system names (CreatedDate, ChangedDate, Owner, ChangedBy) are caught.
func TestValidateEntityReservedAttributeName(t *testing.T) {
	input := `create persistent entity Test.MyEntity (
  Name : String(200),
  CreatedDate : DateTime,
  Status : String(50)
);`

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	stmt, ok := prog.Statements[0].(*ast.CreateEntityStmt)
	if !ok {
		t.Fatalf("Expected CreateEntityStmt, got %T", prog.Statements[0])
	}

	violations := ValidateEntity(stmt)
	found := false
	for _, v := range violations {
		if strings.Contains(v.Message, "CreatedDate") && strings.Contains(v.Message, "system attribute") {
			found = true
			break
		}
	}
	if !found {
		t.Errorf("Expected reserved attribute error for CreatedDate, got: %v", violations)
	}
}

// TestValidateEntityNonPersistentAllowed verifies that non-persistent entities
// can use system attribute names without error.
func TestValidateEntityNonPersistentAllowed(t *testing.T) {
	input := `create non-persistent entity Test.MyNPE (
  CreatedDate : DateTime,
  Owner : String(200)
);`

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	stmt, ok := prog.Statements[0].(*ast.CreateEntityStmt)
	if !ok {
		t.Fatalf("Expected CreateEntityStmt, got %T", prog.Statements[0])
	}

	violations := ValidateEntity(stmt)
	if len(violations) > 0 {
		t.Errorf("Non-persistent entity should allow system attribute names, got: %v", violations)
	}
}

// TestValidateEntityNormalAttributesPass verifies that normal attribute names
// don't trigger false positives.
func TestValidateEntityNormalAttributesPass(t *testing.T) {
	input := `create persistent entity Test.MyEntity (
  Name : String(200),
  Description : String(2000),
  Amount : Decimal,
  IsActive : Boolean
);`

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	stmt, ok := prog.Statements[0].(*ast.CreateEntityStmt)
	if !ok {
		t.Fatalf("Expected CreateEntityStmt, got %T", prog.Statements[0])
	}

	violations := ValidateEntity(stmt)
	if len(violations) > 0 {
		t.Errorf("Normal attributes should not trigger errors, got: %v", violations)
	}
}

// TestReturnsNothingAcceptsBarReturn verifies that RETURNS Nothing treats
// RETURN; (no value) as valid — "Nothing" means void.
func TestReturnsNothingAcceptsBarReturn(t *testing.T) {
	input := `create microflow Test.MF_ReturnsNothing ()
returns Nothing
begin
  log info 'hello';
  return;
end;`

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	stmt := prog.Statements[0].(*ast.CreateMicroflowStmt)

	// The return type should be TypeVoid
	if stmt.ReturnType != nil && stmt.ReturnType.Type.Kind != ast.TypeVoid {
		t.Errorf("Expected TypeVoid for returns Nothing, got %v", stmt.ReturnType.Type.Kind)
	}

	// Validation should NOT produce errors about RETURN requiring a value
	warnings := ValidateMicroflowBody(stmt)
	for _, w := range warnings {
		if strings.Contains(w, "return requires a value") {
			t.Errorf("returns Nothing should not reject bare return;, got: %s", w)
		}
	}
}

// TestEnumDefaultNotDoubleQualified verifies that enum DEFAULT values are stored
// without the enum prefix (just the value name), preventing double-qualification.
func TestEnumDefaultNotDoubleQualified(t *testing.T) {
	input := `create persistent entity Test.Item (
  Status : Enumeration(Test.ItemStatus) default Test.ItemStatus.Active
);`

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	stmt := prog.Statements[0].(*ast.CreateEntityStmt)
	if len(stmt.Attributes) == 0 {
		t.Fatal("Expected at least 1 attribute")
	}

	attr := stmt.Attributes[0]
	if !attr.HasDefault {
		t.Fatal("Expected attribute to have a default value")
	}

	// The default value from the parser is the full text "Test.ItemStatus.Active"
	defaultStr := fmt.Sprintf("%v", attr.DefaultValue)
	// When stored, it should be stripped to just "Active" (the executor does this)
	// Here we verify the parser at least captures the full text correctly
	if !strings.Contains(defaultStr, "Active") {
		t.Errorf("Default value should contain 'Active', got: %s", defaultStr)
	}
}

// TestExpressionToXPath_TokenQuoting verifies that [%CurrentDateTime%] tokens
// are unquoted in XPath context (Mendix special placeholders, not string literals).
// Quoting them causes CE0161 (XPath parse error) in Studio Pro.
func TestExpressionToXPath_TokenQuoting(t *testing.T) {
	tests := []struct {
		name     string
		expr     ast.Expression
		wantExpr string // expressionToString output
		wantXP   string // expressionToXPath output
	}{
		{
			name:     "Token_CurrentDateTime",
			expr:     &ast.TokenExpr{Token: "CurrentDateTime"},
			wantExpr: "[%CurrentDateTime%]",
			wantXP:   "'[%CurrentDateTime%]'",
		},
		{
			name:     "Token_CurrentUser",
			expr:     &ast.TokenExpr{Token: "CurrentUser"},
			wantExpr: "[%CurrentUser%]",
			wantXP:   "'[%CurrentUser%]'",
		},
		{
			name: "BinaryExpr_with_token",
			expr: &ast.BinaryExpr{
				Left:     &ast.IdentifierExpr{Name: "DueDate"},
				Operator: "<",
				Right:    &ast.TokenExpr{Token: "CurrentDateTime"},
			},
			wantExpr: "DueDate < [%CurrentDateTime%]",
			wantXP:   "DueDate < '[%CurrentDateTime%]'",
		},
		{
			name:     "Variable_unchanged",
			expr:     &ast.VariableExpr{Name: "MyVar"},
			wantExpr: "$MyVar",
			wantXP:   "$MyVar",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotExpr := expressionToString(tt.expr)
			if gotExpr != tt.wantExpr {
				t.Errorf("expressionToString() = %q, want %q", gotExpr, tt.wantExpr)
			}
			gotXP := expressionToXPath(tt.expr)
			if gotXP != tt.wantXP {
				t.Errorf("expressionToXPath() = %q, want %q", gotXP, tt.wantXP)
			}
		})
	}
}

// TestExpressionToXPath_XPathPathExpr verifies that XPathPathExpr (bare association paths,
// nested predicates) serialize correctly via expressionToXPath.
func TestExpressionToXPath_XPathPathExpr(t *testing.T) {
	tests := []struct {
		name   string
		expr   ast.Expression
		wantXP string
	}{
		{
			name: "bare_association_path",
			expr: &ast.XPathPathExpr{
				Steps: []ast.XPathStep{
					{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "Module", Name: "Assoc"}}},
					{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "Module", Name: "Entity"}}},
					{Expr: &ast.IdentifierExpr{Name: "Attr"}},
				},
			},
			wantXP: "Module.Assoc/Module.Entity/Attr",
		},
		{
			name: "path_with_nested_predicate",
			expr: &ast.XPathPathExpr{
				Steps: []ast.XPathStep{
					{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "Sys", Name: "roles"}}},
					{
						Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "Sys", Name: "UserRole"}},
						Predicate: &ast.BinaryExpr{
							Left:     &ast.IdentifierExpr{Name: "Active"},
							Operator: "=",
							Right:    &ast.LiteralExpr{Value: true, Kind: ast.LiteralBoolean},
						},
					},
				},
			},
			wantXP: "Sys.roles/Sys.UserRole[Active = true]",
		},
		{
			name: "path_with_reversed",
			expr: &ast.XPathPathExpr{
				Steps: []ast.XPathStep{
					{
						Expr:      &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "System", Name: "roles"}},
						Predicate: &ast.FunctionCallExpr{Name: "reversed"},
					},
					{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "System", Name: "UserRole"}}},
				},
			},
			wantXP: "System.roles[reversed()]/System.UserRole",
		},
		{
			name: "comparison_with_path_and_token",
			expr: &ast.BinaryExpr{
				Left: &ast.XPathPathExpr{
					Steps: []ast.XPathStep{
						{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "System", Name: "owner"}}},
					},
				},
				Operator: "=",
				Right:    &ast.TokenExpr{Token: "CurrentUser"},
			},
			wantXP: "System.owner = '[%CurrentUser%]'",
		},
		{
			name: "not_with_path",
			expr: &ast.UnaryExpr{
				Operator: "not",
				Operand: &ast.XPathPathExpr{
					Steps: []ast.XPathStep{
						{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "Module", Name: "Assoc"}}},
						{Expr: &ast.QualifiedNameExpr{QualifiedName: ast.QualifiedName{Module: "Module", Name: "Entity"}}},
					},
				},
			},
			wantXP: "not(Module.Assoc/Module.Entity)",
		},
		{
			name: "function_with_path_args",
			expr: &ast.FunctionCallExpr{
				Name: "contains",
				Arguments: []ast.Expression{
					&ast.IdentifierExpr{Name: "Name"},
					&ast.VariableExpr{Name: "SearchStr"},
				},
			},
			wantXP: "contains(Name, $SearchStr)",
		},
		{
			name:   "empty_literal",
			expr:   &ast.LiteralExpr{Value: nil, Kind: ast.LiteralEmpty},
			wantXP: "empty",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotXP := expressionToXPath(tt.expr)
			if gotXP != tt.wantXP {
				t.Errorf("expressionToXPath() = %q, want %q", gotXP, tt.wantXP)
			}
		})
	}
}

// validateMicroflowFromMDL parses a CREATE MICROFLOW statement and runs
// ValidateMicroflowBody, returning any validation errors.
func validateMicroflowFromMDL(t *testing.T, input string) []string {
	t.Helper()

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	if len(prog.Statements) == 0 {
		t.Fatal("No statements parsed")
	}

	stmt, ok := prog.Statements[0].(*ast.CreateMicroflowStmt)
	if !ok {
		t.Fatalf("Expected CreateMicroflowStmt, got %T", prog.Statements[0])
	}

	return ValidateMicroflowBody(stmt)
}

// TestAssociationNavParsing verifies that $Var/Module.Assoc/Attr parses as
// AttributePathExpr (not nested BinaryExpr with "/" operator).
// Issue #120: extra spaces around path separators.
func TestAssociationNavParsing(t *testing.T) {
	input := `create microflow Test.MF_Nav()
returns String as $Result
begin
  declare $CustName String = $Order/Test.Order_Customer/Name;
  return $CustName;
end;`

	prog, errs := visitor.Build(input)
	if len(errs) > 0 {
		t.Fatalf("Parse error: %v", errs[0])
	}

	stmt := prog.Statements[0].(*ast.CreateMicroflowStmt)
	declStmt := stmt.Body[0].(*ast.DeclareStmt)

	// The expression should be an AttributePathExpr, not a BinaryExpr
	pathExpr, ok := declStmt.InitialValue.(*ast.AttributePathExpr)
	if !ok {
		t.Fatalf("Expected AttributePathExpr, got %T", declStmt.InitialValue)
	}

	if pathExpr.Variable != "Order" {
		t.Errorf("Variable = %q, want %q", pathExpr.Variable, "Order")
	}
	if len(pathExpr.Path) != 2 {
		t.Fatalf("Path length = %d, want 2", len(pathExpr.Path))
	}
	if pathExpr.Path[0] != "Test.Order_Customer" {
		t.Errorf("Path[0] = %q, want %q", pathExpr.Path[0], "Test.Order_Customer")
	}
	if pathExpr.Path[1] != "Name" {
		t.Errorf("Path[1] = %q, want %q", pathExpr.Path[1], "Name")
	}

	// Serialized form should have no extra spaces
	got := expressionToString(pathExpr)
	want := "$Order/Test.Order_Customer/Name"
	if got != want {
		t.Errorf("expressionToString() = %q, want %q", got, want)
	}
}

// TestResolveAssociationPaths verifies that resolveAssociationPaths inserts
// the target entity after an association segment.
// Issue #120: missing target entity qualifier.
func TestResolveAssociationPaths(t *testing.T) {
	tests := []struct {
		name string
		path []string
		want []string
	}{
		{
			name: "simple_attribute",
			path: []string{"Name"},
			want: []string{"Name"},
		},
		{
			name: "assoc_then_attr",
			path: []string{"Test.Order_Customer", "Name"},
			want: []string{"Test.Order_Customer", "Test.Customer", "Name"},
		},
		{
			name: "already_has_target_entity",
			path: []string{"Test.Order_Customer", "Test.Customer", "Name"},
			want: []string{"Test.Order_Customer", "Test.Customer", "Name"},
		},
		{
			name: "assoc_at_end",
			path: []string{"Test.Order_Customer"},
			want: []string{"Test.Order_Customer"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			fb := &flowBuilder{
				backend: nil, // nil backend → no resolution, path unchanged
			}
			got := fb.resolvePathSegments(tt.path)

			// With nil reader, all paths should be unchanged
			if len(got) != len(tt.path) {
				t.Errorf("resolvePathSegments() length = %d, want %d", len(got), len(tt.path))
			}
		})
	}
}

func TestResolveAssociationPathsUnwrapsEmptySourceExpr(t *testing.T) {
	fb := &flowBuilder{}
	resolved := fb.resolveAssociationPaths(&ast.SourceExpr{
		Expression: &ast.VariableExpr{Name: "CurrentObject"},
	})

	if _, ok := resolved.(*ast.SourceExpr); ok {
		t.Fatalf("empty SourceExpr should unwrap to resolved inner expression, got %T", resolved)
	}
	if got := expressionToString(resolved); got != "$CurrentObject" {
		t.Fatalf("resolved expression = %q, want $CurrentObject", got)
	}
}

func TestResolveAssociationPathsKeepsNonEmptySourceExprVerbatim(t *testing.T) {
	source := "$CurrentObject/Module.Assoc/Name\n"
	fb := &flowBuilder{}
	resolved := fb.resolveAssociationPaths(&ast.SourceExpr{
		Expression: &ast.AttributePathExpr{
			Variable: "CurrentObject",
			Path:     []string{"Module.Assoc", "Name"},
		},
		Source: source,
	})

	sourceExpr, ok := resolved.(*ast.SourceExpr)
	if !ok {
		t.Fatalf("non-empty SourceExpr should remain SourceExpr, got %T", resolved)
	}
	if sourceExpr.Source != source {
		t.Fatalf("source = %q, want %q", sourceExpr.Source, source)
	}
}

// TestExprToStringNoSpaces verifies that association navigation expressions
// produce no extra spaces around separators after parsing.
// Issue #120: generated $Order / Module.Assoc / Name instead of $Order/Module.Assoc/Name
func TestExprToStringNoSpaces(t *testing.T) {
	tests := []struct {
		name string
		expr ast.Expression
		want string
	}{
		{
			name: "simple_path",
			expr: &ast.AttributePathExpr{
				Variable: "Order",
				Path:     []string{"OrderNumber"},
			},
			want: "$Order/OrderNumber",
		},
		{
			name: "assoc_path",
			expr: &ast.AttributePathExpr{
				Variable: "Order",
				Path:     []string{"Test.Order_Customer", "Name"},
			},
			want: "$Order/Test.Order_Customer/Name",
		},
		{
			name: "multi_segment_path",
			expr: &ast.AttributePathExpr{
				Variable: "Invoice",
				Path:     []string{"Billing.Invoice_Order", "Billing.Order_Customer", "Name"},
			},
			want: "$Invoice/Billing.Invoice_Order/Billing.Order_Customer/Name",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := expressionToString(tt.expr)
			if got != tt.want {
				t.Errorf("expressionToString() = %q, want %q", got, tt.want)
			}
		})
	}
}