package utpl

import (
	"errors"
	"fmt"
	"strings"
	"testing"
)

// ---------- 1. TestInclude — @include directive ----------
//
// NOTE: The current implementation creates IncludeNode during parsing but does
// not expand included content inline. The IncludeManager is constructed but never
// invoked. These tests document the actual behavior. When include expansion is
// fully wired up (content resolved before lexing), these tests should be updated
// to verify full inline expansion.

func TestInclude(t *testing.T) {
	t.Run("include node parses without error when resolver configured", func(t *testing.T) {
		resolver := func(path string) (string, error) {
			files := map[string]string{
				"common/tenant": "AND tenant_id = #{tenant_id}",
			}
			src, ok := files[path]
			if !ok {
				return "", fmt.Errorf("not found: %s", path)
			}
			return src, nil
		}
		src := `SELECT * FROM orders WHERE 1=1 @include("common/tenant")`
		_, err := New(WithIncludeResolver(resolver)).Parse("test", src)
		if err != nil {
			t.Fatalf("parse should succeed, got: %v", err)
		}
	})

	t.Run("include without resolver returns error", func(t *testing.T) {
		src := `SELECT 1 @include("anything")`
		_, err := New().Parse("test", src)
		if err == nil {
			t.Fatal("expected error when @include used without resolver")
		}
	})

	t.Run("include content is expanded in output", func(t *testing.T) {
		resolver := func(path string) (string, error) {
			if path == "x" {
				return "RESOLVED_CONTENT", nil
			}
			return "", fmt.Errorf("not found: %s", path)
		}
		src := `BEFORE @include("x") AFTER`
		tpl, _ := New(WithIncludeResolver(resolver)).Parse("test", src)
		r, err := tpl.Execute(nil)
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if !strings.Contains(r.SQL, "RESOLVED_CONTENT") {
			t.Errorf("SQL = %q, should contain resolved content", r.SQL)
		}
		if !strings.Contains(r.SQL, "BEFORE") || !strings.Contains(r.SQL, "AFTER") {
			t.Errorf("SQL = %q, should contain BEFORE and AFTER text", r.SQL)
		}
	})

	t.Run("include with resolver error fails at parse", func(t *testing.T) {
		resolver := func(path string) (string, error) {
			return "", fmt.Errorf("not found: %s", path)
		}
		src := `SELECT 1 @include("nonexistent")`
		_, err := New(WithIncludeResolver(resolver)).Parse("test", src)
		if err == nil {
			t.Fatal("expected error when include resolver fails")
		}
	})
}

// ---------- 2. TestElseIf — else if / else branches ----------

