rtmlast

func TestRenderNodesEscapesValues(t *testing.T)

{
	mgr := state.NewStoreManager()
	st := mgr.NewStore("s", state.WithModule("app"))
	st.Set("v", "<i>store</i>")

	nodes, err := Parse("{{name}}\n@prop:name\n@store:app.s.v\n")
	if err != nil {
		t.Fatal(err)
	}
	ctx := &RenderContext{
		Props:    map[string]any{"name": "<b>x</b>"},
		StoreMgr: mgr,
	}
	out := RenderNodes(nodes, ctx)
	if strings.Contains(out, "<b>x</b>") || strings.Contains(out, "<i>store</i>") {
		t.Fatalf("markup injected: %s", out)
	}
	if !strings.Contains(out, "&lt;b&gt;x&lt;/b&gt;") {
		t.Fatalf("var/prop not escaped: %s", out)
	}
	if !strings.Contains(out, "&lt;i&gt;store&lt;/i&gt;") {
		t.Fatalf("store not escaped: %s", out)
	}
}

func TestRenderNodesEscapesSignals(t *testing.T)

{
	sig := state.NewSignal("<img src=x>")
	nodes, err := Parse("@signal:v")
	if err != nil {
		t.Fatal(err)
	}
	out := RenderNodes(nodes, &RenderContext{Props: map[string]any{"v": sig}})
	if !strings.Contains(out, "&lt;img src=x&gt;") {
		t.Fatalf("signal not escaped: %s", out)
	}
}

func isCommandPrefix(s string) bool

{
	prefixes := []string{"if:", "else-if:", "else", "endif", "for:", "endfor", "include:", "slot:", "endslot", "on:", "store:", "signal:", "prop:", "h:", "plugin:", "expr:"}
	for _, p := range prefixes {
		if len(s) > len(p) && s[:len(p)] == p {
			return true
		}
		if s == p {
			return true
		}
	}
	return false
}

func ParseExpr(s string) Expr

{
	s = strings.TrimSpace(s)
	if s == "" {
		return LiteralExpr{Value: ""}
	}
	// Ternary: cond then X else Y (preferred) or cond ? X : Y (legacy)
	if idx, ok := findTernaryThen(s); ok {
		condStr := strings.TrimSpace(s[:idx])
		rest := s[idx+5:] // len(" then") = 5
		elseIdx, ok2 := findElse(rest)
		if ok2 {
			thenStr := strings.TrimSpace(rest[:elseIdx])
			elseStr := strings.TrimSpace(rest[elseIdx+5:]) // len(" else") = 5
			return TernaryExpr{Cond: ParseExpr(condStr), Then: ParseExpr(thenStr), Else: ParseExpr(elseStr)}
		}
	}
	if idx, ok := findTernarySymbol(s); ok {
		condStr := strings.TrimSpace(s[:idx])
		rest := s[idx+1:]
		colonIdx := findTernaryColon(rest)
		if colonIdx >= 0 {
			thenStr := strings.TrimSpace(rest[:colonIdx])
			elseStr := strings.TrimSpace(rest[colonIdx+1:])
			return TernaryExpr{Cond: ParseExpr(condStr), Then: ParseExpr(thenStr), Else: ParseExpr(elseStr)}
		}
	}
	if result, ok := tryParseBinary(s); ok {
		return result
	}
	if strings.HasPrefix(s, "!") || strings.HasPrefix(s, "not ") {
		var inner string
		if strings.HasPrefix(s, "not ") {
			inner = strings.TrimSpace(s[4:])
		} else {
			inner = strings.TrimSpace(s[1:])
		}
		return UnaryExpr{Op: UnaryNot, Expr: ParseExpr(inner)}
	}
	if strings.HasPrefix(s, "-") && len(s) > 1 {
		return UnaryExpr{Op: UnaryNeg, Expr: ParseExpr(s[1:])}
	}
	if strings.HasPrefix(s, `"`) && strings.HasSuffix(s, `"`) {
		return LiteralExpr{Value: s[1 : len(s)-1]}
	}
	if strings.HasPrefix(s, "'") && strings.HasSuffix(s, "'") && len(s) >= 2 {
		return LiteralExpr{Value: s[1 : len(s)-1]}
	}
	if n, ok := tryParseNumber(s); ok {
		return LiteralExpr{Value: n}
	}
	if strings.HasPrefix(s, "store:") || strings.HasPrefix(s, "signal:") || strings.HasPrefix(s, "prop:") {
		return IdentExpr{Name: s}
	}
	if strings.Contains(s, ".") && !strings.Contains(s, "(") {
		parts := strings.SplitN(s, ".", 2)
		if isIdent(parts[0]) && isIdent(parts[1]) {
			return FieldExpr{Obj: ParseExpr(parts[0]), Field: parts[1]}
		}
	}
	if strings.Contains(s, "(") {
		parenIdx := strings.Index(s, "(")
		fnName := s[:parenIdx]
		argsStr := s[parenIdx+1 : len(s)-1]
		var args []Expr
		if argsStr != "" {
			for _, a := range strings.Split(argsStr, ",") {
				args = append(args, ParseExpr(strings.TrimSpace(a)))
			}
		}
		return CallExpr{Fn: fnName, Args: args}
	}
	return IdentExpr{Name: s}
}

