// Copyright 2021 The Chromium OS 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 <algorithm>
#include <array>
#include <utility>
#include <base/bind.h>
#include <base/logging.h>
#include <glib.h>
#include <gio/gio.h>
#include <gmodule.h>
#include <gio/gunixsocketaddress.h>
#include <libmbim-glib/libmbim-glib.h>
#include "hermes/apdu.h"
#include "hermes/euicc_manager_interface.h"
#include "hermes/hermes_common.h"
#include "hermes/modem_mbim.h"
#include "hermes/sgp_22.h"
#include "hermes/type_traits.h"

namespace {
const int kExecutorIndex = 0;
const guint kMbimTimeoutSeconds = 30;
constexpr int kMbimMessageSuccess = 144;
constexpr auto kSlotInfoDelay = base::Seconds(5);
// Application identifier for the eUICC's SIM EID
const std::array<uint8_t, 12> kMbimEidReqApdu = {
    0x81, 0xE2, 0x91, 0x00, 0x06, 0xBF, 0x3E, 0x03, 0x5C, 0x01, 0x5A, 0x00,
};

// ModemManager uses channel_group=1. Make Hermes use 2 just to be cautious.
constexpr int kChannelGroupId = 2;
std::vector<uint8_t> AidIsdr() {
  return {hermes::kAidIsdr.begin(), hermes::kAidIsdr.end()};
}

bool GetReadyState(MbimDevice* device,
                   bool is_notification,
                   MbimMessage* notification,
                   MbimSubscriberReadyState* ready_state) {
  g_autoptr(GError) error = NULL;

  if (mbim_device_check_ms_mbimex_version(device, 3, 0)) {
    MbimSubscriberReadyStatusFlag flags =
        MBIM_SUBSCRIBER_READY_STATUS_FLAG_NONE;
    auto parser_v3 =
        is_notification
            ? &mbim_message_ms_basic_connect_v3_subscriber_ready_status_notification_parse
            : &mbim_message_ms_basic_connect_v3_subscriber_ready_status_response_parse;
    if (!parser_v3(notification, ready_state, &flags, NULL, NULL,
                   NULL, /* ready_info */
                   NULL, /* telephone_numbers_count */
                   NULL, /* telephone_numbers */
                   &error)) {
      LOG(ERROR) << __func__ << ": Failed due to error: " << error->message;
      return false;
    }
  } else {
    auto parser = is_notification
                      ? &mbim_message_subscriber_ready_status_notification_parse
                      : &mbim_message_subscriber_ready_status_response_parse;
    if (!parser(notification, ready_state,
                /* subscriber_id */ NULL,
                /* sim_iccid */ NULL,
                /* ready_info */ NULL,
                /* telephone_numbers_count */ NULL,
                /* telephone_numbers */ NULL, &error)) {
      LOG(ERROR) << __func__ << ": Failed due to error: " << error->message;
      return false;
    }
  }
  return true;
}

}  // namespace