func TestElseIf(t *testing.T) {
	t.Run("if with else branch", func(t *testing.T) {
		src := "@if(x == 1) {ONE} else {OTHER}"
		tests := []struct {
			val  any
			want string
		}{
			{1, "ONE"},
			{2, "OTHER"},
			{99, "OTHER"},
		}
		for _, tc := range tests {
			tpl, _ := New().Parse("test", src)
			r, err := tpl.Execute(map[string]any{"x": tc.val})
			if err != nil {
				t.Fatalf("x=%v: %v", tc.val, err)
			}
			if !strings.Contains(r.SQL, tc.want) {
				t.Errorf("x=%v: SQL = %q, want to contain %q", tc.val, r.SQL, tc.want)
			}
		}
	})

	t.Run("if else if else chain", func(t *testing.T) {
		src := `@if(role == "admin") {ADMIN} else if (role == "manager") {MGR} else {OTHER}`
		tests := []struct {
			role string
			want string
		}{
			{"admin", "ADMIN"},
			{"manager", "MGR"},
			{"guest", "OTHER"},
			{"other", "OTHER"},
		}
		for _, tc := range tests {
			tpl, _ := New().Parse("test", src)
			r, err := tpl.Execute(map[string]any{"role": tc.role})
			if err != nil {
				t.Fatalf("role=%q: %v", tc.role, err)
			}
			if !strings.Contains(r.SQL, tc.want) {
				t.Errorf("role=%q: SQL = %q, want to contain %q", tc.role, r.SQL, tc.want)
			}
		}
	})

	t.Run("multiple else if branches", func(t *testing.T) {
		src := `@if(x == 1) {ONE} else if (x == 2) {TWO} else if (x == 3) {THREE} else {OTHER}`
		tests := []struct {
			val  any
			want string
		}{
			{1, "ONE"},
			{2, "TWO"},
			{3, "THREE"},
			{99, "OTHER"},
		}
		for _, tc := range tests {
			tpl, _ := New().Parse("test", src)
			r, err := tpl.Execute(map[string]any{"x": tc.val})
			if err != nil {
				t.Fatalf("x=%v: %v", tc.val, err)
			}
			if !strings.Contains(r.SQL, tc.want) {
				t.Errorf("x=%v: SQL = %q, want to contain %q", tc.val, r.SQL, tc.want)
			}
		}
	})

	t.Run("else if without final else", func(t *testing.T) {
		src := `@if(x == 1) {ONE} else if (x == 2) {TWO}`
		tests := []struct {
			val   any
			want  string
			found bool
		}{
			{1, "ONE", true},
			{2, "TWO", true},
			{99, "", false},
		}
		for _, tc := range tests {
			tpl, _ := New().Parse("test", src)
			r, err := tpl.Execute(map[string]any{"x": tc.val})
			if err != nil {
				t.Fatalf("x=%v: %v", tc.val, err)
			}
			if tc.found && !strings.Contains(r.SQL, tc.want) {
				t.Errorf("x=%v: SQL = %q, want to contain %q", tc.val, r.SQL, tc.want)
			}
			if !tc.found && r.SQL != "" {
				t.Errorf("x=%v: SQL = %q, want empty", tc.val, r.SQL)
			}
		}
	})

	t.Run("else if with params in branches", func(t *testing.T) {
		src := `@if(role == "admin") {level = #{admin_level}} else if (role == "manager") {level = #{mgr_level}} else {level = #{default_level}}`
		tests := []struct {
			role   string
			want   string
			argVal any
		}{
			{"admin", "level = ?", 10},
			{"manager", "level = ?", 5},
			{"guest", "level = ?", 1},
		}
		for _, tc := range tests {
			tpl, parseErr := New().Parse("test", src)
			if parseErr != nil {
				t.Fatalf("role=%q: parse failed: %v", tc.role, parseErr)
			}
			r, err := tpl.Execute(map[string]any{
				"role":          tc.role,
				"admin_level":   10,
				"mgr_level":     5,
				"default_level": 1,
			})
			if err != nil {
				t.Fatalf("role=%q: %v", tc.role, err)
			}
			if !strings.Contains(r.SQL, tc.want) {
				t.Errorf("role=%q: SQL = %q, want to contain %q", tc.role, r.SQL, tc.want)
			}
			if len(r.Args) != 1 || r.Args[0] != tc.argVal {
				t.Errorf("role=%q: Args = %v, want [%v]", tc.role, r.Args, tc.argVal)
			}
		}
	})

	t.Run("else if with no space before paren", func(t *testing.T) {
		src := "@if(x == 1) {ONE} else if(x == 2) {TWO} else {OTHER}"
		tests := []struct {
			val  any
			want string
		}{
			{1, "ONE"},
			{2, "TWO"},
			{99, "OTHER"},
		}
		for _, tc := range tests {
			tpl, _ := New().Parse("test", src)
			r, err := tpl.Execute(map[string]any{"x": tc.val})
			if err != nil {
				t.Fatalf("x=%v: %v", tc.val, err)
			}
			if !strings.Contains(r.SQL, tc.want) {
				t.Errorf("x=%v: SQL = %q, want to contain %q", tc.val, r.SQL, tc.want)
			}
		}
	})

	t.Run("else if with multiline SQL", func(t *testing.T) {
		src := `SELECT * FROM users WHERE 1=1
@if(role == "admin") {
  AND level >= #{admin_level}
} else if (role == "manager") {
  AND level >= #{mgr_level}
} else {
  AND level >= 1
}`
		r := exec(t, src, map[string]any{
			"role":        "manager",
			"admin_level": 10,
			"mgr_level":   5,
		})
		if !strings.Contains(r.SQL, "AND level >= ?") {
			t.Errorf("SQL = %q, want 'AND level >= ?'", r.SQL)
		}
		if len(r.Args) != 1 || r.Args[0] != 5 {
			t.Errorf("Args = %v, want [5]", r.Args)
		}

		r2 := exec(t, src, map[string]any{
			"role":        "admin",
			"admin_level": 10,
			"mgr_level":   5,
		})
		if !strings.Contains(r2.SQL, "AND level >= ?") {
			t.Errorf("SQL = %q, want 'AND level >= ?'", r2.SQL)
		}
		if len(r2.Args) != 1 || r2.Args[0] != 10 {
			t.Errorf("Args = %v, want [10]", r2.Args)
		}

		r3 := exec(t, src, map[string]any{
			"role":        "guest",
			"admin_level": 10,
			"mgr_level":   5,
		})
		if !strings.Contains(r3.SQL, "AND level >= 1") {
			t.Errorf("SQL = %q, want 'AND level >= 1'", r3.SQL)
		}
		if len(r3.Args) != 0 {
			t.Errorf("Args = %v, want empty", r3.Args)
		}
	})

	t.Run("if without else produces no output when false", func(t *testing.T) {
		src := "@if(x == 1) {ONE}"
		tpl, _ := New().Parse("test", src)

		r, _ := tpl.Execute(map[string]any{"x": 1})
		if !strings.Contains(r.SQL, "ONE") {
			t.Errorf("x=1: SQL = %q, want ONE", r.SQL)
		}

		r2, _ := tpl.Execute(map[string]any{"x": 99})
		if strings.Contains(r2.SQL, "ONE") {
			t.Errorf("x=99: SQL = %q, should not contain ONE", r2.SQL)
		}
	})
}