func findTernaryThen(s string) (int, bool)

{
	depth := 0
	inStr := false
	for i := 0; i < len(s); i++ {
		ch := s[i]
		if ch == '"' || ch == '\'' {
			inStr = !inStr
		}
		if inStr {
			continue
		}
		if ch == '(' {
			depth++
		}
		if ch == ')' {
			depth--
		}
		if depth > 0 {
			continue
		}
		if i+5 <= len(s) && s[i:i+5] == " then" && (i+5 >= len(s) || s[i+5] == ' ') {
			return i, true
		}
	}
	return -1, false
}

func findElse(s string) (int, bool)

{
	depth := 0
	inStr := false
	for i := 0; i < len(s); i++ {
		ch := s[i]
		if ch == '"' || ch == '\'' {
			inStr = !inStr
		}
		if inStr {
			continue
		}
		if ch == '(' {
			depth++
		}
		if ch == ')' {
			depth--
		}
		if depth > 0 {
			continue
		}
		if i+5 <= len(s) && s[i:i+5] == " else" && (i+5 >= len(s) || s[i+5] == ' ') {
			return i, true
		}
	}
	return -1, false
}

func findTernarySymbol(s string) (int, bool)

{
	depth := 0
	inStr := false
	for i := 0; i < len(s); i++ {
		ch := s[i]
		if ch == '"' || ch == '\'' {
			inStr = !inStr
		}
		if inStr {
			continue
		}
		if ch == '(' {
			depth++
		}
		if ch == ')' {
			depth--
		}
		if depth > 0 {
			continue
		}
		if ch == '?' {
			return i, true
		}
	}
	return -1, false
}

func findTernaryColon(s string) int

{
	depth := 0
	inStr := false
	for i := 0; i < len(s); i++ {
		ch := s[i]
		if ch == '"' || ch == '\'' {
			inStr = !inStr
		}
		if inStr {
			continue
		}
		if ch == '(' {
			depth++
		}
		if ch == ')' {
			depth--
		}
		if depth > 0 {
			continue
		}
		if ch == ':' {
			return i
		}
	}
	return -1
}

func isIdent(s string) bool

{
	if s == "" {
		return false
	}
	for _, ch := range s {
		if !unicode.IsLetter(ch) && ch != '_' && !unicode.IsDigit(ch) {
			return false
		}
	}
	return true
}

func tryParseBinary(s string) (Expr, bool)

{
	type opInfo struct {
		op   BinOp
		syms []string
	}
	ops := []opInfo{
		{OpOr, []string{" or ", "||"}},
		{OpAnd, []string{" and ", "&&"}},
		{OpEq, []string{" is ", "=="}},
		{OpNeq, []string{" is not ", "!="}},
		{OpLte, []string{"<="}},
		{OpGte, []string{">="}},
		{OpLt, []string{"<"}},
		{OpGt, []string{">"}},
		{OpAdd, []string{"+"}},
		{OpSub, []string{"-"}},
		{OpMul, []string{"*"}},
		{OpDiv, []string{"/"}},
	}
	for _, o := range ops {
		for _, sym := range o.syms {
			idx := findBinaryOp(s, sym)
			if idx >= 0 {
				lhs := strings.TrimSpace(s[:idx])
				rhs := strings.TrimSpace(s[idx+len(sym):])
				if lhs != "" && rhs != "" {
					return BinaryExpr{Op: o.op, LHS: ParseExpr(lhs), RHS: ParseExpr(rhs)}, true
				}
			}
		}
	}
	return nil, false
}