namespace hermes {

/* static */
std::unique_ptr<ModemMbim> ModemMbim::Create(
    Logger* logger,
    Executor* executor,
    std::unique_ptr<ModemManagerProxy> modem_manager_proxy) {
  VLOG(2) << __func__;
  return std::unique_ptr<ModemMbim>(
      new ModemMbim(logger, executor, std::move(modem_manager_proxy)));
}

ModemMbim::ModemMbim(Logger* logger,
                     Executor* executor,
                     std::unique_ptr<ModemManagerProxy> modem_manager_proxy)
    : Modem<MbimCmd>(logger, executor, std::move(modem_manager_proxy)),
      channel_(kInvalidChannel),
      is_ready_state_valid(false),
      ready_state_(MBIM_SUBSCRIBER_READY_STATE_NOT_INITIALIZED),
      slot_info_(),
      weak_factory_(this) {}

ModemMbim::~ModemMbim() {
  VLOG(2) << "~ModemMbim Destructor++";
  Shutdown();
}

void ModemMbim::Initialize(EuiccManagerInterface* euicc_manager,
                           ResultCallback cb) {
  LOG(INFO) << __func__;
  CHECK(current_state_ == State::kMbimUninitialized);
  retry_initialization_callback_.Reset();
  euicc_manager_ = euicc_manager;
  InitializationStep(State::kMbimUninitialized, std::move(cb));
}

void ModemMbim::Shutdown() {
  LOG(INFO) << __func__;
  CloseDevice();
  channel_ = kInvalidChannel;
  ready_state_ = MBIM_SUBSCRIBER_READY_STATE_NOT_INITIALIZED;
  current_state_.Transition(State::kMbimUninitialized);
  slot_info_.Clear();
  eid_read_failed_ = false;
  modem_manager_proxy_->ScheduleUninhibit(base::Seconds(0));
}

void ModemMbim::TransmitFromQueue() {
  VLOG(2) << __func__;
  if (tx_queue_.empty() || retry_initialization_callback_) {
    return;
  }
  if (!device_) {
    LOG(ERROR) << "No MBIM device. Cannot transmit MBIM message";
    ProcessMbimResult(kModemMessageProcessingError);
    return;
  }

  auto mbim_cmd = tx_queue_[0].msg_.get();
  switch (mbim_cmd->mbim_type()) {
    case MbimCmd::MbimType::kMbimOpenChannel:
      TransmitOpenChannel();
      break;
    case MbimCmd::MbimType::kMbimCloseChannel:
      TransmitCloseChannel();
      break;
    case MbimCmd::MbimType::kMbimSendApdu:
      TransmitMbimSendApdu(&tx_queue_[0]);
      break;
    case MbimCmd::MbimType::kMbimSubscriberStatusReady:
      TransmitSubscriberStatusReady();
      break;
    case MbimCmd::MbimType::kMbimDeviceCaps:
      TransmitDeviceCaps();
      break;
    case MbimCmd::MbimType::kMbimSendEidApdu:
      TransmitSendEidApdu();
      break;
    case MbimCmd::MbimType::kMbimSlotInfoStatus:
      TransmitSlotInfoStatus();
      break;
    case MbimCmd::MbimType::kMbimDeviceSlotMapping:
      TransmitDeviceSlotMapping();
      break;
    case MbimCmd::MbimType::kMbimSetDeviceSlotMapping:
      TransmitSetDeviceSlotMapping();
      break;
    case MbimCmd::MbimType::kMbimSysCaps:
      TransmitSysCapsQuery();
      break;
    default:
      VLOG(2) << "no instruction";
      break;
  }
}

std::unique_ptr<MbimCmd> ModemMbim::GetTagForSendApdu() {
  return std::make_unique<MbimCmd>(MbimCmd::MbimType::kMbimSendApdu);
}

void ModemMbim::ProcessMbimResult(int err) {
  if (tx_queue_.empty()) {
    VLOG(2) << __func__ << ": Queue is empty";
    return;
  }
  // pop before running the callback since the callback might change the state
  // of the queue.
  auto cb_ = std::move(tx_queue_[0].cb_);
  tx_queue_.pop_front();
  if (!cb_.is_null()) {
    std::move(cb_).Run(err);
  }
}

/* static */
void ModemMbim::MbimCreateNewDeviceCb(GObject* source,
                                      GAsyncResult* res,
                                      ModemMbim* modem_mbim) {
  /* Open the device */
  VLOG(2) << __func__;
  CHECK(modem_mbim) << "modem_mbim does not exist";
  g_autoptr(GError) error = NULL;
  glib_bridge::ScopedGObject<MbimDevice> mbimdevice(
      mbim_device_new_finish(res, &error));
  modem_mbim->device_ = std::move(mbimdevice);
  if (!modem_mbim->device_.get() || error != NULL) {
    LOG(INFO) << "The modem may be booting ...";
    modem_mbim->RetryInitialization(std::move(modem_mbim->init_done_cb_));
    return;
  }
  mbim_device_open_full(modem_mbim->device_.get(), MBIM_DEVICE_OPEN_FLAGS_PROXY,
                        kMbimTimeoutSeconds, /* cancellable */ NULL,
                        (GAsyncReadyCallback)MbimDeviceOpenReadyCb, modem_mbim);
}

/* static */
void ModemMbim::MbimDeviceOpenReadyCb(MbimDevice* device,
                                      GAsyncResult* res,
                                      ModemMbim* modem_mbim) {
  VLOG(2) << __func__;
  g_autoptr(GError) error = NULL;
  base::OnceCallback<void(base::OnceCallback<void(int)>)> get_caps;
  if (!mbim_device_open_finish(device, res, &error)) {
    LOG(ERROR) << "Failed  due to error: " << error->message;
    modem_mbim->RetryInitialization(std::move(modem_mbim->init_done_cb_));
    return;
  }
  modem_mbim->indication_id_ = g_signal_connect(
      modem_mbim->device_.get(), MBIM_DEVICE_SIGNAL_INDICATE_STATUS,
      G_CALLBACK(ClientIndicationCb), modem_mbim);
  if (modem_mbim->current_state_ == State::kMbimStarted) {
    VLOG(2) << "Opened device. Reusing previous IMEI";
    std::move(modem_mbim->init_done_cb_).Run(kModemSuccess);
    return;
  }
  LOG(INFO) << "Mbim device is ready, acquire imei and eid";
  modem_mbim->InitializationStep(State::kReadImei,
                                 std::move(modem_mbim->init_done_cb_));
}

void ModemMbim::InitializationStep(ModemMbim::State::Value next_state,
                                   ResultCallback cb) {
  // cb is executed only after all initialization steps complete or if there is
  // an error. cb is passed in from Initialize and passed around until the last
  // step. At the last step, the cb is executed.
  current_state_.Transition(next_state);
  switch (next_state) {
    case State::Value::kMbimUninitialized:
      // Store cb in init_done_cb_ so that MbimCreateNewDeviceCb can use it
      // while calling InitializationStep(kGetSubscriberReadyState)
      init_done_cb_ = std::move(cb);
      modem_manager_proxy_->WaitForModem(base::BindOnce(
          &ModemMbim::InitializationStep, weak_factory_.GetWeakPtr(),
          State::kMbimInitializeStarted, std::move(cb)));
      break;
    case State::kMbimInitializeStarted: {
      if (modem_manager_proxy_->GetPrimaryPort().empty()) {
        LOG(ERROR) << __func__ << ": Could not get primary port from MM";
        std::move(init_done_cb_).Run(kModemManagerError);
        break;
      }
      std::string dev_path = "/dev/" + modem_manager_proxy_->GetPrimaryPort();
      const gchar* const path = dev_path.c_str();
      LOG(INFO) << __func__ << ": Opening path:" << path;
      file_ = g_file_new_for_path(path);
      mbim_device_new(file_, /* cancellable */ NULL,
                      (GAsyncReadyCallback)MbimCreateNewDeviceCb,
                      this);  // MbimCreateNewDeviceCb will call
                              // InitializationStep(kReadImei)
      break;
    }
    case State::kReadImei:
      SendMessage(MbimCmd::MbimType::kMbimDeviceCaps,
                  std::make_unique<TxInfo>(), std::move(cb),
                  &ModemMbim::InitializationStep,
                  State::kGetSubscriberReadyState);
      break;
    case State::kGetSubscriberReadyState:
      SendMessage(MbimCmd::MbimType::kMbimSubscriberStatusReady,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::InitializationStep, State::kCheckSingleSim);
      break;
    case State::kCheckSingleSim: {
      if (!mbim_device_check_ms_mbimex_version(device_.get(), 2, 0)) {
        // we have a single sim device. Skip to reading EID if a SIM was seen.
        if (ready_state_ == MBIM_SUBSCRIBER_READY_STATE_SIM_NOT_INSERTED) {
          VLOG(2) << "Sim not inserted";
          // skip retries, close device, listen for a new modem, and run cb
          retry_count_ = kMaxRetries + 1;
          RetryInitialization(std::move(cb));
          break;
        }
        slot_info_.InitSlotInfo(1 /* slot_count */, 1 /* map_count */);
        slot_info_.cached_active_slot_ = 0;
        slot_info_.slot_state_[0] =
            MBIM_UICC_SLOT_STATE_ACTIVE_ESIM;  // Assume we have an eSIM until
                                               // we can confirm the EID. This
                                               // is an mbimv1 limitation.
        InitializationStep(State::kCloseChannel, std::move(cb));
        break;
      }
      InitializationStep(State::kSysQuery, std::move(cb));
      break;
    }
    case State::kSysQuery:
      SendMessage(MbimCmd::MbimType::kMbimSysCaps, std::unique_ptr<TxInfo>(),
                  std::move(cb), &ModemMbim::InitializationStep,
                  State::kDeviceSlotMapping);
      break;
    case State::kDeviceSlotMapping:
      // To figure out active slot
      SendMessage(MbimCmd::MbimType::kMbimDeviceSlotMapping,
                  std::make_unique<SwitchSlotTxInfo>(0), std::move(cb),
                  &ModemMbim::InitializationStep, State::kSlotInfo);
      break;
    case State::kSlotInfo:
      ReadSlotsInfo(
          0 /* slot_num */, 0 /* retry_count */,
          std::move(
              cb));  // ReadSlotsInfo calls InitializationStep(CloseChannel)
                     // after slot info for all slots has been read. This is an
                     // exception to the rule that all state transitions must be
                     // captured in InitializationStep.
      break;
    case State::kCloseChannel:
      if (!slot_info_.IsEsimActive()) {
        InitializationStep(State::kMbimStarted, std::move(cb));
        break;
      }
      SendMessage(MbimCmd::MbimType::kMbimCloseChannel,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::InitializationStep, State::kOpenChannel);
      break;
    case State::kOpenChannel:
      SendMessage(MbimCmd::MbimType::kMbimOpenChannel,
                  std::make_unique<OpenChannelTxInfo>(AidIsdr()), std::move(cb),
                  &ModemMbim::InitializationStep, State::kReadEid);
      break;
    case State::kReadEid:
      SendMessage(MbimCmd::MbimType::kMbimSendEidApdu,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::InitializationStep, State::kEidReadComplete);
      break;
    case State::kEidReadComplete:
      SendMessage(MbimCmd::MbimType::kMbimCloseChannel,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::InitializationStep, State::kMbimStarted);
      break;
    case State::kMbimStarted:
      CloseDevice();
      if (eid_read_failed_) {
        LOG(ERROR) << "EID read failed";
        eid_read_failed_ = false;
        std::move(cb).Run(kModemMessageProcessingError);
        return;
      }
      VLOG(2) << "eSIM initialized for MBIM modem";
      std::move(cb).Run(kModemSuccess);
      OnEuiccUpdated();
      break;
  }
}

void ModemMbim::OnEuiccUpdated() {
  VLOG(2) << __func__ << ": " << slot_info_;
  for (int i = 0; i < slot_info_.slot_count_; i++) {
    if (slot_info_.IsEuicc(i)) {
      auto euicc_slot_info =
          (slot_info_.cached_active_slot_ == i)
              ? EuiccSlotInfo(kExecutorIndex, slot_info_.eid_[i])
              : EuiccSlotInfo(slot_info_.eid_[i]);
      euicc_manager_->OnEuiccUpdated(i + 1, EuiccSlotInfo(slot_info_.eid_[i]));
    }
  }
  euicc_manager_->OnLogicalSlotUpdated(slot_info_.cached_active_slot_ + 1,
                                       slot_info_.cached_active_slot_ + 1);
}

void ModemMbim::ReadSlotsInfo(uint32_t slot_num,
                              uint32_t retry_count,
                              ResultCallback cb) {
  VLOG(2) << __func__ << ": slot_num:" << slot_num;
  if (slot_num == slot_info_.slot_count_) {
    if (slot_info_.IsEuiccPresentOnAnySlot() || retry_count >= kMaxRetries) {
      InitializationStep(State::kCloseChannel, std::move(cb));
      return;
    }
    // post a  delayed task after 5secs
    executor_->PostDelayedTask(
        FROM_HERE,
        base::BindOnce(&ModemMbim::ReadSlotsInfo, weak_factory_.GetWeakPtr(), 0,
                       ++retry_count, std::move(cb)),
        kSlotInfoDelay);
  }
  SendMessage(MbimCmd::MbimType::kMbimSlotInfoStatus,
              std::make_unique<SwitchSlotTxInfo>(slot_num), std::move(cb),
              &ModemMbim::ReadSlotsInfo, slot_num + 1, 0 /* retry_count */);
}

void ModemMbim::TransmitSysCapsQuery() {
  g_autoptr(MbimMessage) message = NULL;
  VLOG(2) << __func__;
  message = mbim_message_ms_basic_connect_extensions_sys_caps_query_new(NULL);
  if (!message) {
    LOG(ERROR) << "Mbim message creation failed";
    ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)QuerySysCapsReady, this);
}

