func (a *API) FindMsgAttachedTo(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	attachTo, err := args.QueryString("AttachTo")
	if err != nil || attachTo == "" {
		return ErrArg
	}
	joins, err := a.db.FindMsgAttachedTo(attachTo)
	if err != nil {
		return err
	}
	q := make([]msgJoinJSON, len(joins))
	for i, join := range joins {
		author, err := a.whoIsID(join.Author)
		if err != nil {
			log.Printf("Unresolved author ID: %s", join.Author)
			q[i].AuthorNym = "anonymous"
		} else {
			q[i].AuthorNym = author.Login
		}
		q[i].ID = WebStringOfObjectID(join.ID)
		q[i].Body = join.Doc.Body
		q[i].AuthorID = WebStringOfObjectID(join.Author)
		q[i].AttachTo = WebStringOfObjectID(join.AttachTo)
		q[i].ReplyTo = WebStringOfObjectID(join.ReplyTo)
		modtm := time.NanosecondsToLocalTime(int64(join.Modified)).Format(msgFormat)
		q[i].Modified = modtm
	}
	r.SetInterface("Results", q)
	return nil
}

// AddMsg adds a new message to the database. The author is the currently
// logged in user. The message is attached to the object given by the string
// argument "AttachTo". Optionally, the message is in response to another message
// with message ID "ReplyTo". AddMsg returns the message ID of the newly added
// message, in the return field "ID".
func (a *API) AddMsg(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	authorDoc, authorID, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	attachTo, err := args.QueryString("AttachTo")
	if err != nil || attachTo == "" {
		return ErrArg
	}
	replyTo, _ := args.QueryString("ReplyTo")
	body, err := args.QueryString("Body")
	if err != nil || body == "" {
		return ErrArg
	}
	msgID, err := a.db.AddMsg(authorID, attachTo, ObjectIDOfWebString(replyTo), body)
	if err != nil {
		return err
	}
	j := msgJoinJSON{
		ID:        WebStringOfObjectID(msgID),
		Body:      body,
		AuthorID:  WebStringOfObjectID(authorID),
		AuthorNym: authorDoc.Login,
		AttachTo:  attachTo,
		ReplyTo:   replyTo,
		Modified:  time.NanosecondsToLocalTime(int64(bson.Now())).Format(msgFormat),
	}
	r.SetInterface("Msg", j)
	return nil
}

func (a *API) UnsetFollow(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	_, uid, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	what, _ := args.QueryString("What")
	r.SetInt("XPad", 0)
	return a.db.UnsetFollow(uid, what)
}

func (a *API) Unlike(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	fid, _ := args.QueryString("FID")
	_, uid, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	r.SetInt("XPad", 0)
	return a.db.Unlike(uid, fid)
}

// RemoveMsg deletes a message
func (a *API) RemoveMsg(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	_, editorID, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	msg, err := args.QueryString("Msg")
	if err != nil {
		return err
	}
	r.SetInt("XPad", 0)
	return a.db.RemoveMsg(editorID, ObjectIDOfWebString(msg))
}

// WhoAmI returns the login of the currently signed user
func (a *API) WhoAmI(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	user, _, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	login := ""
	if user != nil {
		login = user.Login
	}
	r.SetString("Login", login)

	return nil
}

// IsLoginAvailable checks if this login (i.e. username) is already taken
func (a *API) IsLoginAvailable(args *rpc.Args, r *rpc.Ret) os.Error {
	login, err := args.QueryString("L")
	if err != nil {
		return err
	}
	if login, err = SanitizeLogin(login); err != nil {
		return rpc.ErrArg
	}
	u, _, err := a.db.FindUserByLogin(login)
	if err != nil {
		return ErrDb
	}
	r.SetBool("Available", u == nil)
	return nil
}

