plugin

func (*Registry) Register(p Plugin) error
{
	r.mu.Lock()
	defer r.mu.Unlock()

	name := p.Name()
	if _, ok := r.byName[name]; ok {
		return ErrAlreadyRegistered
	}

	r.byName[name] = p
	r.order = append(r.order, name)
	return nil
}

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

	r.mu.Lock()
	plugin := r.byName[name]
	delete(r.byName, name)
	for i, current := range r.order {
		if current == name {
			r.order = append(r.order[:i], r.order[i+1:]...)
			break
		}
	}
	r.mu.Unlock()
	if r.running[name] {
		delete(r.running, name)
		if plugin != nil {
			_ = plugin.Stop()
		}
	}
}

func (*Registry) StartAll() []error
{
	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	names := r.Names()
	var errs []error
	var started []string
	for _, name := range names {
		if r.running[name] {
			continue
		}
		p, ok := r.Get(name)
		if !ok {
			continue
		}
		if err := p.Start(); err != nil {
			errs = append(errs, err)
			for i := len(started) - 1; i >= 0; i-- {
				startedPlugin, exists := r.Get(started[i])
				if exists {
					if stopErr := startedPlugin.Stop(); stopErr != nil {
						errs = append(errs, stopErr)
						continue
					}
				}
				delete(r.running, started[i])
			}
			return errs
		}
		r.running[name] = true
		started = append(started, name)
	}
	return errs
}

func (*Registry) StopAll() []error
{
	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	names := r.Names()
	var errs []error
	for i := len(names) - 1; i >= 0; i-- {
		name := names[i]
		if !r.running[name] {
			continue
		}
		p, ok := r.Get(name)
		if !ok {
			delete(r.running, name)
			continue
		}
		if err := p.Stop(); err != nil {
			errs = append(errs, err)
		} else {
			delete(r.running, name)
		}
	}
	return errs
}

func (*Registry) CloseAll(ctx context.Context) []error
{
	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	names := r.Names()
	var errs []error
	for i := len(names) - 1; i >= 0; i-- {
		name := names[i]
		plugin, ok := r.Get(name)
		if !ok {
			continue
		}
		if r.running[name] {
			if err := plugin.Stop(); err != nil {
				errs = append(errs, err)
			}
			delete(r.running, name)
		}
		if closer, ok := plugin.(interface{ Close(context.Context) error }); ok {
			if err := closer.Close(ctx); err != nil {
				errs = append(errs, err)
			}
		}
	}
	return errs
}

func (*Registry) DiscoverFromValues(values ...interface{}) int
{
	if r == nil {
		return 0
	}

	pluginType := reflect.TypeOf((*Plugin)(nil)).Elem()
	count := 0
	for _, value := range values {
		if value == nil {
			continue
		}

		t := reflect.TypeOf(value)
		if t.Implements(pluginType) {
			p, _ := value.(Plugin)
			if p != nil && r.Register(p) == nil {
				count++
			}
			continue
		}

		if t.Kind() == reflect.Ptr && t.Elem().Implements(pluginType) {
			pluginValue, _ := reflect.ValueOf(value).Elem().Interface().(Plugin)
			if pluginValue != nil && r.Register(pluginValue) == nil {
				count++
			}
		}
	}
	return count
}

func (*Registry) RegisterWasmDirectory(ctx context.Context, directory string, options ...WasmOption) (int, error)
{
	loaded, err := DiscoverWasm(ctx, directory, options...)
	if err != nil {
		return 0, err
	}
	registered := 0
	for index, module := range loaded {
		if err := registry.Register(module); err != nil {
			_ = module.Close(ctx)
			closeWasm(ctx, loaded[index+1:])
			return registered, err
		}
		registered++
	}
	return registered, nil
}

func (*ExecSandbox) Start(ctx context.Context) error
{
	e.mu.Lock()
	defer e.mu.Unlock()

	if e.cmd.Process != nil {
		return errors.New("plugin: sandbox already started")
	}

	in, err := e.cmd.StdinPipe()
	if err != nil {
		return err
	}
	out, err := e.cmd.StdoutPipe()
	if err != nil {
		return err
	}

	e.in = in
	e.out = out
	if err := e.cmd.Start(); err != nil {
		return err
	}

	decoder := json.NewDecoder(io.LimitReader(e.out, maxReadyMessageSize+1))
	ready := make(chan error, 1)
	go func() {
		var msg map[string]any
		if err := decoder.Decode(&msg); err != nil {
			ready <- err
			return
		}
		if ok, _ := msg["ready"].(bool); ok {
			ready <- nil
			return
		}
		ready <- errors.New("plugin: unexpected ready message")
	}()

	startCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	select {
	case err := <-ready:
		if err == nil {
			return nil
		}
		return errors.Join(err, e.killAndWait())
	case <-startCtx.Done():
		return errors.Join(startCtx.Err(), e.killAndWait())
	}
}

