// BAD: Unbounded goroutine spawning
func HandleWebhook(w http.ResponseWriter, r *http.Request) {
    payload := parse(r.Body)
    go processWebhook(payload) // Memory leak and CPU exhaustion hazard!
    w.WriteHeader(http.StatusAccepted)
}

Incoming Requests ──> [ Job Queue Channel (Buffer: N) ]
                             │
            ┌────────────────┼────────────────┐
            ▼                ▼                ▼
       [ Worker 1 ]     [ Worker 2 ]     [ Worker N ]
            │                │                │
            └────────────────┼────────────────┘
                             ▼
                    [ Done / Results ]

package workerpool

import (
	"context"
	"errors"
	"sync"
	"time"
)

var (
	ErrPoolClosed   = errors.New("worker pool is closed")
	ErrQueueFull    = errors.New("job queue is full; request rejected")
)

type Job func(ctx context.Context) error

type Pool struct {
	numWorkers int
	jobQueue   chan Job
	wg         sync.WaitGroup
	ctx        context.Context
	cancel     context.CancelFunc
	mu         sync.Mutex
	isClosed   bool
}

// New initializes and starts the worker pool.
func New(ctx context.Context, workers int, queueCap int) *Pool {
	childCtx, cancel := context.WithCancel(ctx)
	p := &Pool{
		numWorkers: workers,
		jobQueue:   make(chan Job, queueCap),
		ctx:        childCtx,
		cancel:     cancel,
	}

	p.start()
	return p
}

func (p *Pool) start() {
	for i := 0; i < p.numWorkers; i++ {
		p.wg.Add(1)
		go p.worker(i)
	}
}

func (p *Pool) worker(id int) {
	defer p.wg.Done()

	for {
		select {
		case <-p.ctx.Done():
			// Context canceled: Drain remaining buffered jobs before exiting
			p.drain()
			return
		case job, ok := <-p.jobQueue:
			if !ok {
				return
			}
			p.executeJob(job)
		}
	}
}

func (p *Pool) executeJob(job Job) {
	// Protect against panics inside individual jobs
	defer func() {
		if r := recover(); r != nil {
			// Log panic with stack trace in real systems
		}
	}()

	_ = job(p.ctx)
}

func (p *Pool) drain() {
	for job := range p.jobQueue {
		p.executeJob(job)
	}
}

// Submit enqueues a job blocking or non-blocking depending on backpressure requirements.
func (p *Pool) Submit(job Job) error {
	p.mu.Lock()
	if p.isClosed {
		p.mu.Unlock()
		return ErrPoolClosed
	}
	p.mu.Unlock()

	select {
	case <-p.ctx.Done():
		return p.ctx.Err()
	case p.jobQueue <- job:
		return nil
	}
}

// TrySubmit enqueues a job without blocking. Returns error if queue is saturated.
func (p *Pool) TrySubmit(job Job) error {
	p.mu.Lock()
	if p.isClosed {
		p.mu.Unlock()
		return ErrPoolClosed
	}
	p.mu.Unlock()

	select {
	case <-p.ctx.Done():
		return p.ctx.Err()
	case p.jobQueue <- job:
		return nil
	default:
		return ErrQueueFull
	}
}

// Shutdown stops accepting jobs and waits for running/queued tasks to finish.
func (p *Pool) Shutdown(timeout time.Duration) error {
	p.mu.Lock()
	if p.isClosed {
		p.mu.Unlock()
		return nil
	}
	p.isClosed = true
	close(p.jobQueue)
	p.mu.Unlock()

	done := make(chan struct{})
	go func() {
		p.wg.Wait()
		close(done)
	}()

	select {
	case <-done:
		p.cancel()
		return nil
	case <-time.After(timeout):
		p.cancel() // Force stop hung workers
		return errors.New("shutdown timed out; workers killed")
	}
}