package operator

import "context"

// Controller drains a work queue, calling Reconcile per key. A real
// controller-runtime controller adds caching informers, rate-limited
// requeue, and leader election; the level-triggered core is this.
type Controller struct {
	R     *Reconciler
	queue chan string
}

func NewController(r *Reconciler) *Controller {
	return &Controller{R: r, queue: make(chan string, 1024)}
}

// Enqueue schedules a key for reconciliation (deduplication is omitted
// for brevity; controller-runtime's queue dedupes).
func (c *Controller) Enqueue(name string) {
	select {
	case c.queue <- name:
	default:
	}
}

// ProcessAll drains the queue synchronously (for tests).
func (c *Controller) ProcessAll() {
	for {
		select {
		case k := <-c.queue:
			_ = c.R.Reconcile(k)
		default:
			return
		}
	}
}

// Run processes the queue until ctx is cancelled.
func (c *Controller) Run(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case k := <-c.queue:
			_ = c.R.Reconcile(k)
		}
	}
}