package notify

func (s *ServerCommon) dispatchMsg(message Message) {
	message = hydrateServerMessagePeerFields(message)
	logical := messageLogicalConnSnapshot(&message)
	transport := messageTransportConnSnapshot(&message)
	switch message.TransferMsg.Type {
	case MSG_SYS_WAIT:
		fallthrough
	case MSG_SYS:
		s.sysMsg(message)
		return
	case MSG_KEY_CHANGE:
		if logical != nil {
			logical.rsaDecode(message)
		}
		return
	case MSG_SYS_REPLY:
		fallthrough
	case MSG_SYNC_REPLY:
		scopes := serverTransportDeliveryScopes(logical)
		if transport != nil {
			scopes = serverTransportDeliveryScopesForTransport(transport)
		}
		if s.getPendingWaitPool().deliverWithScopes(message.TransferMsg.ID, scopes, message) {
			return
		}
		fallthrough
	default:
	}
	if s.dispatchInternalTransferControl(message) {
		return
	}
	callFn := func(fn func(*Message)) {
		fn(&message)
	}
	fn, ok := s.linkFns[message.TransferMsg.Key]
	if ok {
		callFn(fn)
	}
	if s.defaultFns != nil {
		callFn(s.defaultFns)
	}
}

func (s *ServerCommon) sysMsg(message Message) {
	if s.handleBulkAttachSystemMessage(message) {
		return
	}
	if s.handlePeerAttachSystemMessage(message) {
		return
	}
	logical := messageLogicalConnSnapshot(&message)
	switch message.Key {
	case "bye":
		if message.TransferMsg.Type == MSG_SYS_WAIT {
			message.Reply(nil)
		}
		s.stopLogicalSession(logical, "recv stop signal from client", nil)
	case "heartbeat":
		if logical != nil {
			logical.markHeartbeatNow()
		}
		message.Reply(nil)
	}
}