// Resolve the channel, then connect: one call registers the live listener AND
// returns initial history.
pBCWrapper->getChatService()->getChannelId(
    "gl", CHAT_CHANNEL_SUB_ID,
    new BCCallback(
        [](const Json::Value &result) {
            std::string channelId = result["data"]["channelId"].asString();
            pBCWrapper->getChatService()->channelConnect(
                channelId, 30,
                new BCCallback(
                    [channelId](const Json::Value &connectResult) {
                        s_chatChannelId = channelId;
                        for (const auto &m : connectResult["data"]["messages"])
                            s_chatMessages.push_back(parseChatMessage(m));
                        std::reverse(s_chatMessages.begin(), s_chatMessages.end());
                    }, nullptr));
        }, nullptr));

// Registered once, alongside the lobby RTT callback, wherever RTT gets enabled
pBCWrapper->getRTTService()->registerRTTChatCallback(&bcRTTCallback);

// Dispatched from the app's central RTT callback when eventJson["service"] == "chat"
void chat_onRTTChatEvent(const Json::Value &eventJson)
{
    if (eventJson["operation"].asString() != "INCOMING") return;
    s_chatMessages.push_back(parseChatMessage(eventJson["data"]));
}

// Send: no re-fetch; the message arrives back via chat_onRTTChatEvent like anyone else's
pBCWrapper->getChatService()->postChatMessageSimple(s_chatChannelId.c_str(), s_chatInputBuf, true, nullptr);

const CHAT_CHANNEL_TYPE = 'gl'
const CHAT_CHANNEL_SUB_ID = 'gl' // must be pre-registered in Portal > Messaging > Chat Channels

bcWrapper.chat.getChannelId(CHAT_CHANNEL_TYPE, CHAT_CHANNEL_SUB_ID, result => {
  if (result.status === 200 && result.data.channelId) this.connectChannel(result.data.channelId)
})

connectChannel (channelId) {
  this.props.bcWrapper.chat.channelConnect(channelId, 30, result => {
    const messages = result.data.messages.slice().reverse().map(m => ({
      fromName: (m.from && m.from.name) || 'Player',
      text: (m.content && m.content.text) || ''
    }))
    this.props.bcWrapper.rttService.registerRTTChatCallback(this.onRTTChatEvent)
    this.setState({ channelId, messages })
  })
}

// Only "INCOMING" is handled
onRTTChatEvent (result) {
  if (result.operation !== 'INCOMING') return
  const m = result.data || {}
  this.setState({ messages: this.state.messages.concat([{
    fromName: (m.from && m.from.name) || 'Player',
    text: (m.content && m.content.text) || ''
  }]) })
}

// send: no re-fetch; delivered back via onRTTChatEvent
bcWrapper.chat.postChatMessageSimple(channelId, input, true, () => {})

_bc.ChatService.GetChannelId(ChannelType, ChannelSubId, (jsonResponse, cbObject) => {
    var channelId = /* parse data.channelId */ "";
    ConnectChannel(channelId);
}, (status, reasonCode, jsonError, cbObject) => { _retryAtSec = _clock + RetryBackoffSec; });

void ConnectChannel(string channelId) {
    _bc.ChatService.ChannelConnect(channelId, MaxHistory, (jsonResponse, cbObject) => {
        _channelId = channelId;
        // ...replay data.messages, oldest-first...
        _bc.RTTService.RegisterRTTChatCallback(OnRttChatEvent);
    }, (status, reasonCode, jsonError, cbObject) => { });
}

// Only "INCOMING" is handled
void OnRttChatEvent(string jsonResponse) {
    var msg = /* deserialize */;
    if (msg["operation"] as string != "INCOMING") return;
    AddMessageRowFromWire(msg["data"] as Dictionary<string, object>);
}

// send: no re-fetch; delivered back via OnRttChatEvent
_bc.ChatService.PostChatMessageSimple(_channelId, text, true, (jsonResponse, cbObject) => { }, (status, reasonCode, jsonError, cbObject) => { });

var result: Dictionary = await AppState.bc.chat_service.get_channel_id(_CHANNEL_TYPE, _CHANNEL_SUB_ID)
var channel_id: String = result.get("data", {}).get("channelId", "")

var connect_result: Dictionary = await AppState.bc.chat_service.channel_connect(channel_id, 30)
# connect_result.data.messages is the one-time initial history; everything after
# arrives via _on_rtt_chat_event, already chronological, so it's only ever appended.
AppState.bc.rtt_service.register_rtt_chat_callback(_on_rtt_chat_event)

# Live push for the global chat channel, delivered to every connected member including the sender
func _on_rtt_chat_event(msg: Dictionary) -> void:
    if msg.get("operation", "") != "INCOMING":
        return
    var data: Dictionary = msg.get("data", {})
    AppState.global_chat_history.append({
        "from_name": data.get("from", {}).get("name", "Player"),
        "text": data.get("content", {}).get("text", ""),
    })

# send: no re-fetch; delivered back via _on_rtt_chat_event
await AppState.bc.chat_service.post_chat_message_simple(_channel_id, text, true)