// NewGroup creates a group
func (self *Client) NewGroup(id, action, target int32) error {
	dumpReq := osc.NewMessage("/g_new")
	dumpReq.Append(id)
	dumpReq.Append(action)
	dumpReq.Append(target)
	return self.oscServer.SendTo(self.addr, dumpReq)
}

// SendDef sends a synthdef to scsynth.
// This method blocks until a /done message is received
// indicating that the synthdef was loaded
func (self *Client) SendDef(def *Synthdef) error {
	msg := osc.NewMessage("/d_recv")
	db, err := def.Bytes()
	if err != nil {
		return err
	}
	msg.Append(db)
	self.oscServer.SendTo(self.addr, msg)
	var done *osc.Message
	select {
	case done = <-self.doneChan:
		goto ParseMessage
	case err = <-self.oscErrChan:
		return err
	}

ParseMessage:
	// error if this message was not an ack of the synthdef
	errmsg := "expected /done with /d_recv argument"
	if done.CountArguments() != 1 {
		return fmt.Errorf(errmsg)
	}
	if addr, isString := done.Arguments[0].(string); !isString || addr != "/d_recv" {
		return fmt.Errorf(errmsg)
	}
	return nil
}

// Send a /quit message to scsynth
func main() {
	addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:57130")
	if err != nil {
		log.Fatal(err)
	}
	oscServer := osc.NewServer(listenAddr, listenPort)
	errChan := make(chan error)
	doneChan := make(chan *osc.Message)
	err = oscServer.AddMsgHandler("/done", func(msg *osc.Message) {
		doneChan <- msg
	})
	if err != nil {
		log.Println("could not send quit message")
		log.Fatal(err)
	}
	go func() {
		errChan <- oscServer.ListenAndDispatch()
	}()
	err = <-oscServer.Listening
	if err != nil {
		log.Fatal(err)
	}
	log.Println("sending quit request")
	quitReq := osc.NewMessage("/quit")
	err = oscServer.SendTo(addr, quitReq)
	if err != nil {
		log.Fatal(err)
	}
	select {
	case quitResp := <-doneChan:
		osc.PrintMessage(quitResp)
	case err := <-errChan:
		log.Fatal(err)
	}
}

// FreeAll frees all nodes in a group
func (self *Client) FreeAll(gids ...int32) error {
	freeReq := osc.NewMessage(groupFreeAllAddress)
	for _, gid := range gids {
		freeReq.Append(gid)
	}
	return self.oscServer.SendTo(self.conn, freeReq)
}

// Gen generates a buffer using a routine.
// A runtime panic will occur if routine is not one of the
// BufferRoutine constants.
func (self *Buffer) Gen(routine string, flags int, args ...float32) error {
	if err := checkBufferRoutine(routine); err != nil {
		return err
	}
	if err := checkBufferGenFlags(flags); err != nil {
		return err
	}

	pat := bufferGenAddress
	gen, err := osc.NewMessage(pat)
	if err != nil {
		return err
	}
	if err := gen.WriteInt32(self.Num); err != nil {
		return err
	}
	if err := gen.WriteString(routine); err != nil {
		return err
	}
	if err := gen.WriteInt32(int32(flags)); err != nil {
		return err
	}
	for _, arg := range args {
		if err := gen.WriteFloat32(arg); err != nil {
			return err
		}
	}
	if err := self.client.oscConn.Send(gen); err != nil {
		return err
	}

	var done *osc.Message
	select {
	case done = <-self.client.doneChan:
	case err = <-self.client.oscErrChan:
		return err
	}

	if done.CountArguments() != 2 {
		return errors.New("expected two arguments to /done message")
	}
	_, err = done.ReadString()
	if err != nil {
		return err
	}
	bufnum, err := done.ReadInt32()
	if err != nil {
		return err
	}

	// TODO:
	// Don't error if we get a done message for a different buffer.
	// We should probably requeue this particular done message on doneChan.
	if bufnum != self.Num {
		m := "expected done message for buffer %d, but got one for buffer %d"
		return fmt.Errorf(m, self.Num, bufnum)
	}

	return nil
}

// Synth creates a synth node.
func (self *Client) Synth(defName string, id, action, target int32, ctls map[string]float32) (*Synth, error) {
	synthReq, err := osc.NewMessage(synthNewAddress)
	if err != nil {
		return nil, err
	}
	if err := synthReq.WriteString(defName); err != nil {
		return nil, err
	}
	if err := synthReq.WriteInt32(id); err != nil {
		return nil, err
	}
	if err := synthReq.WriteInt32(action); err != nil {
		return nil, err
	}
	if err := synthReq.WriteInt32(target); err != nil {
		return nil, err
	}
	if ctls != nil {
		for k, v := range ctls {
			if err := synthReq.WriteString(k); err != nil {
				return nil, err
			}
			if err := synthReq.WriteFloat32(v); err != nil {
				return nil, err
			}
		}
	}
	if err := self.oscConn.Send(synthReq); err != nil {
		return nil, err
	}
	return newSynth(self, defName, id), nil
}

