// Package appcycle is a stripped-down server stub implementation for the
// AppCycle service.  We can't use the generated stub under
// veyron2/services/mgmt/appcycle because that would introduce a recursive
// dependency on veyron/runtimes/google (via veyron2/rt).
//
// TODO(caprita): It would be nice to still use the stub if possible.  Look
// into the feasibility of a generated stub that does not depend on veyron2/rt.
package appcycle

import (
	"veyron.io/veyron/veyron2"
	"veyron.io/veyron/veyron2/ipc"
)

// AppCycleServerMethods is the interface a server writer
// implements for AppCycle.
//
// AppCycle interfaces with the process running a veyron runtime.
type AppCycleServerMethods interface {
	// Stop initiates shutdown of the server.  It streams back periodic
	// updates to give the client an idea of how the shutdown is
	// progressing.
	Stop(AppCycleStopContext) error
	// ForceStop tells the server to shut down right away.  It can be issued
	// while a Stop is outstanding if for example the client does not want
	// to wait any longer.
	ForceStop(ipc.ServerContext) error
}

// AppCycleServer returns a server stub for AppCycle.
// It converts an implementation of AppCycleServerMethods into
// an object that may be used by ipc.Server.
func AppCycleServer(impl AppCycleServerMethods) AppCycleServerStub {
	return AppCycleServerStub{impl}
}

type AppCycleServerStub struct {
	impl AppCycleServerMethods
}

func (s AppCycleServerStub) Stop(ctx *AppCycleStopContextStub) error {
	return s.impl.Stop(ctx)
}

func (s AppCycleServerStub) ForceStop(call ipc.ServerCall) error {
	return s.impl.ForceStop(call)
}

// AppCycleStopContext represents the context passed to AppCycle.Stop.
type AppCycleStopContext interface {
	ipc.ServerContext
	// SendStream returns the send side of the server stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors encountered
		// while sending.  Blocks if there is no buffer space; will unblock when
		// buffer space is available.
		Send(item veyron2.Task) error
	}
}

type AppCycleStopContextStub struct {
	ipc.ServerCall
}

func (s *AppCycleStopContextStub) Init(call ipc.ServerCall) {
	s.ServerCall = call
}

func (s *AppCycleStopContextStub) SendStream() interface {
	Send(item veyron2.Task) error
} {
	return implAppCycleStopContextSend{s}
}

type implAppCycleStopContextSend struct {
	s *AppCycleStopContextStub
}

func (s implAppCycleStopContextSend) Send(item veyron2.Task) error {
	return s.s.Send(item)
}