// Demo program showcasing all implemented mermaid diagram types
package main

import (
	"fmt"
	"log"

	"mermaid-go/pkg/parser"
	"mermaid-go/pkg/renderer"
)

func main() {
	fmt.Println("=== Mermaid-Go Comprehensive Demo ===\n")

	// Test flowchart
	testFlowchart()
	fmt.Println()

	// Test sequence diagram
	testSequenceDiagram()
	fmt.Println()

	// Test class diagram
	testClassDiagram()
	fmt.Println()

	// Test state diagram
	testStateDiagram()
	fmt.Println()

	// Test pie chart
	testPieChart()
	fmt.Println()

	// Test ER diagram
	testERDiagram()
	fmt.Println()

	fmt.Println("=== Demo Complete ===")
}

func testFlowchart() {
	fmt.Println("--- Testing Flowchart ---")

	input := `flowchart TD
    A --> B
    B --> C
    C --> D`

	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(input)
	if err != nil {
		log.Printf("Failed to parse flowchart: %v", err)
		return
	}

	mermaidRenderer := renderer.NewMermaidRenderer()
	output, err := mermaidRenderer.Render(diagram)
	if err != nil {
		log.Printf("Failed to render flowchart: %v", err)
		return
	}

	fmt.Printf("Input:\n%s\n", input)
	fmt.Printf("Parsed and rendered:\n%s", output)
}

func testSequenceDiagram() {
	fmt.Println("--- Testing Sequence Diagram ---")

	input := `sequenceDiagram
    participant A
    participant B
    A --> B : Hello
    B --> A : Hi`

	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(input)
	if err != nil {
		log.Printf("Failed to parse sequence diagram: %v", err)
		return
	}

	mermaidRenderer := renderer.NewMermaidRenderer()
	output, err := mermaidRenderer.Render(diagram)
	if err != nil {
		log.Printf("Failed to render sequence diagram: %v", err)
		return
	}

	fmt.Printf("Input:\n%s\n", input)
	fmt.Printf("Parsed and rendered:\n%s", output)
}

func testClassDiagram() {
	fmt.Println("--- Testing Class Diagram ---")

	input := `classDiagram
    class Animal
    class Dog
    Animal --> Dog`

	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(input)
	if err != nil {
		log.Printf("Failed to parse class diagram: %v", err)
		return
	}

	mermaidRenderer := renderer.NewMermaidRenderer()
	output, err := mermaidRenderer.Render(diagram)
	if err != nil {
		log.Printf("Failed to render class diagram: %v", err)
		return
	}

	fmt.Printf("Input:\n%s\n", input)
	fmt.Printf("Parsed and rendered:\n%s", output)
}

func testStateDiagram() {
	fmt.Println("--- Testing State Diagram ---")

	input := `stateDiagram
    Idle --> Active
    Active --> Idle`

	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(input)
	if err != nil {
		log.Printf("Failed to parse state diagram: %v", err)
		return
	}

	mermaidRenderer := renderer.NewMermaidRenderer()
	output, err := mermaidRenderer.Render(diagram)
	if err != nil {
		log.Printf("Failed to render state diagram: %v", err)
		return
	}

	fmt.Printf("Input:\n%s\n", input)
	fmt.Printf("Parsed and rendered:\n%s", output)
}

func testPieChart() {
	fmt.Println("--- Testing Pie Chart ---")

	input := `pie showData
    title Pie Chart Example
    "Apples" : 30
    "Oranges" : 25
    "Bananas" : 20
    "Grapes" : 15
    "Others" : 10`

	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(input)
	if err != nil {
		log.Printf("Failed to parse pie chart: %v", err)
		return
	}

	mermaidRenderer := renderer.NewMermaidRenderer()
	output, err := mermaidRenderer.Render(diagram)
	if err != nil {
		log.Printf("Failed to render pie chart: %v", err)
		return
	}

	fmt.Printf("Input:\n%s\n", input)
	fmt.Printf("Parsed and rendered:\n%s", output)
}

func testERDiagram() {
	fmt.Println("--- Testing ER Diagram ---")

	input := `erDiagram
    Customer {
        string name
        string email PK
        int age
    }
    Order {
        int id PK
        string status
        date created
    }
    Customer ||--o{ Order : places`

	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(input)
	if err != nil {
		log.Printf("Failed to parse ER diagram: %v", err)
		return
	}

	mermaidRenderer := renderer.NewMermaidRenderer()
	output, err := mermaidRenderer.Render(diagram)
	if err != nil {
		log.Printf("Failed to render ER diagram: %v", err)
		return
	}

	fmt.Printf("Input:\n%s\n", input)
	fmt.Printf("Parsed and rendered:\n%s", output)
}