// ---------- 3. TestExpression — expression edge cases ----------

func TestExpression(t *testing.T) {
	t.Run("len function with []any non-empty", func(t *testing.T) {
		r := exec(t, "@if(len(ids) > 0) {has ids}", map[string]any{"ids": []any{1, 2}})
		if !strings.Contains(r.SQL, "has ids") {
			t.Errorf("SQL = %q, want 'has ids'", r.SQL)
		}
	})

	t.Run("len function with []any empty", func(t *testing.T) {
		r := exec(t, "@if(len(ids) > 0) {has ids}", map[string]any{"ids": []any{}})
		if strings.Contains(r.SQL, "has ids") {
			t.Errorf("SQL = %q, should not contain 'has ids'", r.SQL)
		}
	})

	t.Run("len function with string", func(t *testing.T) {
		r := exec(t, "@if(len(name) > 0) {has name}", map[string]any{"name": "alice"})
		if !strings.Contains(r.SQL, "has name") {
			t.Errorf("SQL = %q, want 'has name'", r.SQL)
		}

		r2 := exec(t, "@if(len(name) > 0) {has name}", map[string]any{"name": ""})
		if strings.Contains(r2.SQL, "has name") {
			t.Errorf("SQL = %q, should not contain 'has name'", r2.SQL)
		}
	})

	t.Run("numeric comparison ge", func(t *testing.T) {
		r := exec(t, "@if(age >= 18) {adult}", map[string]any{"age": 20})
		if !strings.Contains(r.SQL, "adult") {
			t.Errorf("age=20: SQL = %q, want 'adult'", r.SQL)
		}

		r2 := exec(t, "@if(age >= 18) {adult}", map[string]any{"age": 10})
		if strings.Contains(r2.SQL, "adult") {
			t.Errorf("age=10: SQL = %q, should not contain 'adult'", r2.SQL)
		}
	})

	t.Run("boolean variable true", func(t *testing.T) {
		r := exec(t, "@if(flag) {yes}", map[string]any{"flag": true})
		if !strings.Contains(r.SQL, "yes") {
			t.Errorf("flag=true: SQL = %q, want 'yes'", r.SQL)
		}
	})

	t.Run("boolean variable false", func(t *testing.T) {
		r := exec(t, "@if(flag) {yes}", map[string]any{"flag": false})
		if strings.Contains(r.SQL, "yes") {
			t.Errorf("flag=false: SQL = %q, should not contain 'yes'", r.SQL)
		}
	})

	t.Run("negation true", func(t *testing.T) {
		r := exec(t, "@if(!flag) {no flag}", map[string]any{"flag": true})
		if strings.Contains(r.SQL, "no flag") {
			t.Errorf("flag=true: SQL = %q, should not contain 'no flag'", r.SQL)
		}
	})

	t.Run("negation false", func(t *testing.T) {
		r := exec(t, "@if(!flag) {no flag}", map[string]any{"flag": false})
		if !strings.Contains(r.SQL, "no flag") {
			t.Errorf("flag=false: SQL = %q, want 'no flag'", r.SQL)
		}
	})

	t.Run("nested dot path in condition", func(t *testing.T) {
		r := exec(t, "@if(user.active) {active}", map[string]any{
			"user": map[string]any{"active": true},
		})
		if !strings.Contains(r.SQL, "active") {
			t.Errorf("SQL = %q, want 'active'", r.SQL)
		}

		r2 := exec(t, "@if(user.active) {active}", map[string]any{
			"user": map[string]any{"active": false},
		})
		if strings.Contains(r2.SQL, "active") {
			t.Errorf("SQL = %q, should not contain 'active'", r2.SQL)
		}
	})

	t.Run("compare to nil true", func(t *testing.T) {
		r := exec(t, "@if(val == nil) {is nil}", map[string]any{"val": nil})
		if !strings.Contains(r.SQL, "is nil") {
			t.Errorf("SQL = %q, want 'is nil'", r.SQL)
		}
	})

	t.Run("compare to nil false", func(t *testing.T) {
		r := exec(t, "@if(val == nil) {is nil}", map[string]any{"val": 42})
		if strings.Contains(r.SQL, "is nil") {
			t.Errorf("SQL = %q, should not contain 'is nil'", r.SQL)
		}
	})

	t.Run("compare nil not equal true", func(t *testing.T) {
		r := exec(t, "@if(val != nil) {not nil}", map[string]any{"val": 42})
		if !strings.Contains(r.SQL, "not nil") {
			t.Errorf("SQL = %q, want 'not nil'", r.SQL)
		}
	})

	t.Run("compare nil not equal false", func(t *testing.T) {
		r := exec(t, "@if(val != nil) {not nil}", map[string]any{"val": nil})
		if strings.Contains(r.SQL, "not nil") {
			t.Errorf("SQL = %q, should not contain 'not nil'", r.SQL)
		}
	})

	t.Run("string equality comparison", func(t *testing.T) {
		r := exec(t, `@if(role == "admin") {is admin}`, map[string]any{"role": "admin"})
		if !strings.Contains(r.SQL, "is admin") {
			t.Errorf("SQL = %q, want 'is admin'", r.SQL)
		}

		r2 := exec(t, `@if(role == "admin") {is admin}`, map[string]any{"role": "user"})
		if strings.Contains(r2.SQL, "is admin") {
			t.Errorf("SQL = %q, should not contain 'is admin'", r2.SQL)
		}
	})

	t.Run("numeric less than comparison", func(t *testing.T) {
		r := exec(t, "@if(count < 100) {under limit}", map[string]any{"count": 50})
		if !strings.Contains(r.SQL, "under limit") {
			t.Errorf("SQL = %q, want 'under limit'", r.SQL)
		}

		r2 := exec(t, "@if(count < 100) {under limit}", map[string]any{"count": 150})
		if strings.Contains(r2.SQL, "under limit") {
			t.Errorf("SQL = %q, should not contain 'under limit'", r2.SQL)
		}
	})

	t.Run("and operator short circuit", func(t *testing.T) {
		// When left is false, right should not cause error even if undefined
		r := exec(t, "@if(a != nil && b != \"\") {both}",
			map[string]any{"a": nil})
		if strings.Contains(r.SQL, "both") {
			t.Errorf("SQL = %q, should not contain 'both' when a is nil", r.SQL)
		}
	})
}

