// Command-line tool for exporting mermaid diagrams
package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strings"

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

func main() {
	// Command line flags
	var (
		inputFile  = flag.String("input", "", "Input mermaid file (.mmd)")
		outputFile = flag.String("output", "", "Output file (format inferred from extension)")
		format     = flag.String("format", "svg", "Output format (svg)")
		width      = flag.Int("width", 800, "Output width in pixels")
		height     = flag.Int("height", 600, "Output height in pixels")
		theme      = flag.String("theme", "default", "Theme for SVG output")
		help       = flag.Bool("help", false, "Show help")
	)

	flag.Parse()

	if *help || *inputFile == "" {
		showHelp()
		return
	}

	// Validate input file
	if !fileExists(*inputFile) {
		log.Fatalf("Input file does not exist: %s", *inputFile)
	}

	// Read input file
	content, err := ioutil.ReadFile(*inputFile)
	if err != nil {
		log.Fatalf("Failed to read input file: %v", err)
	}

	// Parse diagram
	mermaidParser := parser.NewMermaidParser()
	diagram, err := mermaidParser.Parse(string(content))
	if err != nil {
		log.Fatalf("Failed to parse mermaid diagram: %v", err)
	}

	// Validate diagram
	if err := diagram.Validate(); err != nil {
		log.Printf("Warning: Diagram validation failed: %v", err)
	}

	// Determine output file
	if *outputFile == "" {
		base := strings.TrimSuffix(*inputFile, filepath.Ext(*inputFile))
		*outputFile = fmt.Sprintf("%s.%s", base, *format)
	}

	// Create export options
	var exportFormat exporter.ExportFormat
	switch strings.ToLower(*format) {
	case "svg":
		exportFormat = exporter.FormatSVG
	default:
		log.Fatalf("Unsupported format: %s (only 'svg' is supported)", *format)
	}

	options := &exporter.ExportOptions{
		Format: exportFormat,
		Width:  *width,
		Height: *height,
		Theme:  *theme,
	}

	// Export diagram
	exp := exporter.NewDiagramExporter()

	if !exp.IsFormatSupported(exportFormat) {
		log.Fatalf("Format %s is not supported", *format)
	}

	if !exp.IsDiagramTypeSupported(diagram.Type()) {
		log.Printf("Warning: Diagram type %s may have limited export support", diagram.Type())
	}

	err = exp.ExportToFile(diagram, *outputFile, options)
	if err != nil {
		log.Fatalf("Failed to export diagram: %v", err)
	}

	// Show success message
	fmt.Printf("✅ Successfully exported %s diagram to %s\n", diagram.Type(), *outputFile)

	// Show file info
	if info, err := os.Stat(*outputFile); err == nil {
		fmt.Printf("   File size: %d bytes\n", info.Size())
		fmt.Printf("   Dimensions: %dx%d pixels\n", *width, *height)
		fmt.Printf("   Theme: %s\n", *theme)
	}
}

func showHelp() {
	fmt.Println("Mermaid Diagram Export Tool")
	fmt.Println()
	fmt.Println("Usage:")
	fmt.Println("  mermaid-export -input diagram.mmd [options]")
	fmt.Println()
	fmt.Println("Options:")
	flag.PrintDefaults()
	fmt.Println()
	fmt.Println("Examples:")
	fmt.Println("  # Export to SVG")
	fmt.Println("  mermaid-export -input flowchart.mmd -output diagram.svg")
	fmt.Println()
	fmt.Println("  # Export to SVG with custom size")
	fmt.Println("  mermaid-export -input diagram.mmd -width 1200 -height 800")
	fmt.Println()
	fmt.Println("  # Export with custom theme")
	fmt.Println("  mermaid-export -input chart.mmd -theme dark")
	fmt.Println()
	fmt.Println("Supported formats: svg")
	fmt.Println("Supported diagram types: flowchart, sequence, class, state, er, pie, gantt, timeline, journey, architecture, organization, bpmn")
}

func fileExists(filename string) bool {
	_, err := os.Stat(filename)
	return !os.IsNotExist(err)
}