func HandleSocket(s *glue.Socket) {
	s.OnClose(func() {
		err := UnsubscribeAll(s)
		if err != nil {
			log.Print(err)
		}
	})

	s.OnRead(func(data string) {
		fields := strings.Fields(data)
		if len(fields) == 0 {
			return
		}
		switch fields[0] {
		case "watch":
			if len(fields) != 2 {
				return
			}
			err := Subscribe(s, fields[1])
			if err != nil {
				log.Print(err)
			}

		case "touch":
			if len(fields) != 4 {
				return
			}
			err := Emit(fields[1], "touch:"+fields[2]+","+fields[3])
			if err != nil {
				log.Print(err)
			}
		}
	})
}

func (h *Hub) HandleSocket(sock *glue.Socket) {
	sock.OnClose(func() {
		h.nexus.detach(sock)
	})

	sock.OnRead(func(data string) {
		fields := strings.SplitN(data, " ", 2)
		if len(fields) != 2 {
			return
		}
		switch fields[0] {
		case "attach":
			h.attachInCh <- AttachIn{
				Socket: sock,
				Token:  fields[1],
			}

		case "change":
			data := ChangeData{}
			err := json.Unmarshal([]byte(fields[1]), &data)
			if err != nil {
				h.sendError(sock, "bad request")
				return
			}

			h.changeInCh <- ChangeIn{
				Socket: sock,
				Change: data.Change(),
			}
		}
	})
}

// ConnectPlayer handles connecting a new player to the game
func (s *Server) ConnectPlayer(socket *glue.Socket) {
	// Logging
	log15.Debug("socket connected", "address", socket.RemoteAddr())
	socket.OnClose(func() {
		log15.Debug("socket closed", "address", socket.RemoteAddr())
	})

	// Attempt to allocate free player Slot
	if slot := s.nextSlot(); slot != -1 {
		log15.Info("Accepting new player connection", "slot", slot)
		s.ConnectedPlayers[slot] = &Player{
			Server: s,
			Slot:   slot,
			Socket: socket,
		}
		s.ConnectedPlayers[slot].Socket.OnClose(func() {
			log15.Debug("socket closed", "address", socket.RemoteAddr())
			s.DisconnectPlayer(slot)
		})
		s.NumConnectedPlayers++
		s.ConnectedPlayers[slot].Socket.Write(msg.SConnected)
		s.ConnectedPlayers[slot].Socket.Write(msg.SDisplayMessage + ":Press [SPACEBAR] To Spawn!")
		go s.ConnectedPlayers[slot].ReadLoop()

	} else {
		// No free slots available
		log15.Info("Rejecting new player connection: Server is full!")
		socket.Write(msg.SGameFull)
	}
}

func onNewSocket(s *glue.Socket) {
	// Set a function which is triggered as soon as the socket is closed.
	s.OnClose(func() {
		log.Printf("socket closed with remote address: %s", s.RemoteAddr())
	})

	// Set a function which is triggered during each received message.
	s.OnRead(func(data string) {
		// Echo the received data back to the client.
		s.Write(data)
	})

	// Send a welcome string to the client.
	s.Write("Hello Client")
}

func readLoop(s *glue.Socket) {
	for {
		// Wait for available data.
		// Optional: pass a timeout duration to read.
		data, err := s.Read()
		if err != nil {
			// Just return and release this goroutine if the socket was closed.
			if err == glue.ErrSocketClosed {
				return
			}

			log.Printf("read error: %v", err)
			continue
		}

		// Echo the received data back to the client.
		s.Write(data)
	}
}

func onNewSocket(s *glue.Socket) {
	s.OnRead(func(data string) {
		// Echo back.
		s.Write(data)
	})

	s.OnClose(func() {
		println("closed")
	})

	s.Write("Hello Client")
}

func onNewSocket(s *glue.Socket) {
	// Set a function which is triggered as soon as the socket is closed.
	s.OnClose(func() {
		log.Printf("socket closed with remote address: %s", s.RemoteAddr())
	})

	// Discard all reads.
	// If received data is not discarded, then the read buffer will block as soon
	// as it is full, which will also block the keep-alive mechanism of the socket.
	// The result would be a closed socket...
	s.DiscardRead()

	// Send a welcome string to the client.
	s.Write("Hello Client")
}

// onNewSocket is triggered as soon as a new socket connects.
func onNewSocket(s *glue.Socket) {
	// Create the BitMonster Socket value.
	socket := &Socket{
		socket:        s,
		chanCall:      s.Channel(channelCall),
		chanEvent:     s.Channel(channelEvent),
		values:        make(map[interface{}]interface{}),
		valueTimeouts: make(map[interface{}]*time.Timer),
	}

	// Save itself to the glue Value.
	s.Value = socket

	// Set the emitter.
	// Create a new emitter, set the recover function and the max listeners.
	socket.emitter = emission.NewEmitter().
		RecoverWith(recoverEmitter).
		SetMaxListeners(emitterMaxListeners)

	// We won't read any data from the socket itself.
	// Discard the received data!
	s.DiscardRead()

	// Set the function which is triggered as soon as the socket is closed.
	s.OnClose(func() {
		onCloseSocket(socket)
	})

	// Prepare the call channel.
	socket.chanCall.OnRead(func(data string) {
		// Trigger the call request.
		handleCallRequest(socket, data)
	})

	// Prepare the event channel.
	socket.chanEvent.OnRead(func(data string) {
		// Trigger the event request.
		handleEventRequest(socket, data)
	})

	// Trigger the event.
	emitter.Emit(emitterOnNewSocket, socket)
}

func (h *Hub) sendError(sock *glue.Socket, msg string) {
	sock.Write("error " + strconv.Quote(msg))
}