void ModemMbim::TransmitSubscriberStatusReady() {
  g_autoptr(MbimMessage) message = NULL;
  VLOG(2) << __func__;
  message = mbim_message_subscriber_ready_status_query_new(NULL);
  if (!message) {
    LOG(ERROR) << "Mbim message creation failed";
    ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)SubscriberReadyStatusRspCb, this);
}

void ModemMbim::TransmitDeviceCaps() {
  g_autoptr(MbimMessage) message = NULL;
  VLOG(2) << __func__;
  message = mbim_message_device_caps_query_new(/* error */ NULL);
  if (!message) {
    LOG(ERROR) << __func__ << " :Mbim message creation failed";
    ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /*cancellable*/ NULL,
                      (GAsyncReadyCallback)DeviceCapsQueryReady, this);
}

void ModemMbim::TransmitCloseChannel() {
  g_autoptr(MbimMessage) message = NULL;
  g_autoptr(GError) error = NULL;
  VLOG(2) << __func__;
  message = mbim_message_ms_uicc_low_level_access_close_channel_set_new(
      /* channel */ 0, kChannelGroupId, &error);
  if (!message) {
    LOG(ERROR) << "Mbim message creation failed:" << error->message;
    ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)UiccLowLevelAccessCloseChannelSetCb,
                      this);
}

void ModemMbim::TransmitOpenChannel() {
  VLOG(2) << __func__;
  auto open_channel_tx_info =
      dynamic_cast<OpenChannelTxInfo*>(tx_queue_[0].info_.get());
  guint8 appId[16];
  guint32 appIdSize = open_channel_tx_info->aid_.size();
  g_autoptr(GError) error = NULL;
  g_autoptr(MbimMessage) message = NULL;
  std::copy(open_channel_tx_info->aid_.begin(),
            open_channel_tx_info->aid_.end(), appId);
  message = mbim_message_ms_uicc_low_level_access_open_channel_set_new(
      appIdSize, appId, /* selectP2arg */ 4, kChannelGroupId, &error);
  if (!message) {
    LOG(ERROR) << __func__ << ": Mbim Message Creation Failed";
    ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /*cancellable*/ NULL,
                      (GAsyncReadyCallback)UiccLowLevelAccessOpenChannelSetCb,
                      this);
}

void ModemMbim::TransmitSendEidApdu() {
  VLOG(2) << __func__;
  uint8_t eid_apduCmd[kMaxApduLen];
  guint32 kMbimEidReqApduSize = kMbimEidReqApdu.size();
  g_autoptr(MbimMessage) message = NULL;
  MbimUiccSecureMessaging secure_messaging = MBIM_UICC_SECURE_MESSAGING_NONE;
  MbimUiccClassByteType class_byte_type = MBIM_UICC_CLASS_BYTE_TYPE_EXTENDED;
  std::copy(kMbimEidReqApdu.begin(), kMbimEidReqApdu.end(), eid_apduCmd);
  message = (mbim_message_ms_uicc_low_level_access_apdu_set_new(
      channel_, secure_messaging, class_byte_type, kMbimEidReqApduSize,
      eid_apduCmd, NULL));
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)UiccLowLevelAccessApduEidParse,
                      this);
}

void ModemMbim::TransmitSlotInfoStatus() {
  g_autoptr(MbimMessage) message = NULL;
  g_autoptr(GError) error = NULL;
  auto switch_slot_tx_info =
      dynamic_cast<SwitchSlotTxInfo*>(tx_queue_[0].info_.get());
  VLOG(2) << __func__ << ": slot:" << switch_slot_tx_info->physical_slot_;
  message =
      (mbim_message_ms_basic_connect_extensions_slot_info_status_query_new(
          switch_slot_tx_info->physical_slot_, &error));
  if (!message) {
    LOG(ERROR) << "Mbim message creation failed";
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)DeviceSlotStatusInfoRspCb, this);
}

void ModemMbim::TransmitDeviceSlotMapping() {
  g_autoptr(MbimMessage) message = NULL;
  VLOG(2) << __func__;
  message =
      mbim_message_ms_basic_connect_extensions_device_slot_mappings_query_new(
          NULL);
  if (!message) {
    LOG(ERROR) << "Mbim message creation failed";
    return;
  }
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)DeviceSlotStatusMappingRspCb, this);
}

void ModemMbim::TransmitSetDeviceSlotMapping() {
  g_autoptr(MbimMessage) message = NULL;
  g_autoptr(MbimSlotArray) slot_mappings =
      NULL;  // Array of MbimSlotArray. Every executor gets a MbimSlotArray.
             // MbimSlotArray always holds a single element.
  slot_mappings = g_new0(MbimSlot*, slot_info_.map_count_ + 1);
  slot_mappings[kExecutorIndex] = g_new0(MbimSlot, 1);
  VLOG(2) << __func__;
  auto switch_slot_tx_info =
      dynamic_cast<SwitchSlotTxInfo*>(tx_queue_[0].info_.get());
  VLOG(2) << __func__ << ": Hermes trying to operate on slot:"
          << switch_slot_tx_info->physical_slot_;
  slot_mappings[kExecutorIndex]->slot = switch_slot_tx_info->physical_slot_;
  message =
      mbim_message_ms_basic_connect_extensions_device_slot_mappings_set_new(
          slot_info_.map_count_, (const MbimSlot**)slot_mappings, NULL);
  if (!message) {
    LOG(ERROR) << "Mbim message creation failed";
    return;
  }
  LOG(INFO) << __func__ << ": before mbim_device_command";
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)SetDeviceSlotMappingsRspCb, this);
}