func (*ExecSandbox) StopContext(ctx context.Context) error
{
	e.mu.Lock()
	defer e.mu.Unlock()

	if e.cmd.Process == nil || e.cmd.ProcessState != nil {
		return errors.New("plugin: sandbox not started")
	}

	done := make(chan error, 1)
	go func() {
		if err := json.NewEncoder(e.in).Encode(map[string]any{"cmd": "stop"}); err != nil {
			done <- errors.Join(err, e.killAndWait())
			return
		}
		done <- e.cmd.Wait()
	}()

	select {
	case err := <-done:
		e.closePipes()
		return err
	case <-ctx.Done():
		_ = e.cmd.Process.Kill()
		_ = e.in.Close()
		err := <-done
		e.closePipes()
		return errors.Join(ctx.Err(), err)
	}
}

func (*WasmPlugin) StartContext(ctx context.Context) error
{
	plugin.mu.Lock()
	defer plugin.mu.Unlock()
	if err := plugin.checkOpen(); err != nil {
		return err
	}
	if plugin.started {
		return nil
	}
	if err := plugin.callStatus(ctx, wasmExportStart); err != nil {
		return fmt.Errorf("%w: start: %v", ErrWasmCallFailed, err)
	}
	plugin.started = true
	return nil
}

func (*WasmPlugin) StopContext(ctx context.Context) error
{
	plugin.mu.Lock()
	defer plugin.mu.Unlock()
	if err := plugin.checkOpen(); err != nil {
		return err
	}
	if !plugin.started {
		return nil
	}
	if err := plugin.callStatus(ctx, wasmExportStop); err != nil {
		return fmt.Errorf("%w: stop: %v", ErrWasmCallFailed, err)
	}
	plugin.started = false
	return nil
}

func (*WasmPlugin) Call(ctx context.Context, method string, input []byte) ([]byte, error)
{
	plugin.mu.Lock()
	defer plugin.mu.Unlock()
	if err := plugin.checkOpen(); err != nil {
		return nil, err
	}
	if !plugin.started {
		return nil, ErrWasmNotStarted
	}
	if _, ok := plugin.methods[method]; !ok {
		return nil, fmt.Errorf("%w: method %q is not declared", ErrWasmCallFailed, method)
	}
	if len(input) > int(plugin.config.payloadLimit) {
		return nil, fmt.Errorf("%w: request exceeds %d bytes", ErrWasmCallFailed, plugin.config.payloadLimit)
	}

	methodPointer, err := plugin.writeGuest(ctx, []byte(method))
	if err != nil {
		return nil, err
	}
	defer plugin.freeGuest(methodPointer, uint32(len(method)))
	inputPointer, err := plugin.writeGuest(ctx, input)
	if err != nil {
		return nil, err
	}
	defer plugin.freeGuest(inputPointer, uint32(len(input)))

	callCtx, cancel := plugin.context(ctx)
	defer cancel()
	result, err := plugin.module.ExportedFunction(wasmExportCall).Call(
		callCtx,
		uint64(methodPointer),
		uint64(len(method)),
		uint64(inputPointer),
		uint64(len(input)),
	)
	if err != nil {
		return nil, plugin.runtimeError(err)
	}
	if result[0] == wasmErrorResult {
		return nil, fmt.Errorf("%w: %s", ErrWasmCallFailed, plugin.lastGuestError(callCtx))
	}
	outputPointer, outputLength := unpackWasmBuffer(result[0])
	if outputLength > plugin.config.payloadLimit {
		return nil, fmt.Errorf("%w: response exceeds %d bytes", ErrWasmCallFailed, plugin.config.payloadLimit)
	}
	output, err := plugin.readGuest(outputPointer, outputLength)
	if err != nil {
		return nil, err
	}
	plugin.freeGuest(outputPointer, outputLength)
	return output, nil
}

func (*WasmPlugin) CallJSON(ctx context.Context, method string, input, output any) error
{
	request, err := json.Marshal(input)
	if err != nil {
		return fmt.Errorf("plugin: encode WebAssembly request: %w", err)
	}
	response, err := plugin.Call(ctx, method, request)
	if err != nil {
		return err
	}
	if output == nil || len(response) == 0 {
		return nil
	}
	if err := json.Unmarshal(response, output); err != nil {
		return fmt.Errorf("plugin: decode WebAssembly response: %w", err)
	}
	return nil
}

