main

func main()

{
	// Create document
	doc := &Document{Name: "test.txt", Content: "Hello World", Dirty: true}

	// Create action transport
	t := action.New()
	t.Logger = logger.NewSlog(slog.Default())

	// Register dependencies
	t.Provide("Document", doc)

	// Register actions
	t.Register(&SaveAction{})
	t.Register(&NewFileAction{})

	// Show registered actions
	fmt.Println("Registered actions:", t.Actions())
	fmt.Println("Key bindings:", t.KeyBindings())

	// Simulate user pressing Ctrl+S
	fmt.Println("\n--- Dispatching 'ctrl+s' ---")
	result, err := t.DispatchKey(context.Background(), "ctrl+s")
	if err != nil {
		slog.Error("dispatch failed", "error", err)
	} else {
		fmt.Printf("Result: %v\n", result)
	}

	// Simulate dispatching by action name
	fmt.Println("\n--- Dispatching 'file.new' ---")
	result, err = t.Dispatch(context.Background(), "file.new")
	if err != nil {
		slog.Error("dispatch failed", "error", err)
	} else {
		fmt.Printf("Result: %v\n", result)
	}
}

func main()

{
	metaFlag := flag.Bool("meta", false, "generate OpenAPI JSON and exit")
	flag.Parse()

	// Create endpoint prototype (for registration and swagger)
	pingEndpoint := &ping.PingEndpoint{}

	// Handle 'swagger' subcommand OR --meta flag
	if (len(os.Args) > 1 && os.Args[1] == "swagger") || *metaFlag {
		doc, err := swagger.Build("Example API", "1.0.0", pingEndpoint)
		if err != nil {
			fmt.Fprintf(os.Stderr, "swagger build error: %v\n", err)
			os.Exit(1)
		}
		fmt.Println(string(doc))
		os.Exit(0)
	}

	// Create router
	r := router.New()
	r.SetLogger(logger.NewSlog(slog.Default()))

	// Register dependencies (by field name)
	r.Provide("PingService", ping.NewPingService())

	// Register endpoints (explicit, no init() magic)
	r.Register(pingEndpoint)

	slog.Info("🚀 Server listening on :8080")
	slog.Info("Try: curl http://localhost:8080/api/v1/ping?times=3")

	if err := r.Listen(":8080"); err != nil {
		slog.Error("server terminated", "err", err)
	}
}

func main()

{
	r := router.New()

	// Subscribe to OrderProcessed events using the Default Bus (passing nil as bus)
	// The Action transport automatically emits events on this bus by default.
	bus.Subscribe(nil, func(ctx context.Context, e *CheckoutAction) error {
		fmt.Printf("[Signal] Async notification: Order %s was processed successfully!\n", e.OrderID)
		return nil
	})

	// Register Action
	r.RegisterAction(&CheckoutAction{})

	fmt.Println("--- Dispatching Checkout Action ---")
	// Passing payload as a map
	res, err := r.Dispatch(context.Background(), "order.checkout", map[string]any{
		"order_id": "ORD-2024-ABC",
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %v\n", res)

	// Wait a bit for async signals
	time.Sleep(500 * time.Millisecond)
	fmt.Println("Done.")
}