void ModemMbim::TransmitMbimSendApdu(TxElement* tx_element) {
  g_autoptr(MbimMessage) message = NULL;
  MbimUiccSecureMessaging secure_messaging = MBIM_UICC_SECURE_MESSAGING_NONE;
  MbimUiccClassByteType class_byte_type = MBIM_UICC_CLASS_BYTE_TYPE_EXTENDED;
  uint8_t* fragment;
  size_t apdu_len = 0;
  uint8_t apduCmd[kMaxApduLen] = {0};
  VLOG(2) << __func__;
  ApduTxInfo* apdu = static_cast<ApduTxInfo*>(tx_element->info_.get());
  size_t fragment_size = apdu->apdu_.GetNextFragment(&fragment);
  VLOG(2) << "Fragment size:" << fragment_size;
  apdu_len = fragment_size;
  std::copy(fragment, fragment + fragment_size, apduCmd);
  apduCmd[apdu_len++] =
      0x00;  // append extra byte for 4G Mbim Modem required for apdu handling
  LOG(INFO) << "Sending APDU fragment (" << apdu_len << " bytes): over channel "
            << channel_;
  VLOG(2) << "APDU:" << base::HexEncode(apduCmd, apdu_len);
  message = (mbim_message_ms_uicc_low_level_access_apdu_set_new(
      channel_, secure_messaging, class_byte_type, apdu_len, apduCmd, NULL));
  mbim_device_command(device_.get(), message, kMbimTimeoutSeconds,
                      /* cancellable */ NULL,
                      (GAsyncReadyCallback)UiccLowLevelAccessApduResponseParse,
                      this);
  return;
}

void ModemMbim::ReacquireChannel(EuiccEventStep step,
                                 std::vector<uint8_t> aid,
                                 ResultCallback cb) {
  LOG(INFO) << __func__ << ":" << to_underlying(step);
  switch (step) {
    case EuiccEventStep::CLOSE_CHANNEL:
      SendMessage(MbimCmd::MbimType::kMbimCloseChannel,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::ReacquireChannel, EuiccEventStep::OPEN_CHANNEL,
                  std::move(aid));
      break;
    case EuiccEventStep::OPEN_CHANNEL:
      SendMessage(MbimCmd::MbimType::kMbimOpenChannel,
                  std::make_unique<OpenChannelTxInfo>(std::move(aid)),
                  std::move(cb), &ModemMbim::ReacquireChannel,
                  EuiccEventStep::EUICC_EVENT_STEP_LAST, std::move(aid));
      break;
    case EuiccEventStep::EUICC_EVENT_STEP_LAST:
      std::move(cb).Run(kModemSuccess);
      break;
    default:
      VLOG(2) << "No Suitable operation";
  }
}