// FreeAll frees all nodes in a group
func (self *Client) FreeAll(gids ...int32) error {
	freeReq := osc.NewMessage("/g_freeAll")
	for _, gid := range gids {
		freeReq.Append(gid)
	}
	return self.oscServer.SendTo(self.addr, freeReq)
}

// Set the value of a synth control.
func (self *Synth) Set(ctls map[string]float32) error {
	set := osc.NewMessage(setSynthNodeAddress)
	set.Append(self.id)
	for name, value := range ctls {
		set.Append(name, value)
	}
	return self.client.oscServer.SendTo(self.client.conn, set)
}

// NewSynth creates a synth
func (self *Client) NewSynth(name string, id, action, target int32) error {
	synthReq := osc.NewMessage("/s_new")
	synthReq.Append(name)
	synthReq.Append(id)
	synthReq.Append(action)
	synthReq.Append(target)
	synthReq.Append(int32(0))
	return self.oscServer.SendTo(self.addr, synthReq)
}

// Free a synth node.
func (self *Synth) Free() error {
	free, err := osc.NewMessage(freeSynthNodeAddress)
	if err != nil {
		return err
	}
	if err := free.WriteInt32(self.id); err != nil {
		return err
	}
	return self.client.oscConn.Send(free)
}

// DumpOSC sends a /dumpOSC message to scsynth
// level should be DumpOff, DumpParsed, DumpContents, DumpAll
func (self *Client) DumpOSC(level int32) error {
	dumpReq, err := osc.NewMessage(dumpOscAddress)
	if err != nil {
		return err
	}
	if err := dumpReq.WriteInt32(level); err != nil {
		return err
	}
	return self.oscConn.Send(dumpReq)
}

// NewGroup creates a group
func (self *Client) Group(id, action, target int32) (*Group, error) {
	dumpReq := osc.NewMessage(groupNewAddress)
	dumpReq.Append(id)
	dumpReq.Append(action)
	dumpReq.Append(target)
	err := self.oscServer.SendTo(self.conn, dumpReq)
	if err != nil {
		return nil, err
	}
	return newGroup(self, id), nil
}

// QueryGroup g_queryTree for a particular group
func (self *Client) QueryGroup(id int32) (*group, error) {
	addr := "/g_queryTree"
	gq := osc.NewMessage(addr)
	gq.Append(int32(RootNodeID))
	err := self.oscServer.SendTo(self.addr, gq)
	if err != nil {
		return nil, err
	}
	// wait for response
	resp := <-self.gqueryTreeChan
	return parseGroup(resp)
}

// FreeAll frees all nodes in a group
func (self *Client) FreeAll(gids ...int32) error {
	freeReq, err := osc.NewMessage(groupFreeAllAddress)
	if err != nil {
		return err
	}
	for _, gid := range gids {
		if err := freeReq.WriteInt32(gid); err != nil {
			return err
		}
	}
	return self.oscConn.Send(freeReq)
}

// AllocBuffer allocates a buffer on the server
func (self *Client) AllocBuffer(frames, channels int) (*Buffer, error) {
	buf := newBuffer(self)
	pat := bufferAllocAddress
	alloc, err := osc.NewMessage(pat)
	if err != nil {
		return nil, err
	}
	if err := alloc.WriteInt32(buf.Num); err != nil {
		return nil, err
	}
	if err := alloc.WriteInt32(int32(frames)); err != nil {
		return nil, err
	}
	if err := alloc.WriteInt32(int32(channels)); err != nil {
		return nil, err
	}
	if err := self.oscConn.Send(alloc); err != nil {
		return nil, err
	}

	var done *osc.Message
	select {
	case done = <-self.doneChan:
		break
	case err = <-self.oscErrChan:
		return nil, err
	}

	// error if this message was not an ack of the synthdef
	if done.CountArguments() != 2 {
		return nil, fmt.Errorf("expected two arguments to /done message")
	}
	addr, err := done.ReadString()
	if err != nil {
		return nil, err
	}
	if addr != pat {
		return nil, fmt.Errorf("expected first argument to be %s but got %s", pat, addr)
	}
	bufnum, err := done.ReadInt32()
	if err != nil {
		return nil, err
	}
	// TODO:
	// Don't error if we get a done message for a different buffer.
	// We should probably requeue this particular done message on doneChan.
	if bufnum != buf.Num {
		m := "expected done message for buffer %d, but got one for buffer %d"
		return nil, fmt.Errorf(m, buf.Num, bufnum)
	}
	return buf, nil
}