// EditMsg changes the body of an existing message
func (a *API) EditMsg(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	_, editorID, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	msg, err := args.QueryString("Msg")
	if err != nil {
		return err
	}
	body, err := args.QueryString("Body")
	if err != nil || body == "" {
		return ErrArg
	}
	r.SetInt("XPad", 0)
	return a.db.EditMsg(editorID, ObjectIDOfWebString(msg), body)
}

// SignUp registers a new user
func (a *API) SignUp(args *rpc.Args, r *rpc.Ret) (err os.Error) {

	// Validate and sanitize arguments
	name, _ := args.QueryString("N")
	if name, err = SanitizeName(name); err != nil {
		return ErrApp
	}
	email, _ := args.QueryString("E")
	if email, err = SanitizeEmail(email); err != nil {
		return ErrApp
	}
	login, _ := args.QueryString("L")
	if login, err = SanitizeLogin(login); err != nil {
		return ErrApp
	}
	hpass, _ := args.QueryString("P")

	// Check that a user like this doesn't already exist
	u, _, err := a.db.FindUserByLogin(login)
	if err != nil {
		return ErrDb
	}
	if u != nil {
		return ErrApp
	}
	u, err = a.db.FindUserByEmail(email)
	if err != nil {
		return ErrDb
	}
	if u != nil {
		return ErrApp
	}

	// Add the user
	u = &db.UserDoc{
		Name:     name,
		Login:    login,
		Email:    email,
		Password: hpass,
	}
	if _, err = a.db.AddUser(u); err != nil {
		return ErrDb
	}

	r.SetInt("XPad", 0)
	return nil
}

func (a *API) LikeInfo(args *rpc.Args, r *rpc.Ret) (err os.Error) {
	fid, _ := args.QueryString("FID")
	_, uid, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	likes, err := a.db.Likes(uid, fid)
	if err != nil {
		likes = false
	}
	n, err := a.db.LikeCount(fid)
	if err != nil {
		return err
	}
	r.SetBool("Likes", likes)
	r.SetInt("Count", n)
	return nil
}

// RPC/SignInLogin logs in a user, specified by their login (aka username)
// Args:
//   "L" string
//   "P" string = HMAC-hashed password
// Err:
//   ErrApp:  If the sign-in information is incorrect
//   non-nil: If a technical problem occured
//
func (a *API) SignInLogin(args *rpc.Args, r *rpc.Ret) (err os.Error) {

	// Validate and sanitize arguments
	login, _ := args.QueryString("L")
	if login, err = SanitizeLogin(login); err != nil {
		return ErrApp
	}
	hpass, _ := args.QueryString("P")

	// Fetch user for this login
	u, _, err := a.db.FindUserByLogin(login)
	if err != nil {
		return ErrDb
	}
	if u == nil {
		return ErrApp
	}

	// Verify credentials
	if !VerifyPassword(hpass, u.Password) {
		return ErrSec
	}

	r.AddSetCookie(a.newUserAuthCookie(u))
	r.AddSetCookie(a.newUserNameCookie(u))
	r.AddSetCookie(a.newUserNymCookie(u))

	r.SetInt("XPad", 0)
	return nil
}

// FollowInfo returns true if the logged user follows the given object
func (a *API) FollowInfo(args *rpc.Args, r *rpc.Ret) (err os.Error) {

	_, uid, err := a.whoAmI(args)
	if err != nil {
		return err
	}
	what, _ := args.QueryString("What")

	follows, err := a.db.IsFollow(uid, what)
	if err != nil {
		follows = false
	}

	n, err := a.db.FollowerCount(what)
	if err != nil {
		return err
	}

	r.SetBool("Follows", follows)
	r.SetInt("Count", n)

	return nil
}

func (a *API) HelloWorld(args *rpc.Args, r *rpc.Ret) os.Error {
	r.SetString("hello", "world")
	return nil
}

func (a *API) Ping(args *rpc.Args, r *rpc.Ret) os.Error {
	r.SetInt("XPad", 0)
	return nil
}