func (*WasmPlugin) Close(ctx context.Context) error
{
	plugin.mu.Lock()
	defer plugin.mu.Unlock()
	if plugin.closed {
		return nil
	}
	if ctx == nil {
		ctx = context.Background()
	}
	var stopErr error
	if plugin.started && plugin.module != nil && !plugin.module.IsClosed() {
		if err := plugin.callStatus(ctx, wasmExportStop); err != nil {
			stopErr = fmt.Errorf("%w: stop: %v", ErrWasmCallFailed, err)
		}
	}
	plugin.started = false
	plugin.closed = true
	return errors.Join(stopErr, plugin.runtime.Close(ctx))
}

func (*WasmPlugin) moduleConfig() wazero.ModuleConfig
{
	config := wazero.NewModuleConfig().WithName("").WithStartFunctions()
	if len(plugin.config.wasiArgs) > 0 {
		config = config.WithArgs(plugin.config.wasiArgs...)
	}
	for key, value := range plugin.config.wasiEnv {
		config = config.WithEnv(key, value)
	}
	if len(plugin.config.wasiFS) > 0 {
		filesystems := wazero.NewFSConfig()
		for _, mount := range plugin.config.wasiFS {
			filesystems = filesystems.WithFSMount(mount.fs, mount.guestPath)
		}
		config = config.WithFSConfig(filesystems)
	}
	if plugin.config.stdin != nil {
		config = config.WithStdin(plugin.config.stdin)
	}
	if plugin.config.stdout != nil {
		config = config.WithStdout(plugin.config.stdout)
	}
	if plugin.config.stderr != nil {
		config = config.WithStderr(plugin.config.stderr)
	}
	if plugin.config.random != nil {
		config = config.WithRandSource(plugin.config.random)
	}
	if plugin.config.systemClock {
		config = config.WithSysWalltime().WithSysNanotime().WithSysNanosleep()
	}
	return config
}

func (*WasmPlugin) loadMetadata(ctx context.Context) error
{
	callCtx, cancel := plugin.context(ctx)
	defer cancel()
	version, err := plugin.module.ExportedFunction(wasmExportVersion).Call(callCtx)
	if err != nil {
		return plugin.runtimeError(err)
	}
	major, minor := uint32(version[0]>>32), uint32(version[0])
	if major != WasmABIMajor || minor > WasmABIMinor {
		return fmt.Errorf("%w: guest %d.%d, host %d.%d", ErrWasmABIMismatch, major, minor, WasmABIMajor, WasmABIMinor)
	}

	result, err := plugin.module.ExportedFunction(wasmExportMetadata).Call(callCtx)
	if err != nil {
		return plugin.runtimeError(err)
	}
	pointer, length := unpackWasmBuffer(result[0])
	if length == 0 || length > maxWasmMetadataSize {
		return fmt.Errorf("%w: metadata must contain 1 to %d bytes", ErrWasmInvalidModule, maxWasmMetadataSize)
	}
	data, err := plugin.readGuest(pointer, length)
	if err != nil {
		return err
	}
	metadata, err := decodeWasmMetadata(data)
	if err != nil {
		return err
	}
	plugin.metadata = metadata
	if err := plugin.validateMetadata(); err != nil {
		return err
	}
	return nil
}

func (*WasmPlugin) validateMetadata() error
{
	if err := validateWasmName(plugin.metadata.Name); err != nil {
		return fmt.Errorf("%w: plugin name: %v", ErrWasmInvalidModule, err)
	}
	if strings.TrimSpace(plugin.metadata.Version) == "" || len(plugin.metadata.Version) > maxWasmNameSize {
		return fmt.Errorf("%w: plugin version must contain 1 to %d bytes", ErrWasmInvalidModule, maxWasmNameSize)
	}
	if len(plugin.metadata.Description) > maxWasmDescription {
		return fmt.Errorf("%w: plugin description exceeds %d bytes", ErrWasmInvalidModule, maxWasmDescription)
	}
	for _, method := range plugin.metadata.Methods {
		if err := validateWasmName(method); err != nil {
			return fmt.Errorf("%w: method %q: %v", ErrWasmInvalidModule, method, err)
		}
		if _, exists := plugin.methods[method]; exists {
			return fmt.Errorf("%w: duplicate method %q", ErrWasmInvalidModule, method)
		}
		plugin.methods[method] = struct{}{}
	}
	for _, capability := range plugin.metadata.Capabilities {
		if err := validateWasmName(capability); err != nil {
			return fmt.Errorf("%w: capability %q: %v", ErrWasmInvalidModule, capability, err)
		}
		if _, exists := plugin.declared[capability]; exists {
			return fmt.Errorf("%w: duplicate capability %q", ErrWasmInvalidModule, capability)
		}
		plugin.declared[capability] = struct{}{}
		if _, granted := plugin.config.capabilities[capability]; !granted {
			return fmt.Errorf("%w: %s", ErrWasmCapabilityDenied, capability)
		}
	}
	return nil
}