func findBinaryOp(s, op string) int

{
	depth := 0
	inStr := false
	inVar := false
	for i := 0; i < len(s); i++ {
		ch := s[i]
		if ch == '"' || ch == '\'' {
			inStr = !inStr
		}
		if inStr {
			continue
		}
		if ch == '{' {
			inVar = true
		}
		if ch == '}' {
			inVar = false
		}
		if inVar {
			continue
		}
		if ch == '(' {
			depth++
		}
		if ch == ')' {
			depth--
		}
		if depth > 0 {
			continue
		}
		if i+len(op) <= len(s) && s[i:i+len(op)] == op {
			return i
		}
	}
	return -1
}

func TestParseText(t *testing.T)

{
	nodes, err := Parse("hello world")
	if err != nil {
		t.Fatal(err)
	}
	if len(nodes) != 1 {
		t.Fatalf("expected 1 node, got %d", len(nodes))
	}
	tn, ok := nodes[0].(TextNode)
	if !ok {
		t.Fatalf("expected TextNode, got %T", nodes[0])
	}
	if tn.Text != "hello world" {
		t.Fatalf("expected 'hello world', got '%s'", tn.Text)
	}
}

func TestParseVarInterpolation(t *testing.T)

{
	input := "hello {{name}} world"
	nodes, err := Parse(input)
	if err != nil {
		t.Fatal(err)
	}
	if len(nodes) != 3 {
		t.Fatalf("expected 3 nodes, got %d", len(nodes))
	}
	vn, ok := nodes[1].(VarNode)
	if !ok {
		t.Fatalf("expected VarNode, got %T", nodes[1])
	}
	ident, ok := vn.Expr.(IdentExpr)
	if !ok {
		t.Fatalf("expected IdentExpr, got %T", vn.Expr)
	}
	if ident.Name != "name" {
		t.Fatalf("expected 'name', got '%s'", ident.Name)
	}
}

func TestParseIfConditional(t *testing.T)

{
	input := "@if:active\nhello\n@else\nworld\n@endif"
	nodes, err := Parse(input)
	if err != nil {
		t.Fatal(err)
	}
	ifn, ok := nodes[0].(IfNode)
	if !ok {
		t.Fatalf("expected IfNode, got %T", nodes[0])
	}
	ident, ok := ifn.Cond.(IdentExpr)
	if !ok {
		t.Fatalf("expected IdentExpr condition, got %T", ifn.Cond)
	}
	if ident.Name != "active" {
		t.Fatalf("expected condition 'active', got '%s'", ident.Name)
	}
	if len(ifn.Then) == 0 {
		t.Fatal("expected Then branch")
	}
	if len(ifn.Else) == 0 {
		t.Fatal("expected Else branch")
	}
}

func TestParseForLoop(t *testing.T)

{
	input := "@for:item in items\n<div>{{item}}</div>\n@endfor"
	nodes, err := Parse(input)
	if err != nil {
		t.Fatal(err)
	}
	fn, ok := nodes[0].(ForNode)
	if !ok {
		t.Fatalf("expected ForNode, got %T", nodes[0])
	}
	if fn.Alias != "item" {
		t.Fatalf("expected alias 'item', got '%s'", fn.Alias)
	}
}

func TestParseInclude(t *testing.T)

{
	input := "@include:MyComponent"
	nodes, err := Parse(input)
	if err != nil {
		t.Fatal(err)
	}
	inc, ok := nodes[0].(IncludeNode)
	if !ok {
		t.Fatalf("expected IncludeNode, got %T", nodes[0])
	}
	if inc.Name != "MyComponent" {
		t.Fatalf("expected 'MyComponent', got '%s'", inc.Name)
	}
}

func TestParseElseIf(t *testing.T)

{
	input := "@if:a\nA\n@else-if:b\nB\n@else\nC\n@endif"
	nodes, err := Parse(input)
	if err != nil {
		t.Fatal(err)
	}
	ifn, ok := nodes[0].(IfNode)
	if !ok {
		t.Fatalf("expected IfNode, got %T", nodes[0])
	}
	if len(ifn.ElseIf) != 1 {
		t.Fatalf("expected 1 else-if, got %d", len(ifn.ElseIf))
	}
	if len(ifn.Else) == 0 {
		t.Fatal("expected else branch")
	}
}

