func (r *Registry) Available() []string {
	r.mu.RLock()
	defer r.mu.RUnlock()

	return r.sortedNames(true)
}

func Available() []string {
	return globalRegistry.Available()
}

func (e *BackendUnavailableError) Error() string {
	return "surface: backend unavailable: " + e.Name
}

func (e *BackendNotFoundError) Error() string {
	return "surface: backend not found: " + e.Name
}

func (r *Registry) Get(name string) (*RegistryEntry, bool) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	entry, ok := r.entries[name]
	if !ok {
		return nil, false
	}

	// Return a copy to prevent modification
	entryCopy := *entry
	return &entryCopy, true
}

func Get(name string) (*RegistryEntry, bool) {
	return globalRegistry.Get(name)
}

func (r *Registry) List() []string {
	r.mu.RLock()
	defer r.mu.RUnlock()

	return r.sortedNames(false)
}

func List() []string {
	return globalRegistry.List()
}

func NewRegistry() *Registry {
	return &Registry{
		entries: make(map[string]*RegistryEntry),
	}
}

func NewSurface(width, height int) (Surface, error) {
	return globalRegistry.NewSurface(Options{Width: width, Height: height})
}

func (r *Registry) NewSurface(opts Options) (Surface, error) {
	r.mu.RLock()
	available := r.sortedNames(true)
	r.mu.RUnlock()

	if len(available) == 0 {
		return nil, ErrNoBackendAvailable
	}

	// Try each available backend in priority order
	var lastErr error
	for _, name := range available {
		s, err := r.NewSurfaceByName(name, opts)
		if err == nil {
			return s, nil
		}
		lastErr = err
	}

	if lastErr != nil {
		return nil, lastErr
	}
	return nil, ErrNoBackendAvailable
}

func NewSurfaceByName(name string, width, height int) (Surface, error) {
	return globalRegistry.NewSurfaceByName(name, Options{Width: width, Height: height})
}

func (r *Registry) NewSurfaceByName(name string, opts Options) (Surface, error) {
	r.mu.RLock()
	entry, ok := r.entries[name]
	r.mu.RUnlock()

	if !ok {
		return nil, &BackendNotFoundError{Name: name}
	}

	if !entry.Available() {
		return nil, &BackendUnavailableError{Name: name}
	}

	return entry.Factory(opts)
}

func NewSurfaceByNameWithOptions(name string, opts Options) (Surface, error) {
	return globalRegistry.NewSurfaceByName(name, opts)
}

func NewSurfaceWithOptions(opts Options) (Surface, error) {
	return globalRegistry.NewSurface(opts)
}

func (r *Registry) Register(name string, priority int, factory SurfaceFactory, available func() bool) {
	r.mu.Lock()
	defer r.mu.Unlock()

	if r.entries == nil {
		r.entries = make(map[string]*RegistryEntry)
	}

	if available == nil {
		available = func() bool { return true }
	}

	r.entries[name] = &RegistryEntry{
		Name:		name,
		Priority:	priority,
		Factory:	factory,
		Available:	available,
	}
}

func Register(name string, priority int, factory SurfaceFactory, available func() bool) {
	globalRegistry.Register(name, priority, factory, available)
}

func (r *Registry) Unregister(name string) {
	r.mu.Lock()
	defer r.mu.Unlock()

	delete(r.entries, name)
}

func Unregister(name string) {
	globalRegistry.Unregister(name)
}

type RegistryEntry struct {
	// Name is the unique identifier for this backend.
	Name	string

	// Priority determines selection order (higher = preferred).
	// Standard priorities:
	//   - 100: GPU backends (Vulkan, Metal, D3D12)
	//   - 50: Hardware-accelerated software (WARP)
	//   - 10: Pure software backends
	Priority	int

	// Factory creates surface instances.
	Factory	SurfaceFactory

	// Available reports if the backend is available on this system.
	// This is called during registration and cached.
	Available	func() bool
}

type Registry struct {
	mu	sync.RWMutex
	entries	map[string]*RegistryEntry
}

type BackendNotFoundError struct {
	Name string
}

type BackendUnavailableError struct {
	Name string
}