package main

import (
  "context"
  "fmt"
  "time"
  
  queue "github.com/pardnchiu/go-queue"
)

func main() {
  // Initialize with default config
  q := queue.New(nil)
  
  // Start queue workers
  ctx := context.Background()
  q.Start(ctx)
  
  // Enqueue tasks
  for i := 0; i < 10; i++ {
    id, err := q.Enqueue(ctx, "", func(ctx context.Context) error {
      fmt.Println("task executed")
      return nil
    })
    if err != nil {
      fmt.Printf("enqueue failed: %v\n", err)
    }
    fmt.Printf("task ID: %s\n", id)
  }
  
  // Graceful shutdown (wait for all tasks to finish)
  if err := q.Shutdown(ctx); err != nil {
    fmt.Printf("shutdown error: %v\n", err)
  }
}

package main

import (
  "context"
  "fmt"
  
  queue "github.com/pardnchiu/go-queue"
)

func main() {
  q := queue.New(&queue.Config{
    Workers: 8,
    Size:    1000,
    Timeout: 60,
    Preset: map[string]queue.PresetConfig{
      "critical": {Priority: PriorityImmediate, Timeout: 15},
      "email":    {Priority: PriorityHigh, Timeout: 30},
      "report":   {Priority: PriorityNormal, Timeout: 120},
      "cleanup":  {Priority: PriorityLow, Timeout: 300},
    },
  })
  
  ctx := context.Background()
  q.Start(ctx)
  defer q.Shutdown(ctx)
  
  // Use preset config for critical payment
  q.Enqueue(ctx, "critical", func(ctx context.Context) error {
    return processPayment()
  })
  
  // Use preset config to send email
  q.Enqueue(ctx, "email", func(ctx context.Context) error {
    return sendNotification()
  })
  
  // Use preset config to generate report
  q.Enqueue(ctx, "report", func(ctx context.Context) error {
    return generateReport()
  })
}

package main

import (
  "context"
  "fmt"
  "time"
  
  queue "github.com/pardnchiu/go-queue"
)

func main() {
  q := queue.New(&queue.Config{Workers: 4})
  
  ctx := context.Background()
  q.Start(ctx)
  defer q.Shutdown(ctx)
  
  // Custom task ID
  q.Enqueue(ctx, "", func(ctx context.Context) error {
    return processOrder("ORD-123")
  }, queue.WithTaskID("order-ORD-123"))
  
  // Custom timeout
  q.Enqueue(ctx, "", func(ctx context.Context) error {
    return heavyComputation()
  }, queue.WithTimeout(5*time.Minute))
  
  // Custom callback (only triggered on success)
  q.Enqueue(ctx, "", func(ctx context.Context) error {
    return sendEmail()
  }, queue.WithCallback(func(id string) {
    fmt.Printf("task %s completed\n", id)
  }))
  
  // Combined options
  q.Enqueue(ctx, "", func(ctx context.Context) error {
    return importData()
  },
    queue.WithTaskID("import-daily"),
    queue.WithTimeout(10*time.Minute),
    queue.WithCallback(func(id string) {
      logSuccess(id)
    }),
  )
}

type Config struct {
  Workers int                     // worker pool size (default: CPU cores × 2)
  Size    int                     // max queue capacity (default: Workers × 64)
  Timeout int                     // default timeout in seconds (default: 30)
  Preset  map[string]PresetConfig // named preset configs
}

type PresetConfig struct {
  Priority Priority         // nil = PriorityNormal
  Timeout  time.Duration    // override timeout in seconds (0 = computed by priority)
}

// Scheduler triggers, Queue controls concurrency
scheduler.Add("@every 1m", func() error {
  orders := db.GetPendingOrders()
  for _, o := range orders {
    queue.Enqueue(ctx, "order", func(ctx context.Context) error {
      return processOrder(o)
    })
  }
  return nil
})