func TestParseSlot(t *testing.T)

{
	input := "@slot:header\n<h1>fallback</h1>\n@endslot"
	nodes, err := Parse(input)
	if err != nil {
		t.Fatal(err)
	}
	sn, ok := nodes[0].(SlotNode)
	if !ok {
		t.Fatalf("expected SlotNode, got %T", nodes[0])
	}
	if sn.Name != "header" {
		t.Fatalf("expected 'header', got '%s'", sn.Name)
	}
}

func renderNode(n Node, ctx *RenderContext) string

{
	switch v := n.(type) {
	case TextNode:
		return v.Text
	case ExprNode:
		return renderExprNode(v, ctx)
	case VarNode:
		return renderVar(v, ctx)
	case IfNode:
		return renderIf(v, ctx)
	case ForNode:
		return renderFor(v, ctx)
	case IncludeNode:
		return renderInclude(v, ctx)
	case SlotNode:
		return renderSlot(v, ctx)
	case CommandNode:
		return renderCommand(v, ctx)
	default:
		return ""
	}
}

func renderIf(v IfNode, ctx *RenderContext) string

{
	condVal := evalBool(v.Cond, ctx)
	if condVal {
		return RenderNodes(v.Then, ctx)
	}
	for _, branch := range v.ElseIf {
		if evalBool(branch.Cond, ctx) {
			return RenderNodes(branch.Body, ctx)
		}
	}
	if len(v.Else) > 0 {
		return RenderNodes(v.Else, ctx)
	}
	return ""
}

func renderFor(v ForNode, ctx *RenderContext) string

{
	collection := evalExpr(v.Expr, ctx)
	var items []any
	switch c := collection.(type) {
	case []any:
		items = c
	case map[string]any:
		for k, val := range c {
			items = append(items, map[string]any{"key": k, "value": val})
		}
	default:
		return ""
	}
	var sb strings.Builder
	for i, item := range items {
		childCtx := *ctx
		if childCtx.Props == nil {
			childCtx.Props = map[string]any{}
		}
		childCtx.Props[v.Alias] = item
		if v.KeyAlias != "" {
			switch k := item.(type) {
			case map[string]any:
				childCtx.Props[v.KeyAlias] = k["key"]
			default:
				childCtx.Props[v.KeyAlias] = i
			}
		}
		sb.WriteString(RenderNodes(v.Body, &childCtx))
	}
	return sb.String()
}

func renderCommand(v CommandNode, ctx *RenderContext) string

{
	switch v.Kind {
	case "store":
		return renderStoreCmd(v.Value, ctx)
	case "signal":
		return renderSignalCmd(v.Value, ctx)
	case "prop":
		return renderPropCmd(v.Value, ctx)
	case "on":
		return renderEventCmd(v.Value)
	case "h":
		return fmt.Sprintf(`<span data-host-var="%s" data-host-expected=""></span>`, v.Value)
	default:
		return fmt.Sprintf(`@%s:%s`, v.Kind, v.Value)
	}
}

func renderStoreCmd(val string, ctx *RenderContext) string

{
	parts := strings.Split(val, ".")
	isW := strings.HasSuffix(val, ":w")
	if isW && len(parts) >= 3 {
		cleanVal := strings.TrimSuffix(val, ":w")
		cparts := strings.Split(cleanVal, ".")
		if len(cparts) == 3 {
			placeholder := fmt.Sprintf("@store:%s:w", cleanVal)
			return placeholder
		}
	}
	if len(parts) == 3 && !isW {
		store := ctx.StoreMgr.GetStore(parts[0], parts[1])
		if store != nil {
			v := store.Get(parts[2])
			return fmt.Sprintf(`<span data-store="%s">%s</span>`, val, escapeValue(v))
		}
	}
	return fmt.Sprintf(`@store:%s`, val)
}

func renderSignalCmd(val string, ctx *RenderContext) string

{
	name := val
	isW := strings.HasSuffix(val, ":w")
	if isW {
		name = strings.TrimSuffix(val, ":w")
		return fmt.Sprintf("@signal:%s:w", name)
	}
	if prop, ok := ctx.Props[name]; ok {
		if sig, ok := prop.(interface{ Read() any }); ok {
			v := sig.Read()
			return fmt.Sprintf(`<span data-signal="%s">%s</span>`, name, escapeValue(v))
		}
	}
	return fmt.Sprintf(`@signal:%s`, name)
}

