package tests

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"mermaid-go/pkg/ast"
	"mermaid-go/pkg/mermaid"
)

func TestMermaid_ParseAndRender_RoundTrip(t *testing.T) {
	testCases := []struct {
		name  string
		input string
	}{
		{
			name: "basic flowchart",
			input: `graph TD
    A --> B`,
		},
		{
			name: "flowchart with shapes",
			input: `graph TD
    A[Rectangle] --> B(Round)
    B --> C{Diamond}`,
		},
		{
			name: "flowchart with labels",
			input: `graph TD
    A -->|Get money| B
    B -->|Go shopping| C`,
		},
		{
			name: "flowchart with different arrows",
			input: `graph TD
    A --> B
    B -.-> C
    C ==> D`,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			parser := mermaid.NewParser()
			renderer := mermaid.NewRenderer()

			// Parse
			diagram, err := parser.Parse(tc.input)
			require.NoError(t, err)
			require.NotNil(t, diagram)

			// Validate
			err = diagram.Validate()
			require.NoError(t, err)

			// Render
			output := renderer.Render(diagram)
			require.NotEmpty(t, output)

			// Verify it starts with graph declaration
			assert.Contains(t, output, "graph")

			// Parse the rendered output again to ensure it's valid
			diagram2, err := parser.Parse(output)
			require.NoError(t, err)
			require.NotNil(t, diagram2)

			// Validate again
			err = diagram2.Validate()
			require.NoError(t, err)
		})
	}
}

func TestMermaid_ComplexFlowchart(t *testing.T) {
	input := `graph TD
    A[Christmas] -->|Get money| B(Go shopping)
    B --> C{Let me think}
    C -.->|One| D[Laptop]
    C -.->|Two| E[iPhone]
    C -.->|Three| F[Car]`

	parser := mermaid.NewParser()
	diagram, err := parser.Parse(input)
	require.NoError(t, err)

	flowchart := diagram.(*ast.Flowchart)

	// Verify structure
	assert.Equal(t, "TD", flowchart.Direction)
	assert.Len(t, flowchart.Vertices, 6) // A, B, C, D, E, F
	assert.Len(t, flowchart.Edges, 5)    // 5 connections

	// Verify specific vertices
	assert.Contains(t, flowchart.Vertices, "A")
	assert.Contains(t, flowchart.Vertices, "B")
	assert.Contains(t, flowchart.Vertices, "C")

	// Verify vertex properties
	vertexA := flowchart.Vertices["A"]
	require.NotNil(t, vertexA.Text)
	assert.Equal(t, "Christmas", *vertexA.Text)

	vertexB := flowchart.Vertices["B"]
	require.NotNil(t, vertexB.Text)
	assert.Equal(t, "Go shopping", *vertexB.Text)

	// Render and verify
	renderer := mermaid.NewRenderer()
	output := renderer.Render(diagram)

	assert.Contains(t, output, "graph TD")
	assert.Contains(t, output, "Christmas")
	assert.Contains(t, output, "Go shopping")
	assert.Contains(t, output, "Get money")
}