// Copyright 2009 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// SRPC server

package srpc

import (
	"bytes"
	"log"
	"os"
	"syscall"
)

// TODO(rsc): I'd prefer to make this
//	type Handler func(m *msg) Errno
// but NaCl can't use closures.
// The explicit interface is a way to attach state.

// A Handler is a handler for an SRPC method.
// It reads arguments from arg, checks size for array limits,
// writes return values to ret, and returns an Errno status code.
type Handler interface {
	Run(arg, ret []interface{}, size []int) Errno
}

type method struct {
	name    string
	fmt     string
	handler Handler
}

var rpcMethod []method

// BUG(rsc): Add's format string should be replaced by analyzing the
// type of an arbitrary func passed in an interface{} using reflection.

// Add registers a handler for the named method.
// Fmt is a Native Client format string, a sequence of
// alphabetic characters representing the types of the parameter values,
// a colon, and then a sequence of alphabetic characters
// representing the types of the returned values.
// The format characters and corresponding dynamic types are:
//
//	b	bool
//	C	[]byte
//	d	float64
//	D	[]float64
//	h	int	// a file descriptor (aka handle)
//	i	int32
//	I	[]int32
//	s	string
//
func Add(name, fmt string, handler Handler) {
	n := len(rpcMethod)
	if n >= cap(rpcMethod) {
		a := make([]method, n, (n+4)*2)
		for i := range a {
			a[i] = rpcMethod[i]
		}
		rpcMethod = a
	}
	rpcMethod = rpcMethod[0 : n+1]
	rpcMethod[n] = method{name, fmt, handler}
}

// Serve accepts new SRPC connections from the file descriptor fd
// and answers RPCs issued on those connections.
// It closes fd and returns an error if the imc_accept system call fails.
func Serve(fd int) os.Error {
	defer syscall.Close(fd)

	for {
		cfd, _, e := syscall.Syscall(syscall.SYS_IMC_ACCEPT, uintptr(fd), 0, 0)
		if e != 0 {
			return os.NewSyscallError("imc_accept", int(e))
		}
		go serveLoop(int(cfd))
	}
	panic("unreachable")
}

func serveLoop(fd int) {
	c := make(chan *msg)
	go sendLoop(fd, c)

	var r msgReceiver
	r.fd = fd
	for {
		m, err := r.recv()
		if err != nil {
			break
		}
		m.unpackRequest()
		if !m.gotHeader {
			log.Stderrf("cannot unpack header: %s", m.status)
			continue
		}
		// log.Stdoutf("<- %#v", m);
		m.isReq = false // set up for response
		go serveMsg(m, c)
	}
	close(c)
}

func sendLoop(fd int, c <-chan *msg) {
	var s msgSender
	s.fd = fd
	for m := range c {
		// log.Stdoutf("-> %#v", m);
		m.packResponse()
		s.send(m)
	}
	syscall.Close(fd)
}

func serveMsg(m *msg, c chan<- *msg) {
	if m.status != OK {
		c <- m
		return
	}
	if m.rpcNumber >= uint32(len(rpcMethod)) {
		m.status = ErrBadRPCNumber
		c <- m
		return
	}

	meth := &rpcMethod[m.rpcNumber]
	if meth.fmt != m.fmt {
		switch {
		case len(m.fmt) < len(meth.fmt):
			m.status = ErrTooFewArgs
		case len(m.fmt) > len(meth.fmt):
			m.status = ErrTooManyArgs
		default:
			// There's a type mismatch.
			// It's an in-arg mismatch if the mismatch happens
			// before the colon; otherwise it's an out-arg mismatch.
			m.status = ErrInArgTypeMismatch
			for i := 0; i < len(m.fmt) && m.fmt[i] == meth.fmt[i]; i++ {
				if m.fmt[i] == ':' {
					m.status = ErrOutArgTypeMismatch
					break
				}
			}
		}
		c <- m
		return
	}

	m.status = meth.handler.Run(m.Arg, m.Ret, m.Size)
	c <- m
}

// ServeRuntime serves RPCs issued by the Native Client embedded runtime.
// This should be called by main once all methods have been registered using Add.
func ServeRuntime() os.Error {
	// Call getFd to check that we are running embedded.
	if _, err := getFd(); err != nil {
		return err
	}

	// We are running embedded.
	// The fd returned by getFd is a red herring.
	// Accept connections on magic fd 3.
	return Serve(3)
}

// getFd runs the srpc_get_fd system call.
func getFd() (fd int, err os.Error) {
	r1, _, e := syscall.Syscall(syscall.SYS_SRPC_GET_FD, 0, 0, 0)
	return int(r1), os.NewSyscallError("srpc_get_fd", int(e))
}

// Enabled returns true if SRPC is enabled in the Native Client runtime.
func Enabled() bool {
	_, err := getFd()
	return err == nil
}

// Service #0, service_discovery, returns a list of the other services
// and their argument formats.
type serviceDiscovery struct{}

func (serviceDiscovery) Run(arg, ret []interface{}, size []int) Errno {
	var b bytes.Buffer
	for _, m := range rpcMethod {
		b.WriteString(m.name)
		b.WriteByte(':')
		b.WriteString(m.fmt)
		b.WriteByte('\n')
	}
	if b.Len() > size[0] {
		return ErrNoMemory
	}
	ret[0] = b.Bytes()
	return OK
}

func init() { Add("service_discovery", ":C", serviceDiscovery{}) }