/*
 * Copyright 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <unordered_map>

#include "common/bind.h"
#include "l2cap/internal/basic_mode_channel_data_controller.h"
#include "l2cap/internal/enhanced_retransmission_mode_channel_data_controller.h"
#include "l2cap/internal/le_credit_based_channel_data_controller.h"
#include "l2cap/internal/scheduler.h"
#include "l2cap/internal/sender.h"
#include "os/handler.h"
#include "os/log.h"

namespace bluetooth {
namespace l2cap {
namespace internal {

Sender::Sender(os::Handler* handler, ILink* link, Scheduler* scheduler, std::shared_ptr<ChannelImpl> channel)
    : handler_(handler), link_(link), queue_end_(channel->GetQueueDownEnd()), scheduler_(scheduler),
      channel_id_(channel->GetCid()), remote_channel_id_(channel->GetRemoteCid()),
      data_controller_(std::make_unique<BasicModeDataController>(channel_id_, remote_channel_id_, queue_end_, handler_,
                                                                 scheduler_)) {
  try_register_dequeue();
}

Sender::Sender(os::Handler* handler, ILink* link, Scheduler* scheduler, std::shared_ptr<ChannelImpl> channel,
               ChannelMode mode)
    : handler_(handler), link_(link), queue_end_(channel->GetQueueDownEnd()), scheduler_(scheduler),
      channel_id_(channel->GetCid()), remote_channel_id_(channel->GetRemoteCid()) {
  if (mode == ChannelMode::BASIC) {
    data_controller_ =
        std::make_unique<BasicModeDataController>(channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
  } else if (mode == ChannelMode::ERTM) {
    data_controller_ =
        std::make_unique<ErtmController>(link_, channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
  } else if (mode == ChannelMode::LE_CREDIT_BASED) {
    data_controller_ = std::make_unique<LeCreditBasedDataController>(link_, channel_id_, remote_channel_id_, queue_end_,
                                                                     handler_, scheduler_);
  }
  try_register_dequeue();
}

Sender::~Sender() {
  if (is_dequeue_registered_.exchange(false)) {
    queue_end_->UnregisterDequeue();
  }
}

void Sender::OnPacketSent() {
  link_->OnPendingPacketChange(channel_id_, false);
  try_register_dequeue();
}

std::unique_ptr<Sender::UpperDequeue> Sender::GetNextPacket() {
  return data_controller_->GetNextPacket();
}

DataController* Sender::GetDataController() {
  return data_controller_.get();
}

void Sender::try_register_dequeue() {
  if (is_dequeue_registered_.exchange(true)) {
    return;
  }
  queue_end_->RegisterDequeue(handler_, common::Bind(&Sender::dequeue_callback, common::Unretained(this)));
}

// From external context
void Sender::dequeue_callback() {
  auto packet = queue_end_->TryDequeue();
  ASSERT(packet != nullptr);
  handler_->Post(
      common::BindOnce(&DataController::OnSdu, common::Unretained(data_controller_.get()), std::move(packet)));
  if (is_dequeue_registered_.exchange(false)) {
    queue_end_->UnregisterDequeue();
  }
  link_->OnPendingPacketChange(channel_id_, true);
}

void Sender::UpdateClassicConfiguration(classic::internal::ChannelConfigurationState config) {
  auto mode = config.retransmission_and_flow_control_mode_;
  if (mode == mode_) {
    return;
  }
  if (mode == RetransmissionAndFlowControlModeOption::L2CAP_BASIC) {
    data_controller_ =
        std::make_unique<BasicModeDataController>(channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
    return;
  }
  if (mode == RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION) {
    data_controller_ =
        std::make_unique<ErtmController>(link_, channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
    RetransmissionAndFlowControlConfigurationOption option = config.local_retransmission_and_flow_control_;
    option.tx_window_size_ = config.remote_retransmission_and_flow_control_.tx_window_size_;
    data_controller_->SetRetransmissionAndFlowControlOptions(option);
    data_controller_->EnableFcs(config.fcs_type_ == FcsType::DEFAULT);
    return;
  }
}

}  // namespace internal
}  // namespace l2cap
}  // namespace bluetooth