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) 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 (*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)
	}
}