// 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 ===")

	// 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()

	// Test Gantt chart
	testGanttChart()
	fmt.Println()

	// Test Timeline
	testTimeline()
	fmt.Println()

	// Test User Journey
	testUserJourney()
	fmt.Println()

	// Test Architecture
	testArchitecture()
	fmt.Println()

	// Test Organization Chart
	testOrganizationChart()
	fmt.Println()

	// Test BPMN
	testBPMN()
	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)
}
func testGanttChart() {
	fmt.Println("--- Testing Gantt Chart ---")

	input := `gantt
    title Project Timeline
    dateFormat YYYY-MM-DD
    section Planning
    Research : 2024-01-01, 5d
    Design : 2024-01-06, 3d
    section Development
    Backend : 2024-01-09, 10d
    Frontend : 2024-01-15, 8d`

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

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

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

func testTimeline() {
	fmt.Println("--- Testing Timeline ---")

	input := `timeline
    title History of Computing
    section Early Era
    : 1940s : First computers
    : 1950s : Programming languages
    section Modern Era
    : 1970s : Personal computers
    : 1990s : Internet boom`

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

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

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

func testUserJourney() {
	fmt.Println("--- Testing User Journey ---")

	input := `journey
    title User Shopping Journey
    section Discovery
    Search for product : 5 : User
    Read reviews : 3 : User
    section Purchase
    Add to cart : 5 : User
    Checkout : 2 : User, System`

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

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

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

func testArchitecture() {
	fmt.Println("--- Testing Architecture ---")

	input := `architecture
    title System Architecture
    group api[API Layer]
    service web[Web Server] in api
    service db[Database]
    web L--R db : queries`

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

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

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

func testOrganizationChart() {
	fmt.Println("--- Testing Organization Chart ---")

	input := `organization
    title Company Structure
    CEO[Chief Executive Officer]
    CEO --> CTO[Chief Technology Officer]
    CEO --> CFO[Chief Financial Officer]
    CTO --> DevManager[Development Manager]
    CTO --> QAManager[QA Manager]
    DevManager --> Developer1[Senior Developer]
    DevManager --> Developer2[Junior Developer]`

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

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

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

func testBPMN() {
	fmt.Println("--- Testing BPMN ---")

	input := `bpmn
    title Order Processing
    pool customer[Customer]
    pool system[Order System]
    
    startEvent[Order Request](startEvent)
    validateTask[Validate Order](userTask)
    processTask[Process Payment](serviceTask)
    endEvent[Order Complete](endEvent)
    
    startEvent --> validateTask : submit order
    validateTask --> processTask : valid
    processTask --> endEvent : completed`

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

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

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