func (*WasmPlugin) callStatus(ctx context.Context, name string) error
{
	callCtx, cancel := plugin.context(ctx)
	defer cancel()
	result, err := plugin.module.ExportedFunction(name).Call(callCtx)
	if err != nil {
		return plugin.runtimeError(err)
	}
	if result[0] != 0 {
		return errors.New(plugin.lastGuestError(callCtx))
	}
	return nil
}

func (*WasmPlugin) writeGuest(ctx context.Context, data []byte) (uint32, error)
{
	if len(data) == 0 {
		return 0, nil
	}
	callCtx, cancel := plugin.context(ctx)
	defer cancel()
	result, err := plugin.module.ExportedFunction(wasmExportAllocate).Call(callCtx, uint64(len(data)))
	if err != nil {
		return 0, plugin.runtimeError(err)
	}
	pointer := uint32(result[0])
	if pointer == 0 || !plugin.module.Memory().Write(pointer, data) {
		return 0, fmt.Errorf("%w: guest allocation is outside memory", ErrWasmInvalidModule)
	}
	return pointer, nil
}

func (*WasmPlugin) lastGuestError(ctx context.Context) string
{
	result, err := plugin.module.ExportedFunction(wasmExportLastError).Call(ctx)
	if err != nil || len(result) == 0 {
		return "guest did not provide an error"
	}
	pointer, length := unpackWasmBuffer(result[0])
	if length == 0 || length > plugin.config.payloadLimit {
		return "guest returned an invalid error"
	}
	message, err := plugin.readGuest(pointer, length)
	if err != nil {
		return "guest returned an invalid error"
	}
	return string(message)
}

func (*WasmPlugin) context(ctx context.Context) (context.Context, context.CancelFunc)
{
	if ctx == nil {
		ctx = context.Background()
	}
	if plugin.config.callTimeout <= 0 {
		return context.WithCancel(ctx)
	}
	if deadline, ok := ctx.Deadline(); ok && time.Until(deadline) <= plugin.config.callTimeout {
		return context.WithCancel(ctx)
	}
	return context.WithTimeout(ctx, plugin.config.callTimeout)
}

func (*WasmPlugin) validateContract() error
{
	for _, imported := range plugin.compiled.ImportedFunctions() {
		module, name, ok := imported.Import()
		if !ok {
			continue
		}
		if module == wasmHostModule {
			if _, allowed := wasmHostFunctions[name]; allowed {
				continue
			}
			return fmt.Errorf("%w: unknown host import %s.%s", ErrWasmInvalidModule, module, name)
		}
		if plugin.config.wasi && module == wasiModuleName {
			continue
		}
		return fmt.Errorf("%w: import %s.%s is not allowed", ErrWasmInvalidModule, module, name)
	}
	if len(plugin.compiled.ImportedMemories()) > 0 {
		return fmt.Errorf("%w: imported memory is not allowed", ErrWasmInvalidModule)
	}
	if _, ok := plugin.compiled.ExportedMemories()["memory"]; !ok {
		return fmt.Errorf("%w: memory export is missing", ErrWasmInvalidModule)
	}
	for _, signature := range wasmFunctions {
		function, ok := plugin.compiled.ExportedFunctions()[signature.name]
		if !ok {
			return fmt.Errorf("%w: export %s is missing", ErrWasmInvalidModule, signature.name)
		}
		if !equalValueTypes(function.ParamTypes(), signature.parameters) || !equalValueTypes(function.ResultTypes(), signature.results) {
			return fmt.Errorf("%w: export %s has the wrong signature", ErrWasmInvalidModule, signature.name)
		}
	}
	return nil
}