// Status gets the status of scsynth
func (self *Client) Status() (*ServerStatus, error) {
	statusReq := osc.NewMessage("/status")
	err := self.oscServer.SendTo(self.addr, statusReq)
	if err != nil {
		return nil, err
	}
	select {
	case msg := <-self.statusChan:
		return newStatus(msg)
	case err = <-self.oscErrChan:
		return nil, err
	}
}

// ReadBuffer tells the server to read an audio file and
// load it into a buffer
func (self *Client) ReadBuffer(path string, num int32) (*Buffer, error) {
	allocRead, err := osc.NewMessage(bufferReadAddress)
	if err != nil {
		return nil, err
	}

	buf := newReadBuffer(path, num, self)
	if err := allocRead.WriteInt32(buf.Num); err != nil {
		return nil, err
	}
	if err := allocRead.WriteString(path); err != nil {
		return nil, err
	}
	if err := self.oscConn.Send(allocRead); err != nil {
		return nil, err
	}

	var done *osc.Message
	select {
	case done = <-self.doneChan:
	case err = <-self.oscErrChan:
		return nil, err
	}

	// error if this message was not an ack of the buffer read
	if done.CountArguments() != 2 {
		return nil, fmt.Errorf("expected two arguments to /done message")
	}
	addr, err := done.ReadString()
	if err != nil {
		return nil, err
	}
	if addr != bufferReadAddress {
		return nil, fmt.Errorf("expected first argument to be %s but got %s", bufferReadAddress, addr)
	}
	bufnum, err := done.ReadInt32()
	if err != nil {
		return nil, err
	}
	// TODO:
	// Don't error if we get a done message for a different buffer.
	// We should probably requeue this particular done message on doneChan.
	if bufnum != buf.Num {
		m := "expected done message for buffer %d, but got one for buffer %d"
		return nil, fmt.Errorf(m, buf.Num, bufnum)
	}
	return buf, nil
}

// QueryGroup g_queryTree for a particular group
func (self *Client) QueryGroup(id int32) (*Group, error) {
	addr := gqueryTreeAddress
	gq, err := osc.NewMessage(addr)
	if err != nil {
		return nil, err
	}
	if err := gq.WriteInt32(int32(RootNodeID)); err != nil {
		return nil, err
	}
	if err := self.oscConn.Send(gq); err != nil {
		return nil, err
	}
	// wait for response
	resp := <-self.gqueryTreeChan
	return parseGroup(resp)
}

// defaultGroupExists figures out whether or not the default group exists
func (self *Client) defaultGroupExists() (bool, error) {
	addr := "/g_queryTree"
	gq := osc.NewMessage(addr)
	gq.Append(int32(RootNodeID))
	err := self.oscServer.SendTo(self.addr, gq)
	if err != nil {
		return false, err
	}
	// wait for response
	resp := <-self.gqueryTreeChan
	_, err = parseGroup(resp)
	if err != nil {
		return false, err
	}
	return false, nil
}

// Gen generates a buffer using a routine.
// A runtime panic will occur if routine is not one of the
// BufferRoutine constants.
func (self *buffer) Gen(routine string, flags int, args ...float32) error {
	checkBufferRoutine(routine)
	checkBufferGenFlags(flags)
	pat := bufferGenAddress
	gen := osc.NewMessage(pat)
	gen.Append(self.Num())
	gen.Append(routine)
	gen.Append(int32(flags))
	for _, arg := range args {
		gen.Append(arg)
	}
	err := self.c.oscServer.SendTo(self.c.conn, gen)
	if err != nil {
		return err
	}

	var done *osc.Message
	select {
	case done = <-self.c.doneChan:
		break
	case err = <-self.c.oscErrChan:
		return err
	}

	if done.CountArguments() != 2 {
		return fmt.Errorf("expected two arguments to /done message")
	}
	if addr, isString := done.Arguments[0].(string); !isString || addr != pat {
		return fmt.Errorf("expected first argument to be %s but got %s", pat, addr)
	}
	var bufnum int32
	var isInt32 bool
	if bufnum, isInt32 = done.Arguments[1].(int32); !isInt32 {
		m := "expected int32 as second argument, but got %s (%v)"
		return fmt.Errorf(m, reflect.TypeOf(done.Arguments[1]), done.Arguments[1])
	}
	// TODO:
	// Don't error if we get a done message for a different buffer.
	// We should probably requeue this particular done message on doneChan.
	if bufnum != self.Num() {
		m := "expected done message for buffer %d, but got one for buffer %d"
		return fmt.Errorf(m, self.Num(), bufnum)
	}

	return nil
}