visualizer

func ToMermaid(v VisualizerInterface) string

{
	initial, transitions, wildcards := v.GetStructure()
	var sb strings.Builder
	sb.WriteString("stateDiagram-v2\n")

	if initial != "" {
		sb.WriteString(fmt.Sprintf("    [*] --> %s\n", initial))
	}

	var keys []string
	for k := range transitions {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for _, src := range keys {
		dsts := transitions[src]
		sort.Strings(dsts)
		for _, dst := range dsts {
			sb.WriteString(fmt.Sprintf("    %s --> %s\n", src, dst))
		}
	}

	if len(wildcards) > 0 {
		sort.Strings(wildcards)
		for _, dst := range wildcards {
			sb.WriteString(fmt.Sprintf("    [*] --> %s : (Wildcard)\n", dst))
		}
	}

	return sb.String()
}

func ToGraphviz(v VisualizerInterface) string

{
	initial, transitions, wildcards := v.GetStructure()
	var sb strings.Builder
	sb.WriteString("digraph FSM {\n")
	sb.WriteString("    rankdir=LR;\n")
	sb.WriteString("    node [shape=box style=rounded];\n")

	if initial != "" {
		sb.WriteString("    start [shape=point];\n")
		sb.WriteString(fmt.Sprintf("    start -> %s;\n", initial))
	}

	var keys []string
	for k := range transitions {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for _, src := range keys {
		dsts := transitions[src]
		sort.Strings(dsts)
		for _, dst := range dsts {
			sb.WriteString(fmt.Sprintf("    %s -> %s;\n", src, dst))
		}
	}

	if len(wildcards) > 0 {
		sort.Strings(wildcards)
		for _, dst := range wildcards {
			sb.WriteString(fmt.Sprintf("    ANY_STATE -> %s [label=\"*\"];\n", dst))
		}
	}

	sb.WriteString("}\n")
	return sb.String()
}

func TestToMermaid_Basic(t *testing.T)

{
	v := &testFSM{
		initial:     "draft",
		transitions: map[string][]string{"draft": {"paid"}, "paid": {"shipped"}},
	}
	out := ToMermaid(v)
	if !strings.Contains(out, "stateDiagram-v2") {
		t.Error("expected stateDiagram-v2 header")
	}
	if !strings.Contains(out, "[*] --> draft") {
		t.Error("expected initial state arrow")
	}
	if !strings.Contains(out, "draft --> paid") {
		t.Error("expected draft->paid transition")
	}
}

func TestToMermaid_Wildcards(t *testing.T)

{
	v := &testFSM{
		initial:   "active",
		wildcards: []string{"cancelled", "archived"},
	}
	out := ToMermaid(v)
	if !strings.Contains(out, "(Wildcard)") {
		t.Error("expected wildcard label")
	}
	if !strings.Contains(out, "cancelled") || !strings.Contains(out, "archived") {
		t.Error("expected both wildcard destinations")
	}
}

func TestToGraphviz_Basic(t *testing.T)

{
	v := &testFSM{
		initial:     "start",
		transitions: map[string][]string{"start": {"end"}},
	}
	out := ToGraphviz(v)
	if !strings.Contains(out, "digraph FSM") {
		t.Error("expected graphviz header")
	}
	if !strings.Contains(out, "start [shape=point]") {
		t.Error("expected start node")
	}
	if !strings.Contains(out, "start -> end") {
		t.Error("expected start->end edge")
	}
}