func (*WasmPlugin) instantiateHost(ctx context.Context) error
{
	builder := plugin.runtime.NewHostModuleBuilder(wasmHostModule)
	builder.NewFunctionBuilder().WithFunc(plugin.hostCall).Export(wasmImportHostCall)
	builder.NewFunctionBuilder().WithFunc(plugin.hostResponseLen).Export(wasmImportResultLen)
	builder.NewFunctionBuilder().WithFunc(plugin.hostResponseRead).Export(wasmImportResultRead)
	builder.NewFunctionBuilder().WithFunc(plugin.hostErrorLen).Export(wasmImportErrorLen)
	builder.NewFunctionBuilder().WithFunc(plugin.hostErrorRead).Export(wasmImportErrorRead)
	if _, err := builder.Instantiate(ctx); err != nil {
		return fmt.Errorf("%w: instantiate host ABI: %v", ErrWasmInvalidModule, err)
	}
	return nil
}

func (*WasmPlugin) hostCall(ctx context.Context, module api.Module, capabilityPointer, capabilityLength, operationPointer, operationLength, inputPointer, inputLength uint32) uint32
{
	plugin.hostResponse = nil
	plugin.hostError = nil
	if capabilityLength > maxWasmNameSize || operationLength > maxWasmNameSize || inputLength > plugin.config.payloadLimit {
		plugin.setHostError("request exceeds its size limit")
		return uint32(WasmHostPayloadTooLarge)
	}
	capability, ok := readModuleBytes(module, capabilityPointer, capabilityLength)
	if !ok {
		plugin.setHostError("capability is outside guest memory")
		return uint32(WasmHostInvalidRequest)
	}
	operation, ok := readModuleBytes(module, operationPointer, operationLength)
	if !ok {
		plugin.setHostError("operation is outside guest memory")
		return uint32(WasmHostInvalidRequest)
	}
	input, ok := readModuleBytes(module, inputPointer, inputLength)
	if !ok {
		plugin.setHostError("input is outside guest memory")
		return uint32(WasmHostInvalidRequest)
	}
	capabilityName := string(capability)
	if validateWasmName(capabilityName) != nil || validateWasmName(string(operation)) != nil {
		plugin.setHostError("capability or operation name is invalid")
		return uint32(WasmHostInvalidRequest)
	}
	if _, declared := plugin.declared[capabilityName]; !declared {
		plugin.setHostError("capability was not declared by the plugin")
		return uint32(WasmHostDenied)
	}
	handler, granted := plugin.config.capabilities[capabilityName]
	if !granted {
		plugin.setHostError("capability was not granted by the host")
		return uint32(WasmHostDenied)
	}
	response, err := handler.Call(ctx, string(operation), input)
	if err != nil {
		plugin.setHostError(err.Error())
		return uint32(WasmHostHandlerError)
	}
	if len(response) > int(plugin.config.payloadLimit) {
		plugin.setHostError("response exceeds the payload limit")
		return uint32(WasmHostPayloadTooLarge)
	}
	plugin.hostResponse = append(plugin.hostResponse[:0], response...)
	return uint32(WasmHostOK)
}

func (wasmConfig) validate() error
{
	if config.memoryLimit < wasmPageSize || config.memoryLimit > uint64(math.MaxUint32)+1 {
		return fmt.Errorf("%w: memory limit must be between 64 KiB and 4 GiB", ErrWasmInvalidModule)
	}
	if config.payloadLimit == 0 || config.payloadLimit > math.MaxInt32 {
		return fmt.Errorf("%w: payload limit must be between 1 and %d bytes", ErrWasmInvalidModule, math.MaxInt32)
	}
	for name, capability := range config.capabilities {
		if err := validateWasmName(name); err != nil {
			return fmt.Errorf("%w: capability %q: %v", ErrWasmInvalidModule, name, err)
		}
		if capability == nil {
			return fmt.Errorf("%w: capability %q has no handler", ErrWasmInvalidModule, name)
		}
		if function, ok := capability.(CapabilityFunc); ok && function == nil {
			return fmt.Errorf("%w: capability %q has no handler", ErrWasmInvalidModule, name)
		}
	}
	for key := range config.wasiEnv {
		if strings.TrimSpace(key) == "" || strings.ContainsAny(key, "=\x00") {
			return fmt.Errorf("%w: invalid WASI environment key %q", ErrWasmInvalidModule, key)
		}
	}
	for _, mount := range config.wasiFS {
		if mount.fs == nil || strings.TrimSpace(mount.guestPath) == "" {
			return fmt.Errorf("%w: invalid WASI filesystem mount", ErrWasmInvalidModule)
		}
	}
	return nil
}