func evalExpr(e Expr, ctx *RenderContext) any

{
	switch v := e.(type) {
	case IdentExpr:
		return lookupIdent(v.Name, ctx)
	case LiteralExpr:
		return v.Value
	case BinaryExpr:
		return evalBinary(v, ctx)
	case UnaryExpr:
		return evalUnary(v, ctx)
	case FieldExpr:
		obj := evalExpr(v.Obj, ctx)
		if m, ok := obj.(map[string]any); ok {
			return m[v.Field]
		}
		return nil
	case CallExpr:
		return nil
	case TernaryExpr:
		if evalBool(v.Cond, ctx) {
			return evalExpr(v.Then, ctx)
		}
		return evalExpr(v.Else, ctx)
	default:
		return nil
	}
}

func evalBool(e Expr, ctx *RenderContext) bool

{
	val := evalExpr(e, ctx)
	switch v := val.(type) {
	case bool:
		return v
	case string:
		return v != ""
	case int:
		return v != 0
	case float64:
		return v != 0
	case nil:
		return false
	default:
		return true
	}
}

func evalBinary(b BinaryExpr, ctx *RenderContext) any

{
	lhs := evalExpr(b.LHS, ctx)
	rhs := evalExpr(b.RHS, ctx)
	switch b.Op {
	case OpEq:
		return fmt.Sprintf("%v", lhs) == fmt.Sprintf("%v", rhs)
	case OpNeq:
		return fmt.Sprintf("%v", lhs) != fmt.Sprintf("%v", rhs)
	case OpAnd:
		return toBool(lhs) && toBool(rhs)
	case OpOr:
		return toBool(lhs) || toBool(rhs)
	case OpLt, OpGt, OpLte, OpGte:
		return compareValues(lhs, rhs, b.Op)
	case OpAdd:
		return toFloat(lhs) + toFloat(rhs)
	case OpSub:
		return toFloat(lhs) - toFloat(rhs)
	case OpMul:
		return toFloat(lhs) * toFloat(rhs)
	case OpDiv:
		r := toFloat(rhs)
		if r == 0 {
			return 0.0
		}
		return toFloat(lhs) / r
	default:
		return nil
	}
}

func evalUnary(u UnaryExpr, ctx *RenderContext) any

{
	val := evalExpr(u.Expr, ctx)
	switch u.Op {
	case UnaryNot:
		return !toBool(val)
	case UnaryNeg:
		return -toFloat(val)
	default:
		return val
	}
}

func lookupIdent(name string, ctx *RenderContext) any

{
	if strings.HasPrefix(name, "store:") {
		parts := strings.Split(strings.TrimPrefix(name, "store:"), ".")
		if len(parts) == 3 && ctx.StoreMgr != nil {
			store := ctx.StoreMgr.GetStore(parts[0], parts[1])
			if store != nil {
				return store.Get(parts[2])
			}
		}
		return nil
	}
	if strings.HasPrefix(name, "signal:") {
		sigName := strings.TrimPrefix(name, "signal:")
		if prop, ok := ctx.Props[sigName]; ok {
			if sig, ok := prop.(interface{ Read() any }); ok {
				return sig.Read()
			}
			return prop
		}
		return nil
	}
	if v, ok := ctx.Props[name]; ok {
		if sig, ok := v.(interface{ Read() any }); ok {
			return sig.Read()
		}
		return v
	}
	return nil
}

func toBool(v any) bool

{
	switch val := v.(type) {
	case bool:
		return val
	case string:
		return val != ""
	case int:
		return val != 0
	case float64:
		return val != 0
	default:
		return v != nil
	}
}

func toFloat(v any) float64

{
	switch val := v.(type) {
	case int:
		return float64(val)
	case float64:
		return val
	case string:
		f, err := strconv.ParseFloat(val, 64)
		if err != nil {
			return 0
		}
		return f
	default:
		return 0
	}
}

func compareValues(lhs, rhs any, op BinOp) bool

{
	l, r := toFloat(lhs), toFloat(rhs)
	switch op {
	case OpLt:
		return l < r
	case OpGt:
		return l > r
	case OpLte:
		return l <= r
	case OpGte:
		return l >= r
	default:
		return false
	}
}