// ---------- 4. TestErrorPaths — error handling ----------

func TestErrorPaths(t *testing.T) {
	t.Run("unterminated param", func(t *testing.T) {
		_, err := New().Parse("test", "SELECT #{id")
		if err == nil {
			t.Fatal("expected error for unterminated param, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
	})

	t.Run("unterminated if", func(t *testing.T) {
		_, err := New().Parse("test", "@if(x > 0")
		if err == nil {
			t.Fatal("expected error for unterminated @if, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
	})

	t.Run("unterminated for", func(t *testing.T) {
		_, err := New().Parse("test", "@for(x, range list)")
		if err == nil {
			t.Fatal("expected error for unterminated @for (missing {), got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
	})

	t.Run("empty tpl name", func(t *testing.T) {
		_, err := New().Parse("test", `@tpl("") { SELECT 1 }`)
		if err == nil {
			t.Fatal("expected error for empty @tpl name, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
		if !strings.Contains(err.Error(), "empty") {
			t.Errorf("error should mention empty: %v", err)
		}
	})

	t.Run("duplicate tpl names", func(t *testing.T) {
		_, err := New().Parse("test", `@tpl("a") {X} @tpl("a") {Y}`)
		if err == nil {
			t.Fatal("expected error for duplicate @tpl names, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
		if !strings.Contains(err.Error(), "duplicate") {
			t.Errorf("error should mention duplicate: %v", err)
		}
	})

	t.Run("namespace not at top", func(t *testing.T) {
		_, err := New().Parse("test", `SELECT 1 @namespace("x")`)
		if err == nil {
			t.Fatal("expected error for @namespace not at top, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
		if !strings.Contains(err.Error(), "top") {
			t.Errorf("error should mention top: %v", err)
		}
	})

	t.Run("tpl nested inside tpl", func(t *testing.T) {
		_, err := New().Parse("test", `@tpl("a") { @tpl("b") {X} }`)
		if err == nil {
			t.Fatal("expected error for nested @tpl, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
		if !strings.Contains(err.Error(), "nested") {
			t.Errorf("error should mention nested: %v", err)
		}
	})

	t.Run("undefined variable in strict mode", func(t *testing.T) {
		tpl, _ := New(WithStrictMode(true)).Parse("test", "SELECT #{missing}")
		_, err := tpl.Execute(map[string]any{})
		if err == nil {
			t.Fatal("expected error for undefined variable in strict mode")
		}
		// The executor returns a plain error (not wrapped in ExecError)
		if !strings.Contains(err.Error(), "undefined") {
			t.Errorf("error should mention undefined: %v", err)
		}
	})

	t.Run("for with non-slice value", func(t *testing.T) {
		tpl, err := New().Parse("test", "SELECT @for(x, range items) {#{x}, }")
		if err != nil {
			t.Fatalf("parse failed: %v", err)
		}
		_, err = tpl.Execute(map[string]any{"items": "not a slice"})
		if err == nil {
			t.Fatal("expected error for non-slice in @for, got nil")
		}
		if !strings.Contains(err.Error(), "slice") {
			t.Errorf("error should mention slice: %v", err)
		}
	})

	t.Run("unterminated raw param", func(t *testing.T) {
		_, err := New().Parse("test", "SELECT ${col")
		if err == nil {
			t.Fatal("expected error for unterminated raw param, got nil")
		}
		var parseErr *ParseError
		if !errors.As(err, &parseErr) {
			t.Errorf("expected ParseError, got %T: %v", err, err)
		}
	})
}

// ---------- 5. TestEdgeCases — boundary conditions ----------

func TestEdgeCases(t *testing.T) {
	t.Run("empty template", func(t *testing.T) {
		r := exec(t, "", nil)
		if r.SQL != "" {
			t.Errorf("SQL = %q, want empty", r.SQL)
		}
		if len(r.Args) != 0 {
			t.Errorf("Args = %v, want empty", r.Args)
		}
	})

	t.Run("pure text", func(t *testing.T) {
		r := exec(t, "SELECT 1", nil)
		if r.SQL != "SELECT 1" {
			t.Errorf("SQL = %q, want %q", r.SQL, "SELECT 1")
		}
		if len(r.Args) != 0 {
			t.Errorf("Args = %v, want empty", r.Args)
		}
	})

	t.Run("only comments", func(t *testing.T) {
		r := exec(t, "# comment", nil)
		if r.SQL != "" {
			t.Errorf("SQL = %q, want empty", r.SQL)
		}
		if len(r.Args) != 0 {
			t.Errorf("Args = %v, want empty", r.Args)
		}
	})

	t.Run("multiple consecutive comments", func(t *testing.T) {
		r := exec(t, "# line1\n# line2\nSELECT 1", nil)
		if r.SQL != "SELECT 1" {
			t.Errorf("SQL = %q, want %q", r.SQL, "SELECT 1")
		}
	})

	t.Run("mixed params and raw", func(t *testing.T) {
		r := exec(t, "SELECT ${col} FROM t WHERE id = #{id}",
			map[string]any{"col": "name", "id": 1})
		if !strings.Contains(r.SQL, "SELECT name FROM t WHERE id = ?") {
			t.Errorf("SQL = %q, want 'SELECT name FROM t WHERE id = ?'", r.SQL)
		}
		if len(r.Args) != 1 || r.Args[0] != 1 {
			t.Errorf("Args = %v, want [1]", r.Args)
		}
	})

	t.Run("nested if both true", func(t *testing.T) {
		r := exec(t, "@if(a) { @if(b) {both} }",
			map[string]any{"a": true, "b": true})
		if !strings.Contains(r.SQL, "both") {
			t.Errorf("SQL = %q, want 'both'", r.SQL)
		}
	})

	t.Run("nested if inner false", func(t *testing.T) {
		r := exec(t, "@if(a) { @if(b) {both} }",
			map[string]any{"a": true, "b": false})
		if strings.Contains(r.SQL, "both") {
			t.Errorf("SQL = %q, should not contain 'both'", r.SQL)
		}
	})

	t.Run("nested if outer false", func(t *testing.T) {
		r := exec(t, "@if(a) { @if(b) {both} }",
			map[string]any{"a": false, "b": true})
		if strings.Contains(r.SQL, "both") {
			t.Errorf("SQL = %q, should not contain 'both'", r.SQL)
		}
	})

	t.Run("if with parenthesized expression", func(t *testing.T) {
		src := "@if((a || b) && c) {yes}"
		tpl, _ := New().Parse("test", src)

		r, _ := tpl.Execute(map[string]any{"a": true, "b": false, "c": true})
		if !strings.Contains(r.SQL, "yes") {
			t.Errorf("a=true,b=false,c=true: SQL = %q, want 'yes'", r.SQL)
		}

		r, _ = tpl.Execute(map[string]any{"a": false, "b": true, "c": true})
		if !strings.Contains(r.SQL, "yes") {
			t.Errorf("a=false,b=true,c=true: SQL = %q, want 'yes'", r.SQL)
		}

		r, _ = tpl.Execute(map[string]any{"a": false, "b": false, "c": true})
		if strings.Contains(r.SQL, "yes") {
			t.Errorf("a=false,b=false,c=true: SQL = %q, should not contain 'yes'", r.SQL)
		}

		r, _ = tpl.Execute(map[string]any{"a": true, "b": true, "c": false})
		if strings.Contains(r.SQL, "yes") {
			t.Errorf("a=true,b=true,c=false: SQL = %q, should not contain 'yes'", r.SQL)
		}
	})

	t.Run("for with index variable", func(t *testing.T) {
		r := exec(t, "@for(i, v range items) {#{i}:#{v}, }",
			map[string]any{"items": []any{"x", "y", "z"}})
		if len(r.Args) != 6 {
			t.Fatalf("Args = %v, want 6 args (3 indices + 3 values)", r.Args)
		}
		// Indices: 0, 1, 2
		if r.Args[0] != 0 || r.Args[2] != 1 || r.Args[4] != 2 {
			t.Errorf("index args wrong: %v", r.Args)
		}
		// Values: x, y, z
		if r.Args[1] != "x" || r.Args[3] != "y" || r.Args[5] != "z" {
			t.Errorf("value args wrong: %v", r.Args)
		}
	})

	t.Run("comment does not interfere with param", func(t *testing.T) {
		// #{param} starts with # but is not a comment
		r := exec(t, "SELECT #{id}\n# real comment",
			map[string]any{"id": 42})
		if !strings.Contains(r.SQL, "SELECT ?") {
			t.Errorf("SQL = %q, want 'SELECT ?'", r.SQL)
		}
		if len(r.Args) != 1 || r.Args[0] != 42 {
			t.Errorf("Args = %v, want [42]", r.Args)
		}
	})

	t.Run("raw with numeric value", func(t *testing.T) {
		r := exec(t, "SELECT ${n}", map[string]any{"n": 123})
		if !strings.Contains(r.SQL, "SELECT 123") {
			t.Errorf("SQL = %q, want 'SELECT 123'", r.SQL)
		}
	})

	t.Run("multiple consecutive params", func(t *testing.T) {
		r := exec(t, "INSERT INTO t (a, b, c) VALUES (#{a}, #{b}, #{c})",
			map[string]any{"a": 1, "b": 2, "c": 3})
		if !strings.Contains(r.SQL, "?, ?, ?") {
			t.Errorf("SQL = %q, want three placeholders", r.SQL)
		}
		if len(r.Args) != 3 {
			t.Errorf("Args = %v, want 3", r.Args)
		}
	})
}

// ---------- 6. TestMultiline — real SQL with line breaks ----------

func TestMultiline(t *testing.T) {
	t.Run("full SELECT with multiple lines", func(t *testing.T) {
		src := `SELECT u.id, u.name, u.email
FROM users u
WHERE u.status = #{status}
  @if(name != "") { AND u.name LIKE #{name} }
ORDER BY u.id DESC
LIMIT #{limit}`
		tpl, err := New().Parse("test", src)
		if err != nil {
			t.Fatalf("parse failed: %v", err)
		}
		r, err := tpl.Execute(map[string]any{
			"status": "active",
			"name":   "%alice%",
			"limit":  10,
		})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}

		if !strings.Contains(r.SQL, "SELECT u.id, u.name, u.email") {
			t.Errorf("SQL missing SELECT: %q", r.SQL)
		}
		if !strings.Contains(r.SQL, "FROM users u") {
			t.Errorf("SQL missing FROM: %q", r.SQL)
		}
		if !strings.Contains(r.SQL, "WHERE u.status = ?") {
			t.Errorf("SQL missing WHERE: %q", r.SQL)
		}
		if !strings.Contains(r.SQL, "AND u.name LIKE ?") {
			t.Errorf("SQL missing name condition: %q", r.SQL)
		}
		if !strings.Contains(r.SQL, "ORDER BY u.id DESC") {
			t.Errorf("SQL missing ORDER BY: %q", r.SQL)
		}
		if !strings.Contains(r.SQL, "LIMIT ?") {
			t.Errorf("SQL missing LIMIT: %q", r.SQL)
		}
		if len(r.Args) != 3 || r.Args[0] != "active" || r.Args[1] != "%alice%" || r.Args[2] != 10 {
			t.Errorf("Args = %v, want [active %%alice%% 10]", r.Args)
		}
	})

	t.Run("line breaks preserved", func(t *testing.T) {
		src := "SELECT id\nFROM users\nWHERE id = #{id}"
		r := exec(t, src, map[string]any{"id": 1})
		lines := strings.Split(r.SQL, "\n")
		if len(lines) < 3 {
			t.Errorf("SQL = %q, want at least 3 lines", r.SQL)
		}
		if !strings.Contains(r.SQL, "SELECT id\nFROM users\nWHERE id = ?") {
			t.Errorf("SQL = %q, line breaks not preserved", r.SQL)
		}
	})

	t.Run("multiline dynamic update", func(t *testing.T) {
		src := `UPDATE users SET
  @if(name != nil) { name = #{name}, }
  @if(email != nil) { email = #{email}, }
  updated_at = NOW()
WHERE id = #{id}`
		r := exec(t, src, map[string]any{"name": "alice", "email": nil, "id": 1})
		if !strings.Contains(r.SQL, "name = ?") {
			t.Errorf("SQL missing name: %q", r.SQL)
		}
		if strings.Contains(r.SQL, "email = ?") {
			t.Errorf("SQL should not contain email: %q", r.SQL)
		}
		if !strings.Contains(r.SQL, "WHERE id = ?") {
			t.Errorf("SQL missing WHERE: %q", r.SQL)
		}
		if len(r.Args) != 2 {
			t.Errorf("Args = %v, want 2 args", r.Args)
		}
	})
}

// ---------- 7. TestExecuteString — convenience methods ----------

func TestExecuteString(t *testing.T) {
	t.Run("ExecuteString returns SQL only", func(t *testing.T) {
		tpl, err := New().Parse("test", "SELECT * FROM users WHERE id = #{id}")
		if err != nil {
			t.Fatalf("parse failed: %v", err)
		}
		sql, err := tpl.ExecuteString(map[string]any{"id": 42})
		if err != nil {
			t.Fatalf("ExecuteString failed: %v", err)
		}
		if sql != "SELECT * FROM users WHERE id = ?" {
			t.Errorf("SQL = %q, want %q", sql, "SELECT * FROM users WHERE id = ?")
		}
	})

	t.Run("ExecuteBlockString returns SQL only", func(t *testing.T) {
		tpl, err := New().Parse("test", "@tpl(\"search\") {\nSELECT * FROM orders WHERE id = #{id}\n}")
		if err != nil {
			t.Fatalf("parse failed: %v", err)
		}
		sql, err := tpl.ExecuteBlockString("search", map[string]any{"id": 7})
		if err != nil {
			t.Fatalf("ExecuteBlockString failed: %v", err)
		}
		if !strings.Contains(sql, "SELECT * FROM orders WHERE id = ?") {
			t.Errorf("SQL = %q, want to contain 'SELECT * FROM orders WHERE id = ?'", sql)
		}
	})

	t.Run("ExecuteString error propagation", func(t *testing.T) {
		tpl, _ := New(WithStrictMode(true)).Parse("test", "SELECT #{missing}")
		_, err := tpl.ExecuteString(map[string]any{})
		if err == nil {
			t.Fatal("expected error for undefined variable, got nil")
		}
	})

	t.Run("ExecuteBlockString error for missing block", func(t *testing.T) {
		tpl, _ := New().Parse("test", `@tpl("search") {SELECT 1}`)
		_, err := tpl.ExecuteBlockString("nonexistent", nil)
		if err == nil {
			t.Fatal("expected error for missing block, got nil")
		}
	})
}

// ---------- 8. TestBenchmarkConsistency ----------

func TestBenchmarkConsistency(t *testing.T) {
	t.Run("simple benchmark scenario", func(t *testing.T) {
		tpl := New().MustParse("bench", "SELECT * FROM users WHERE id = #{id} AND name = #{name}")
		result, err := tpl.Execute(map[string]any{"id": 42, "name": "alice"})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if result.SQL != "SELECT * FROM users WHERE id = ? AND name = ?" {
			t.Errorf("SQL = %q", result.SQL)
		}
		if len(result.Args) != 2 || result.Args[0] != 42 || result.Args[1] != "alice" {
			t.Errorf("Args = %v, want [42 alice]", result.Args)
		}
	})

	t.Run("conditional benchmark scenario", func(t *testing.T) {
		src := `SELECT * FROM users WHERE 1=1
@if(status != nil) { AND status = #{status} }
@if(name != "") { AND name = #{name} }
ORDER BY id`
		tpl := New().MustParse("bench", src)

		// all conditions active
		result, err := tpl.Execute(map[string]any{"status": "active", "name": "alice"})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if !strings.Contains(result.SQL, "AND status = ?") {
			t.Errorf("SQL missing status: %q", result.SQL)
		}
		if !strings.Contains(result.SQL, "AND name = ?") {
			t.Errorf("SQL missing name: %q", result.SQL)
		}
		if len(result.Args) != 2 {
			t.Errorf("Args = %v, want 2 args", result.Args)
		}

		// no conditions
		result2, err := tpl.Execute(map[string]any{"status": nil, "name": ""})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if strings.Contains(result2.SQL, "AND") {
			t.Errorf("SQL should have no AND: %q", result2.SQL)
		}
		if len(result2.Args) != 0 {
			t.Errorf("Args = %v, want empty", result2.Args)
		}
	})

	t.Run("loop benchmark scenario", func(t *testing.T) {
		src := `SELECT * FROM users WHERE id IN (@for(id range ids) {#{id}, })`
		tpl := New().MustParse("bench", src)
		ids := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
		result, err := tpl.Execute(map[string]any{"ids": ids})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if len(result.Args) != 10 {
			t.Errorf("Args = %v, want 10 args", result.Args)
		}
		for i, want := range ids {
			if result.Args[i] != want {
				t.Errorf("Args[%d] = %v, want %v", i, result.Args[i], want)
			}
		}
		if strings.HasSuffix(result.SQL, ",") {
			t.Errorf("SQL should not end with comma: %q", result.SQL)
		}
	})

	t.Run("placeholder dollar benchmark scenario", func(t *testing.T) {
		eng := New(WithPlaceholderStyle(DollarNumber))
		tpl := eng.MustParse("bench", "SELECT * FROM users WHERE id = #{id} AND name = #{name}")
		result, err := tpl.Execute(map[string]any{"id": 42, "name": "alice"})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if !strings.Contains(result.SQL, "WHERE id = $1 AND name = $2") {
			t.Errorf("SQL = %q, want $1/$2 placeholders", result.SQL)
		}
		if len(result.Args) != 2 {
			t.Errorf("Args = %v, want 2 args", result.Args)
		}
	})

	t.Run("placeholder colon benchmark scenario", func(t *testing.T) {
		eng := New(WithPlaceholderStyle(ColonNumber))
		tpl := eng.MustParse("bench", "WHERE id = #{id} AND name = #{name}")
		result, err := tpl.Execute(map[string]any{"id": 1, "name": "a"})
		if err != nil {
			t.Fatalf("execute failed: %v", err)
		}
		if !strings.Contains(result.SQL, "WHERE id = :1 AND name = :2") {
			t.Errorf("SQL = %q, want :1/:2 placeholders", result.SQL)
		}
	})
}