// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "channel_manager.h"

#include <fbl/function.h>
#include <lib/async/cpp/task.h>
#include <lib/async/default.h>

#include "src/connectivity/bluetooth/core/bt-host/common/log.h"
#include "src/connectivity/bluetooth/core/bt-host/l2cap/l2cap.h"

#include "session.h"

namespace bt {
namespace rfcomm {

ChannelManager::ChannelManager(OnL2capConnectionRequest l2cap_delegate)
    : dispatcher_(async_get_default_dispatcher()),
      l2cap_delegate_(std::move(l2cap_delegate)),
      weak_ptr_factory_(this) {
  ZX_DEBUG_ASSERT(l2cap_delegate_);
}

bool ChannelManager::RegisterL2CAPChannel(
    fbl::RefPtr<l2cap::Channel> l2cap_channel) {
  auto handle = l2cap_channel->link_handle();

  if (handle_to_session_.find(handle) != handle_to_session_.end()) {
    bt_log(WARN, "rfcomm",
           "L2CAP channel for link (handle: %#.4x) already registered", handle);
    return false;
  }

  auto session = Session::Create(
      l2cap_channel, fit::bind_member(this, &ChannelManager::ChannelOpened));
  if (!session) {
    bt_log(ERROR, "rfcomm",
           "could not start session on the given L2CAP channel");
    return false;
  }
  handle_to_session_[handle] = std::move(session);
  return true;
}

void ChannelManager::OpenRemoteChannel(hci::ConnectionHandle handle,
                                       ServerChannel server_channel,
                                       ChannelOpenedCallback channel_opened_cb,
                                       async_dispatcher_t* dispatcher) {
  ZX_DEBUG_ASSERT(channel_opened_cb);
  ZX_DEBUG_ASSERT(dispatcher);

  auto session_it = handle_to_session_.find(handle);
  if (session_it == handle_to_session_.end()) {
    l2cap_delegate_(
        handle,
        [this, handle, server_channel, dispatcher,
         cb = std::move(channel_opened_cb)](auto l2cap_channel) mutable {
          if (!l2cap_channel) {
            bt_log(ERROR, "rfcomm",
                   "failed to open L2CAP channel with handle %#.4x", handle);
            async::PostTask(dispatcher, [cb_ = std::move(cb)] {
              cb_(nullptr, kInvalidServerChannel);
            });
            return;
          }

          bt_log(INFO, "rfcomm", "opened L2CAP session with handle %#.4x",
                 handle);
          ZX_DEBUG_ASSERT(handle_to_session_.find(handle) ==
                          handle_to_session_.end());

          handle_to_session_.emplace(
              handle,
              Session::Create(
                  l2cap_channel,
                  fbl::BindMember(this, &ChannelManager::ChannelOpened)));

          // Re-run OpenRemoteChannel now that the session is opened.
          async::PostTask(dispatcher_,
                          [this, handle, server_channel, dispatcher,
                           cb_ = std::move(cb)]() mutable {
                            OpenRemoteChannel(handle, server_channel,
                                              std::move(cb_), dispatcher);
                          });
        });
    return;
  }

  ZX_DEBUG_ASSERT(session_it != handle_to_session_.end());

  session_it->second->OpenRemoteChannel(
      server_channel, [cb = std::move(channel_opened_cb), dispatcher](
                          auto rfcomm_channel, auto server_channel) mutable {
        async::PostTask(dispatcher, [cb_ = std::move(cb), rfcomm_channel,
                                     server_channel]() {
          cb_(rfcomm_channel, server_channel);
        });
      });
}

ServerChannel ChannelManager::AllocateLocalChannel(
    ChannelOpenedCallback cb, async_dispatcher_t* dispatcher) {
  // Find the first free Server Channel and allocate it.
  for (ServerChannel server_channel = kMinServerChannel;
       server_channel <= kMaxServerChannel; ++server_channel) {
    if (server_channels_.find(server_channel) == server_channels_.end()) {
      server_channels_[server_channel] =
          std::make_pair(std::move(cb), dispatcher);
      return server_channel;
    }
  }

  return kInvalidServerChannel;
}

void ChannelManager::ChannelOpened(fbl::RefPtr<Channel> rfcomm_channel,
                                   ServerChannel server_channel) {
  auto server_channel_it = server_channels_.find(server_channel);
  ZX_DEBUG_ASSERT_MSG(server_channel_it != server_channels_.end(),
                      "new channel created on an unallocated Server Channel");

  async::PostTask(server_channel_it->second.second,
                  [server_channel, rfcomm_channel,
                   cb = server_channel_it->second.first.share()]() {
                    cb(rfcomm_channel, server_channel);
                  });
}

}  // namespace rfcomm
}  // namespace bt