/* static */
void ModemMbim::SubscriberReadyStatusRspCb(MbimDevice* device,
                                           GAsyncResult* res,
                                           ModemMbim* modem_mbim) {
  g_autoptr(MbimMessage) response = NULL;
  VLOG(2) << __func__;
  g_autoptr(GError) error = NULL;
  response = mbim_device_command_finish(device, res, &error);
  if (!GetReadyState(device, false /* is_notification */, response,
                     &modem_mbim->ready_state_)) {
    LOG(ERROR) << "Could not parse ready state";
    modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  LOG(INFO) << "Current Sim status:" << modem_mbim->ready_state_;
  modem_mbim->ProcessMbimResult(kModemSuccess);
}

/* static */
void ModemMbim::DeviceCapsQueryReady(MbimDevice* device,
                                     GAsyncResult* res,
                                     ModemMbim* modem_mbim) {
  g_autoptr(MbimMessage) response = NULL;
  g_autoptr(GError) error = NULL;
  g_autofree gchar* caps_device_id = NULL;
  VLOG(2) << __func__;
  response = mbim_device_command_finish(device, res, &error);
  if (!response ||
      !mbim_message_response_get_result(
          response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) ||
      !mbim_message_device_caps_response_parse(response, NULL, /* device_type */
                                               NULL, /* cellular class  */
                                               NULL, /* voice_class  */
                                               NULL, /* sim_class  */
                                               NULL, /* data_class */
                                               NULL, /* sms_caps */
                                               NULL, /* ctrl_caps */
                                               NULL, /* max_sessions */
                                               NULL, /* custom_data_class */
                                               &caps_device_id,
                                               NULL, /* firmware_info */
                                               NULL, /* hardware_info */
                                               &error)) {
    modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  modem_mbim->imei_ = caps_device_id;
  VLOG(2) << "IMEI received from modem:" << modem_mbim->imei_;
  modem_mbim->ProcessMbimResult(kModemSuccess);
}

/* static */
void ModemMbim::UiccLowLevelAccessCloseChannelSetCb(MbimDevice* device,
                                                    GAsyncResult* res,
                                                    ModemMbim* modem_mbim) {
  g_autoptr(GError) error = NULL;
  g_autoptr(MbimMessage) response = NULL;
  guint32 status;
  LOG(INFO) << __func__;
  response = mbim_device_command_finish(device, res, &error);
  if (response &&
      mbim_message_response_get_result(response, MBIM_MESSAGE_TYPE_COMMAND_DONE,
                                       &error) &&
      mbim_message_ms_uicc_low_level_access_close_channel_response_parse(
          response, &status, &error)) {
    modem_mbim->channel_ = kInvalidChannel;
    modem_mbim->ProcessMbimResult(kModemSuccess);
    return;
  }
  if (g_error_matches(error, MBIM_STATUS_ERROR,
                      MBIM_STATUS_ERROR_OPERATION_NOT_ALLOWED)) {
    LOG(INFO) << "Operation not allowed from modem:" << error->message;
  } else {
    LOG(INFO) << "Channel could not be closed:" << error->message;
  }
  modem_mbim->ProcessMbimResult(kModemSuccess);
}

/* static */
void ModemMbim::UiccLowLevelAccessOpenChannelSetCb(MbimDevice* device,
                                                   GAsyncResult* res,
                                                   ModemMbim* modem_mbim) {
  g_autoptr(GError) error = NULL;
  g_autoptr(MbimMessage) response = NULL;
  guint32 status;
  guint32 chl;
  guint32 rsp_size;
  const guint8* rsp = NULL;
  LOG(INFO) << __func__;
  response = mbim_device_command_finish(device, res, &error);
  if (response &&
      mbim_message_response_get_result(response, MBIM_MESSAGE_TYPE_COMMAND_DONE,
                                       &error) &&
      mbim_message_ms_uicc_low_level_access_open_channel_response_parse(
          response, &status, &chl, &rsp_size, &rsp, &error)) {
    if (status != kMbimMessageSuccess) {
      LOG(INFO) << "Could not open channel:" << error->message
                << ". Inserted sim may not be an eSIM.";
      modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
      return;
    }
    VLOG(2) << "Successfully opened channel:" << chl;
    modem_mbim->channel_ = chl;
    modem_mbim->open_channel_raw_response_.clear();
    for (int i = 0; i < rsp_size; i++)
      modem_mbim->open_channel_raw_response_.push_back(rsp[i]);
    modem_mbim->open_channel_raw_response_.push_back(status & 0xFF);
    modem_mbim->open_channel_raw_response_.push_back((status >> 8) & 0xFF);
    VLOG(2) << __func__ << " Open Channel Response: "
            << base::HexEncode(modem_mbim->open_channel_raw_response_.data(),
                               modem_mbim->open_channel_raw_response_.size());
    modem_mbim->ProcessMbimResult(kModemSuccess);
    return;
  }
  if (g_error_matches(error, MBIM_STATUS_ERROR,
                      MBIM_STATUS_ERROR_OPERATION_NOT_ALLOWED)) {
    LOG(INFO) << "Modem FW may not support eSIM:" << error->message;
  } else {
    LOG(INFO) << "Could not open channel:" << error->message
              << ". Inserted sim may not be an eSIM.";
  }
  // not being able to open a channel is irrecoverable on L850. On dual sim
  // modems too, we should not attempt to open a channel unless we know we have
  // an eSIM.
  modem_mbim->retry_count_ = kMaxRetries + 1;
  modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
}

/* static */
bool ModemMbim::ParseEidApduResponse(const MbimMessage* response,
                                     std::string* eid,
                                     ModemMbim* modem_mbim) {
  g_autoptr(GError) error = NULL;
  guint32 status;
  guint32 response_size = 0;
  const guint8* out_response = NULL;
  std::vector<uint8_t> kGetEidDgiTag = {0xBF, 0x3E, 0x12, 0x5A, 0x10};
  if (!response)
    return false;
  if (!mbim_message_response_get_result(
          response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error)) {
    LOG(ERROR) << "Could not parse EID: " << error->message;
    if (modem_mbim) {
      // We've likely encountered b/230851574. Set flag that closes the channel,
      // and restores the slot.
      modem_mbim->retry_count_ = kMaxRetries + 1;
      modem_mbim->eid_read_failed_ = true;
    }
    return false;
  }
  if (!mbim_message_ms_uicc_low_level_access_apdu_response_parse(
          response, &status, &response_size, &out_response, &error)) {
    LOG(ERROR) << "Could not parse EID: " << error->message;
    return false;
  }
  if (response_size < 2 || out_response[0] != kGetEidDgiTag[0] ||
      out_response[1] != kGetEidDgiTag[1]) {
    return false;
  }
  VLOG(2) << "Decoding EID from APDU response (" << response_size << " bytes)"
          << base::HexEncode(&out_response[kGetEidDgiTag.size()],
                             response_size - kGetEidDgiTag.size());
  for (int j = kGetEidDgiTag.size(); j < response_size; j++) {
    *eid += bcd_chars[(out_response[j] >> 4) & 0xF];
    *eid += bcd_chars[out_response[j] & 0xF];
  }
  return true;
}

/* static */
void ModemMbim::UiccLowLevelAccessApduEidParse(MbimDevice* device,
                                               GAsyncResult* res,
                                               ModemMbim* modem_mbim) {
  g_autoptr(GError) error = NULL;
  std::string eid;
  g_autoptr(MbimMessage) response = NULL;
  response = mbim_device_command_finish(device, res, &error);
  if (ParseEidApduResponse(response, &eid, modem_mbim)) {
    VLOG(2) << "EID for physical slot:"
            << modem_mbim->slot_info_.cached_active_slot_ << " is " << eid;
    modem_mbim->slot_info_.SetSlotStateActiveSlot(MBIM_UICC_SLOT_STATE_UNKNOWN);
    if (!eid.empty()) {
      modem_mbim->slot_info_.SetEidActiveSlot(std::move(eid));
      modem_mbim->slot_info_.SetSlotStateActiveSlot(
          MBIM_UICC_SLOT_STATE_ACTIVE_ESIM);
    }
    modem_mbim->ProcessMbimResult(kModemSuccess);
    return;
  }
  LOG(ERROR) << "Could not read EID";
  // An EID read failure should usually abort any eSIM operation. In the special
  // case where we encounter b/230851574, eid_read_failed_ is set. In such
  // cases, do not abort the eSIM operation immediately. Instead, declare
  // success, and expect any subsequent code to read the eid_read_failed_ flag
  // and close any channels and reverse any slot switches.
  if (modem_mbim->eid_read_failed_) {
    modem_mbim->ProcessMbimResult(kModemSuccess);
    return;
  }
  modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
}

/* static */
void ModemMbim::UiccLowLevelAccessApduResponseParse(MbimDevice* device,
                                                    GAsyncResult* res,
                                                    ModemMbim* modem_mbim) {
  g_autoptr(GError) error = NULL;
  g_autoptr(MbimMessage) response = NULL;
  guint32 status;
  guint32 response_size = 0;
  const guint8* out_response;
  CHECK(modem_mbim->tx_queue_.size());
  // Ensure that the queued element is for a kSendApdu command
  TxInfo* base_info = modem_mbim->tx_queue_[0].info_.get();
  CHECK(base_info);
  static ResponseApdu payload;
  ApduTxInfo* info = static_cast<ApduTxInfo*>(base_info);
  response = mbim_device_command_finish(device, res, &error);
  if (response &&
      mbim_message_response_get_result(response, MBIM_MESSAGE_TYPE_COMMAND_DONE,
                                       &error) &&
      mbim_message_ms_uicc_low_level_access_apdu_response_parse(
          response, &status, &response_size, &out_response, &error)) {
    LOG(INFO) << "Adding to payload from APDU response (" << response_size
              << " bytes)";
    VLOG(2) << "Payload: " << base::HexEncode(out_response, response_size)
            << ", status: " << status;

    payload.AddData(out_response, response_size);
    payload.AddStatusBytes((status >> 8) & 0xFF, status & 0xFF);
    if (payload.MorePayloadIncoming()) {
      // Make the next transmit operation be a request for more APDU data
      info->apdu_ = payload.CreateGetMoreCommand(/* is_extended_apdu */ false,
                                                 info->apdu_.cls_);
      LOG(INFO) << "Requesting more APDUs...";
      modem_mbim->TransmitFromQueue();
      return;
    }
    if (info->apdu_.HasMoreFragments()) {
      // Send next fragment of APDU
      LOG(INFO) << "Sending next APDU fragment...";
      modem_mbim->TransmitFromQueue();
      return;
    }
    modem_mbim->responses_.push_back(std::move(payload));
    std::move(modem_mbim->tx_queue_[0].cb_).Run(lpa::card::EuiccCard::kNoError);
    modem_mbim->tx_queue_.pop_front();
    modem_mbim->TransmitFromQueue();
  } else {
    LOG(ERROR) << __func__ << ": Failed to parse APDU response";
    std::move(modem_mbim->tx_queue_[0].cb_)
        .Run(lpa::card::EuiccCard::kSendApduError);
    modem_mbim->tx_queue_.pop_front();
    modem_mbim->TransmitFromQueue();
    return;
  }
}

void ModemMbim::DeviceSlotStatusInfoRspCb(MbimDevice* device,
                                          GAsyncResult* res,
                                          ModemMbim* modem_mbim) {
  g_autoptr(MbimMessage) response = NULL;
  g_autoptr(GError) error = NULL;
  guint32 slot_index;
  MbimUiccSlotState slot_status;
  response = mbim_device_command_finish(device, res, &error);
  if (response &&
      mbim_message_response_get_result(response, MBIM_MESSAGE_TYPE_COMMAND_DONE,
                                       &error) &&
      mbim_message_ms_basic_connect_extensions_slot_info_status_response_parse(
          response, &slot_index, &slot_status, &error)) {
    modem_mbim->slot_info_.slot_state_[slot_index] = slot_status;
    VLOG(2) << "Response received with slot_index:" << slot_index
            << " & status:" << slot_status;
    modem_mbim->ProcessMbimResult(kModemSuccess);
    return;
  }
  LOG(ERROR) << __func__ << ":" << error->message;
  modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
}

void ModemMbim::QuerySysCapsReady(MbimDevice* device,
                                  GAsyncResult* res,
                                  ModemMbim* modem_mbim) {
  g_autoptr(MbimMessage) response = NULL;
  g_autoptr(GError) error = NULL;
  guint32 number_executors;
  guint32 number_slots;
  guint32 concurrency;
  guint64 modem_id;
  LOG(INFO) << __func__;
  response = mbim_device_command_finish(device, res, &error);
  if (!response ||
      !mbim_message_response_get_result(
          response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) ||
      !mbim_message_ms_basic_connect_extensions_sys_caps_response_parse(
          response, &number_executors, &number_slots, &concurrency, &modem_id,
          &error)) {
    modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  VLOG(2) << "executor index:" << number_executors
          << " Number of slots:" << number_slots;
  modem_mbim->slot_info_.InitSlotInfo(number_slots, number_executors);
  modem_mbim->ProcessMbimResult(kModemSuccess);
}

void ModemMbim::DeviceSlotStatusMappingRspCb(MbimDevice* device,
                                             GAsyncResult* res,
                                             ModemMbim* modem_mbim) {
  g_autoptr(MbimMessage) response = NULL;
  g_autoptr(GError) error = NULL;
  guint32 map_count = 0;
  g_autoptr(MbimSlotArray) slot_mappings = NULL;
  response = mbim_device_command_finish(device, res, &error);
  if (response &&
      mbim_message_response_get_result(response, MBIM_MESSAGE_TYPE_COMMAND_DONE,
                                       &error) &&
      mbim_message_ms_basic_connect_extensions_device_slot_mappings_response_parse(
          response, &map_count, &slot_mappings, &error)) {
    CHECK_EQ(map_count, 1) << "Unexpected multi radio modem";
    modem_mbim->slot_info_.map_count_ = map_count;
    modem_mbim->slot_info_.cached_active_slot_ =
        slot_mappings[kExecutorIndex]->slot;
    modem_mbim->slot_info_.get_slot_mapping_result_ =
        slot_mappings[kExecutorIndex]->slot;
    VLOG(2) << "Map count:" << map_count
            << "& current active slot:" << slot_mappings[kExecutorIndex]->slot;
    modem_mbim->ProcessMbimResult(kModemSuccess);
    return;
  }
  modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
}

void ModemMbim::SetDeviceSlotMappingsRspCb(MbimDevice* device,
                                           GAsyncResult* res,
                                           ModemMbim* modem_mbim) {
  g_autoptr(MbimMessage) response = NULL;
  g_autoptr(GError) error = NULL;
  guint32 map_count = 0;
  uint8_t physical_switch_slot = 1;
  g_autoptr(MbimSlotArray) slot_mappings = NULL;
  VLOG(2) << __func__;
  auto switch_slot_tx_info =
      dynamic_cast<SwitchSlotTxInfo*>(modem_mbim->tx_queue_[0].info_.get());
  physical_switch_slot = switch_slot_tx_info->physical_slot_;
  response = mbim_device_command_finish(device, res, &error);
  if (!response ||
      !mbim_message_response_get_result(
          response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) ||
      !mbim_message_ms_basic_connect_extensions_device_slot_mappings_response_parse(
          response, &map_count, &slot_mappings, &error)) {
    LOG(ERROR) << "Sim slot switch to " << physical_switch_slot << " failed";
    modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  if (physical_switch_slot != slot_mappings[kExecutorIndex]->slot) {
    LOG(ERROR) << "Sim slot switch to " << physical_switch_slot << " failed";
    // b/230851574 causes a slot switch to fail once inevitably.
    if (modem_mbim->eid_read_failed_) {
      LOG(INFO) << "Ignoring failed slot switch";
      modem_mbim->ProcessMbimResult(kModemSuccess);
      return;
    }
    modem_mbim->ProcessMbimResult(kModemMessageProcessingError);
    return;
  }
  modem_mbim->slot_info_.cached_active_slot_ = physical_switch_slot;
  for (int i = 0; i < modem_mbim->slot_info_.slot_count_; i++) {
    if (i != physical_switch_slot) {
      modem_mbim->euicc_manager_->OnLogicalSlotUpdated(
          modem_mbim->slot_info_.cached_active_slot_, std::nullopt);
      continue;
    }
    modem_mbim->euicc_manager_->OnLogicalSlotUpdated(
        modem_mbim->slot_info_.cached_active_slot_, kExecutorIndex);
  }
  LOG(INFO) << "Sim switch was successful to:"
            << slot_mappings[kExecutorIndex]->slot;
  modem_mbim->ProcessMbimResult(kModemSuccess);
}

/* static */
void ModemMbim::ClientIndicationCb(MbimDevice* device,
                                   MbimMessage* notification,
                                   ModemMbim* modem_mbim) {
  MbimService service;
  service = mbim_message_indicate_status_get_service(notification);
  VLOG(2) << "Received notification for service:"
          << mbim_service_get_string(service);
  VLOG(2) << "Command received from the modem:"
          << mbim_cid_get_printable(
                 service, mbim_message_indicate_status_get_cid(notification));
  switch (service) {
    case MBIM_SERVICE_BASIC_CONNECT:
      if (mbim_message_indicate_status_get_cid(notification) ==
          MBIM_CID_BASIC_CONNECT_SUBSCRIBER_READY_STATUS) {
        modem_mbim->is_ready_state_valid =
            GetReadyState(device, true /*is_notification*/, notification,
                          &modem_mbim->ready_state_);
        LOG(INFO) << "Current sim status:" << modem_mbim->ready_state_;
        if (modem_mbim->ready_state_ ==
            MBIM_SUBSCRIBER_READY_STATE_INITIALIZED) {
          VLOG(2) << "Sim has one profile enabled";
        } else if (modem_mbim->ready_state_ ==
                   MBIM_SUBSCRIBER_READY_STATE_SIM_NOT_INSERTED) {
          VLOG(2) << "Sim not inserted";
        }
      }
      break;
    default:
      VLOG(2) << "Indication received is not handled";
      break;
  }
  return;
}

void ModemMbim::CloseDevice() {
  if (device_ && g_signal_handler_is_connected(device_.get(), indication_id_))
    g_signal_handler_disconnect(device_.get(), indication_id_);
  device_.reset();
}

bool ModemMbim::State::Transition(ModemMbim::State::Value value) {
  bool valid_transition;
  switch (value) {
    case kMbimUninitialized:
      valid_transition = true;
      break;
    case kCloseChannel:
      valid_transition = (value_ == kCheckSingleSim || value_ == kSlotInfo);
      break;
    case kMbimStarted:
      valid_transition =
          (value_ == kCloseChannel || value_ == kEidReadComplete);
      break;
    default:
      // Most states can only transition from the previous state.
      valid_transition = (value == value_ + 1);
  }
  if (valid_transition) {
    LOG(INFO) << "Transitioning from state " << *this << " to state "
              << State(value);
    value_ = value;
  } else {
    LOG(ERROR) << "Cannot transition from state " << *this << " to state "
               << State(value);
  }
  return valid_transition;
}

std::ostream& operator<<(std::ostream& os, const ModemMbim::State state) {
  switch (state.value_) {
    case ModemMbim::State::kMbimUninitialized:
      os << "Uninitialized";
      break;
    case ModemMbim::State::kMbimInitializeStarted:
      os << "InitializeStarted";
      break;
    case ModemMbim::State::kReadImei:
      os << "GetReadImei";
      break;
    case ModemMbim::State::kGetSubscriberReadyState:
      os << "GetSubscriberReadyState";
      break;
    case ModemMbim::State::kCheckSingleSim:
      os << "CheckSingleSim";
      break;
    case ModemMbim::State::kSysQuery:
      os << "GetSysQuery";
      break;
    case ModemMbim::State::kDeviceSlotMapping:
      os << "GetDeviceSlotMapping";
      break;
    case ModemMbim::State::kSlotInfo:
      os << "GetSlotInfo";
      break;
    case ModemMbim::State::kCloseChannel:
      os << "Close Channel";
      break;
    case ModemMbim::State::kOpenChannel:
      os << "Open Channel";
      break;
    case ModemMbim::State::kReadEid:
      os << "GetReadEid";
      break;
    case ModemMbim::State::kEidReadComplete:
      os << "kEidReadComplete";
      break;
    case ModemMbim::State::kMbimStarted:
      os << "MbimStarted";
      break;
  }
  return os;
}

void ModemMbim::OnEuiccEventStart(const uint32_t physical_slot,
                                  bool switch_slot_only,
                                  EuiccEventStep step,
                                  ResultCallback cb) {
  LOG(INFO) << __func__ << ": slot=" << physical_slot
            << " switch_slot_only=" << switch_slot_only
            << " step=" << to_underlying(step);
  switch (step) {
    case EuiccEventStep::GET_MBIM_DEVICE:
      CloseDevice();
      {
        auto next_step = (switch_slot_only) ? EuiccEventStep::CLOSE_CHANNEL
                                            : EuiccEventStep::GET_SLOT_MAPPING;
        auto get_slot_mapping = base::BindOnce(
            &ModemMbim::OnEuiccEventStart, weak_factory_.GetWeakPtr(),
            physical_slot, switch_slot_only, next_step);
        init_done_cb_ = base::BindOnce(
            &RunNextStep, std::move(get_slot_mapping), std::move(cb));
        mbim_device_new(file_, /* cancellable */ NULL,
                        (GAsyncReadyCallback)MbimCreateNewDeviceCb, this);
      }
      break;
    case EuiccEventStep::GET_SLOT_MAPPING:
      if (!mbim_device_check_ms_mbimex_version(device_.get(), 2, 0)) {
        OnEuiccEventStart(physical_slot, false /* switch_slot_only */
                          ,
                          EuiccEventStep::CLOSE_CHANNEL, std::move(cb));
        break;
      }
      SendMessage(MbimCmd::MbimType::kMbimDeviceSlotMapping,
                  std::make_unique<SwitchSlotTxInfo>(physical_slot),
                  std::move(cb), &ModemMbim::OnEuiccEventStart, physical_slot,
                  switch_slot_only, EuiccEventStep::GET_SLOT_INFO);
      break;
    case EuiccEventStep::GET_SLOT_INFO: {
      SendMessage(MbimCmd::MbimType::kMbimSlotInfoStatus,
                  std::make_unique<SwitchSlotTxInfo>(physical_slot),
                  std::move(cb), &ModemMbim::OnEuiccEventStart, physical_slot,
                  switch_slot_only, EuiccEventStep::CLOSE_CHANNEL);
    } break;
    case EuiccEventStep::CLOSE_CHANNEL: {
      // b/230851574 Channel must be closed before attempting a slot switch.
      SendMessage(MbimCmd::MbimType::kMbimCloseChannel,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::OnEuiccEventStart, physical_slot,
                  switch_slot_only, EuiccEventStep::SET_SLOT_MAPPING);
    } break;
    case EuiccEventStep::SET_SLOT_MAPPING: {
      auto next_step = (switch_slot_only)
                           ? EuiccEventStep::EUICC_EVENT_STEP_LAST
                           : EuiccEventStep::OPEN_CHANNEL;
      // Bypass slot switch if we are already on the requested slot or if slot
      // switch isn't supported
      if (physical_slot == slot_info_.cached_active_slot_ ||
          !mbim_device_check_ms_mbimex_version(device_.get(), 2, 0)) {
        OnEuiccEventStart(physical_slot, switch_slot_only, next_step,
                          std::move(cb));
        break;
      }
      SendMessage(MbimCmd::MbimType::kMbimSetDeviceSlotMapping,
                  std::make_unique<SwitchSlotTxInfo>(physical_slot),
                  std::move(cb), &ModemMbim::OnEuiccEventStart, physical_slot,
                  switch_slot_only, next_step);
    } break;
    case EuiccEventStep::OPEN_CHANNEL:
      if (!slot_info_.IsEsimActive()) {
        LOG(ERROR) << "Active slot does not have an eSIM";
        euicc_manager_->OnEuiccRemoved(slot_info_.cached_active_slot_ + 1);
        std::move(cb).Run(kModemMessageProcessingError);
        break;
      }
      SendMessage(MbimCmd::MbimType::kMbimOpenChannel,
                  std::make_unique<OpenChannelTxInfo>(AidIsdr()), std::move(cb),
                  &ModemMbim::OnEuiccEventStart, physical_slot,
                  switch_slot_only, EuiccEventStep::GET_EID);
      break;
    case EuiccEventStep::GET_EID:
      SendMessage(MbimCmd::MbimType::kMbimSendEidApdu,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::OnEuiccEventStart, physical_slot,
                  switch_slot_only, EuiccEventStep::CHECK_EID);
      break;
    case EuiccEventStep::CHECK_EID:
      if (eid_read_failed_) {
        OnEidReadFailed(physical_slot, EidReadFailedStep::CLOSE_CHANNEL,
                        std::move(cb));
        break;
      }
      OnEuiccEventStart(physical_slot, switch_slot_only,
                        EuiccEventStep::EUICC_EVENT_STEP_LAST, std::move(cb));
      break;
    case EuiccEventStep::EUICC_EVENT_STEP_LAST:
      OnEuiccUpdated();
      std::move(cb).Run(kModemSuccess);
      break;
  }
}

void ModemMbim::OnEidReadFailed(const uint32_t physical_slot,
                                EidReadFailedStep step,
                                ResultCallback cb) {
  // b/230851574 An EID error may have occurred after a slot switch.
  // Attempt to switch back to the original slot after closing the
  // channel, while still reporting an error.
  LOG(INFO) << __func__ << ": slot=" << physical_slot
            << " step=" << to_underlying(step);
  switch (step) {
    case EidReadFailedStep::CLOSE_CHANNEL:
      SendMessage(MbimCmd::MbimType::kMbimCloseChannel,
                  std::unique_ptr<TxInfo>(), std::move(cb),
                  &ModemMbim::OnEidReadFailed, physical_slot,
                  EidReadFailedStep::RESTORE_SLOT_ATTEMPT1);
      break;
    case EidReadFailedStep::RESTORE_SLOT_ATTEMPT1:
      if (!slot_info_.get_slot_mapping_result_.has_value()) {
        LOG(ERROR) << "Cannot restore slot after EID read failure";
        eid_read_failed_ = false;
        std::move(cb).Run(kModemMessageProcessingError);
        break;
      }
      // This attempt will most likely fail due to b/230851574
      SendMessage(MbimCmd::MbimType::kMbimSetDeviceSlotMapping,
                  std::make_unique<SwitchSlotTxInfo>(
                      slot_info_.get_slot_mapping_result_.value()),
                  std::move(cb), &ModemMbim::OnEidReadFailed, physical_slot,
                  EidReadFailedStep::RESTORE_SLOT_ATTEMPT2);
      break;
    case EidReadFailedStep::RESTORE_SLOT_ATTEMPT2:
      SendMessage(MbimCmd::MbimType::kMbimSetDeviceSlotMapping,
                  std::make_unique<SwitchSlotTxInfo>(
                      slot_info_.get_slot_mapping_result_.value()),
                  std::move(cb), &ModemMbim::OnEidReadFailed, physical_slot,
                  EidReadFailedStep::STEP_LAST);
      break;
    case EidReadFailedStep::STEP_LAST:
      eid_read_failed_ = false;
      std::move(cb).Run(kModemMessageProcessingError);
      break;
  }
}

void ModemMbim::ProcessEuiccEvent(EuiccEvent event, ResultCallback cb) {
  LOG(INFO) << __func__ << ": " << event;
  if (event.step == EuiccStep::START) {
    auto on_euicc_event_start = base::BindOnce(
        &ModemMbim::OnEuiccEventStart, weak_factory_.GetWeakPtr(),
        event.slot - 1, false /* switch_slot_only */,
        EuiccEventStep::GET_MBIM_DEVICE);
    modem_manager_proxy_->WaitForModemAndInhibit(base::BindOnce(
        &RunNextStep, std::move(on_euicc_event_start), std::move(cb)));
    return;
  }
  if (event.step == EuiccStep::PENDING_NOTIFICATIONS) {
    AcquireChannelAfterCardReady(event, std::move(cb));
    return;
  }
  if (event.step == EuiccStep::END) {
    slot_info_.get_slot_mapping_result_.reset();
    auto close_device_and_uninhibit = base::BindOnce(
        &ModemMbim::CloseDeviceAndUninhibit, weak_factory_.GetWeakPtr());
    // Close channel, followed by close device and uninhibit, and then execute
    // cb
    SendMessage(MbimCmd::MbimType::kMbimCloseChannel, std::unique_ptr<TxInfo>(),
                std::move(cb), &ModemMbim::CloseDeviceAndUninhibit);
    return;
  }
}

void ModemMbim::AcquireChannelAfterCardReady(EuiccEvent event,
                                             ResultCallback cb) {
  const guint MBIM_SUBSCRIBER_READY_STATE_NO_ESIM_PROFILE = 7;
  if (!is_ready_state_valid ||
      !(ready_state_ == MBIM_SUBSCRIBER_READY_STATE_NOT_INITIALIZED ||
        ready_state_ == MBIM_SUBSCRIBER_READY_STATE_INITIALIZED ||
        ready_state_ == MBIM_SUBSCRIBER_READY_STATE_DEVICE_LOCKED ||
        ready_state_ == MBIM_SUBSCRIBER_READY_STATE_NO_ESIM_PROFILE)) {
    if (retry_count_ > kMaxRetries) {
      LOG(ERROR) << "Could not finish profile operation,ready_state_="
                 << ready_state_
                 << ", is_ready_state_valid=" << is_ready_state_valid;
      std::move(cb).Run(kModemMessageProcessingError);
      return;
    }
    retry_count_++;
    executor_->PostDelayedTask(
        FROM_HERE,
        base::BindOnce(&ModemMbim::AcquireChannelAfterCardReady,
                       weak_factory_.GetWeakPtr(), std::move(event),
                       std::move(cb)),
        kSimRefreshDelay);
    return;
  }
  retry_count_ = 0;
  ReacquireChannel(EuiccEventStep::OPEN_CHANNEL, AidIsdr(), std::move(cb));
}

void ModemMbim::CloseDeviceAndUninhibit(ResultCallback cb) {
  CloseDevice();
  modem_manager_proxy_->ScheduleUninhibit(kUninhibitDelay);
  std::move(cb).Run(kModemSuccess);
}

void ModemMbim::RestoreActiveSlot(ResultCallback cb) {
  LOG(INFO) << __func__;
  if (!mbim_device_check_ms_mbimex_version(device_.get(), 2, 0)) {
    std::move(cb).Run(kModemSuccess);
    return;
  }
  if (!slot_info_.get_slot_mapping_result_.has_value()) {
    LOG(ERROR) << "Could not find slot number to switch to";
    std::move(cb).Run(kModemMessageProcessingError);
    return;
  }
  if (slot_info_.get_slot_mapping_result_ == slot_info_.cached_active_slot_) {
    VLOG(2) << __func__ << "Already on the right slot";
    std::move(cb).Run(kModemSuccess);
    return;
  }
  OnEuiccEventStart(slot_info_.get_slot_mapping_result_.value(),
                    true /* switch_slot_only */,
                    EuiccEventStep::GET_MBIM_DEVICE, std::move(cb));
}

bool ModemMbim::IsSimValidAfterEnable() {
  VLOG(2) << __func__;
  return false;
  // The sim issues a proactive refresh after an enable. This
  // function should return true immediately after the refresh completes,
  // However, the LPA expects that this function does not read any
  // other state variable. Thus, we simply return false until the LPA
  // times out, and then finish the operation. This imposes a 15 sec penalty
  // on every enable and 30 sec penalty on every disable.
  // A workaround is to return true and complete the eSIM operation before the
  // refresh. FinishProfileOp can gate the dbus response until the refresh is
  // complete. However, this exposes UI issues.
}

bool ModemMbim::IsSimValidAfterDisable() {
  VLOG(2) << __func__;
  return false;
}

void ModemMbim::OpenConnection(
    const std::vector<uint8_t>& aid,
    base::OnceCallback<void(std::vector<uint8_t>)> cb) {
  LOG(INFO) << __func__ << base::HexEncode(aid.data(), aid.size());
  ReacquireChannel(EuiccEventStep::CLOSE_CHANNEL, aid,
                   base::BindOnce(&ModemMbim::OpenConnectionResponse,
                                  weak_factory_.GetWeakPtr(), std::move(cb)));
}

void ModemMbim::TransmitApdu(
    const std::vector<uint8_t>& apduCommand,
    base::OnceCallback<void(std::vector<uint8_t>)> cb) {
  LOG(INFO) << __func__ << ": APDU command="
            << base::HexEncode(apduCommand.data(), apduCommand.size());
  DCHECK(apduCommand.size() > 2) << "APDU does not have a header.";
  CommandApdu apdu(apduCommand);
  auto transmit_apdu_resp =
      base::BindOnce(&ModemMbim::TransmitApduResponse,
                     weak_factory_.GetWeakPtr(), std::move(cb));
  tx_queue_.push_back({std::make_unique<ApduTxInfo>(std::move(apdu)),
                       AllocateId(), GetTagForSendApdu(),
                       std::move(transmit_apdu_resp)});
  TransmitFromQueue();
}

/* static */
bool ModemMbim::ParseEidApduResponseForTesting(const MbimMessage* response,
                                               std::string* eid) {
  return ParseEidApduResponse(response, eid, nullptr);
}

template <typename Func, typename... Args>
void ModemMbim::SendMessage(MbimCmd::MbimType type,
                            std::unique_ptr<TxInfo> tx_info,
                            ResultCallback cb,
                            Func&& next_step,
                            Args&&... args) {
  // First, transmit an mbim message. If the message is successful, run
  // next_step(args).
  auto next_step_weak =
      base::BindOnce(next_step, weak_factory_.GetWeakPtr(), args...);
  auto run_next_step =
      base::BindOnce(&ModemMbim::RunNextStepOrRetry, weak_factory_.GetWeakPtr(),
                     std::move(next_step_weak), std::move(cb));
  tx_queue_.push_back({std::move(tx_info), AllocateId(),
                       std::make_unique<MbimCmd>(type),
                       std::move(run_next_step)});
  TransmitFromQueue();
}

bool ModemMbim::SlotInfo::IsEuiccPresentOnAnySlot() const {
  for (int i = 0; i < slot_count_; i++) {
    if (IsEuicc(i)) {
      return true;
    }
  }
  return false;
}

bool ModemMbim::SlotInfo::IsEuicc(int slot) const {
  return (slot_state_[slot] == MBIM_UICC_SLOT_STATE_ACTIVE_ESIM) ||
         (slot_state_[slot] == MBIM_UICC_SLOT_STATE_ACTIVE_ESIM_NO_PROFILES);
}

void ModemMbim::SlotInfo::InitSlotInfo(guint32 slot_count, guint32 map_count) {
  slot_count_ = slot_count;
  map_count_ = map_count;  // number of executors/radios
  slot_state_.clear();
  eid_.clear();
  for (int i = 0; i < slot_count_; i++) {
    slot_state_.push_back(MBIM_UICC_SLOT_STATE_UNKNOWN);
    eid_.emplace_back();
  }
}

void ModemMbim::SlotInfo::SetEidActiveSlot(std::string eid) {
  eid_[cached_active_slot_] = std::move(eid);
}

void ModemMbim::SlotInfo::SetSlotStateActiveSlot(MbimUiccSlotState state) {
  slot_state_[cached_active_slot_] = state;
}

std::ostream& operator<<(std::ostream& os, const ModemMbim::SlotInfo& info) {
  os << "map_count_: " << info.map_count_
     << " slot_count_: " << info.slot_count_
     << " cached_active_slot_: " << info.cached_active_slot_;
  for (int i = 0; i < info.slot_count_; i++) {
    os << " slot_state[" << i << "]: " << info.slot_state_[i] << " eid[" << i
       << "]:" << info.eid_[i];
  }
  return os;
}

}  // namespace hermes