/*
 * Copyright (C) 2017 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 "mcap_test_app.h"
#include "mca_defs.h"

namespace SYSTEM_BT_TOOLS_MCAP_TOOL {

#define CASE_RETURN_STR(const) \
  case const:                  \
    return #const;

static const char* dump_mcap_events(const uint8_t event) {
  switch (event) {
    CASE_RETURN_STR(MCA_ERROR_RSP_EVT)
    CASE_RETURN_STR(MCA_CREATE_IND_EVT)
    CASE_RETURN_STR(MCA_CREATE_CFM_EVT)
    CASE_RETURN_STR(MCA_RECONNECT_IND_EVT)
    CASE_RETURN_STR(MCA_RECONNECT_CFM_EVT)
    CASE_RETURN_STR(MCA_ABORT_IND_EVT)
    CASE_RETURN_STR(MCA_ABORT_CFM_EVT)
    CASE_RETURN_STR(MCA_DELETE_IND_EVT)
    CASE_RETURN_STR(MCA_DELETE_CFM_EVT)
    CASE_RETURN_STR(MCA_SYNC_CAP_IND_EVT)
    CASE_RETURN_STR(MCA_SYNC_CAP_CFM_EVT)
    CASE_RETURN_STR(MCA_SYNC_SET_IND_EVT)
    CASE_RETURN_STR(MCA_SYNC_SET_CFM_EVT)
    CASE_RETURN_STR(MCA_SYNC_INFO_IND_EVT)
    CASE_RETURN_STR(MCA_CONNECT_IND_EVT)
    CASE_RETURN_STR(MCA_DISCONNECT_IND_EVT)
    CASE_RETURN_STR(MCA_OPEN_IND_EVT)
    CASE_RETURN_STR(MCA_OPEN_CFM_EVT)
    CASE_RETURN_STR(MCA_CLOSE_IND_EVT)
    CASE_RETURN_STR(MCA_CLOSE_CFM_EVT)
    CASE_RETURN_STR(MCA_CONG_CHG_EVT)
    CASE_RETURN_STR(MCA_RSP_TOUT_IND_EVT)
    default:
      return "Unknown event";
  }
}

static void print_mcap_event(const tMCA_DISCONNECT_IND* mcap_disconnect_ind) {
  printf("%s: peer_bd_addr=%s,l2cap_disconnect_reason=0x%04x\n", __func__,
         mcap_disconnect_ind->bd_addr.ToString().c_str(),
         mcap_disconnect_ind->reason);
}

static void print_mcap_event(const tMCA_CONNECT_IND* mcap_connect_ind) {
  printf("%s: peer_bd_addr=%s, peer_mtu=%d \n", __func__,
         mcap_connect_ind->bd_addr.ToString().c_str(), mcap_connect_ind->mtu);
}

static void print_mcap_event(const tMCA_RSP_EVT* mcap_rsp) {
  printf("%s: response, mdl_id=%d, op_code=0x%02x, rsp_code=0x%02x\n", __func__,
         mcap_rsp->mdl_id, mcap_rsp->op_code, mcap_rsp->rsp_code);
}

static void print_mcap_event(const tMCA_EVT_HDR* mcap_evt_hdr) {
  printf("%s: event, mdl_id=%d, op_code=0x%02x\n", __func__,
         mcap_evt_hdr->mdl_id, mcap_evt_hdr->op_code);
}

static void print_mcap_event(const tMCA_CREATE_IND* mcap_create_ind) {
  printf("%s: mdl_id=%d, op_code=0x%02x, dep_id=%d, cfg=0x%02x\n", __func__,
         mcap_create_ind->mdl_id, mcap_create_ind->op_code,
         mcap_create_ind->dep_id, mcap_create_ind->cfg);
}

static void print_mcap_event(const tMCA_CREATE_CFM* mcap_create_cfm) {
  printf("%s: mdl_id=%d, op_code=0x%02x, rsp_code=%d, cfg=0x%02x\n", __func__,
         mcap_create_cfm->mdl_id, mcap_create_cfm->op_code,
         mcap_create_cfm->rsp_code, mcap_create_cfm->cfg);
}

static void print_mcap_event(const tMCA_DL_OPEN* mcap_dl_open) {
  printf("%s: mdl_id=%d, mdl_handle=%d, mtu=%d\n", __func__,
         mcap_dl_open->mdl_id, mcap_dl_open->mdl, mcap_dl_open->mtu);
}

static void print_mcap_event(const tMCA_DL_CLOSE* mcap_dl_close) {
  printf("%s: mdl_id=%d, mdl_handle=%d, l2cap_disconnect_reason=0x%04x\n",
         __func__, mcap_dl_close->mdl_id, mcap_dl_close->mdl,
         mcap_dl_close->reason);
}

static void print_mcap_event(const tMCA_CONG_CHG* mcap_congestion_change) {
  printf("%s: mdl_id=%d, mdl_handle=%d, congested=%d\n", __func__,
         mcap_congestion_change->mdl_id, mcap_congestion_change->mdl,
         mcap_congestion_change->cong);
}

McapTestApp::McapTestApp(btmcap_test_interface_t* mcap_test_interface)
    : _mcl_list(), _mdep_list() {
  _mcap_test_interface = mcap_test_interface;
}

btmcap_test_interface_t* McapTestApp::GetInterface() {
  return _mcap_test_interface;
}

bool McapTestApp::Register(uint16_t ctrl_psm, uint16_t data_psm,
                           uint16_t sec_mask, tMCA_CTRL_CBACK* callback) {
  if (!callback) {
    LOG(ERROR) << "callback is null";
    return false;
  }
  _mca_reg.rsp_tout = 5000;
  _mca_reg.ctrl_psm = ctrl_psm;
  _mca_reg.data_psm = data_psm;
  _mca_reg.sec_mask = sec_mask;
  _mcap_handle =
      _mcap_test_interface->register_application(&_mca_reg, callback);
  return _mcap_handle > 0;
}

void McapTestApp::Deregister() {
  _mcap_test_interface->deregister_application(_mcap_handle);
  _mcap_handle = 0;
}

bool McapTestApp::Registered() { return _mcap_handle > 0; }

bool McapTestApp::ConnectMcl(const RawAddress& bd_addr, uint16_t ctrl_psm,
                             uint16_t sec_mask) {
  if (!Registered()) {
    LOG(ERROR) << "Application not registered";
    return false;
  }
  McapMcl* mcap_mcl = FindMclByPeerAddress(bd_addr);
  if (!mcap_mcl) {
    LOG(INFO) << "MCL does not exist, creating new MCL";
    _mcl_list.push_back(McapMcl(_mcap_test_interface, _mcap_handle, bd_addr));
    mcap_mcl = &_mcl_list[_mcl_list.size() - 1];
  }
  if (mcap_mcl->GetHandle() != 0) {
    LOG(ERROR) << "MCL is still active, cannot make another connection";
    return false;
  }
  return mcap_mcl->Connect(ctrl_psm, sec_mask);
}

bool McapTestApp::CreateMdep(uint8_t type, uint8_t max_mdl,
                             tMCA_DATA_CBACK* data_callback) {
  if (!data_callback) {
    LOG(ERROR) << "Data callback is null";
    return false;
  }
  _mdep_list.push_back(McapMdep(_mcap_test_interface, _mcap_handle, type,
                                max_mdl, data_callback));
  return _mdep_list[_mdep_list.size() - 1].Create();
}

uint8_t McapTestApp::GetHandle() { return _mcap_handle; }

McapMcl* McapTestApp::FindMclByPeerAddress(const RawAddress& bd_addr) {
  for (McapMcl& mcl : _mcl_list) {
    if (mcl.GetPeerAddress() == bd_addr) {
      return &mcl;
    }
  }
  return nullptr;
}

McapMcl* McapTestApp::FindMclByHandle(tMCA_CL mcl_handle) {
  for (McapMcl& mcl : _mcl_list) {
    if (mcl.GetHandle() == mcl_handle) {
      return &mcl;
    }
  }
  return nullptr;
}

McapMdep* McapTestApp::FindMdepByHandle(tMCA_DEP mdep_handle) {
  for (McapMdep& mdep : _mdep_list) {
    if (mdep.GetHandle() == mdep_handle) {
      return &mdep;
    }
  }
  return nullptr;
}

void McapTestApp::RemoveMclByHandle(tMCA_CL mcl_handle) {
  LOG(INFO) << "Removing MCL handle " << (int)mcl_handle;
  for (std::vector<McapMcl>::iterator it = _mcl_list.begin();
       it != _mcl_list.end(); ++it) {
    if (it->GetHandle() == mcl_handle) {
      _mcl_list.erase(it);
      LOG(INFO) << "Removed MCL handle " << (int)mcl_handle;
      return;
    }
  }
}

bool McapTestApp::IsRegistered() { return _mcap_handle > 0; }

void McapTestApp::ControlCallback(tMCA_HANDLE handle, tMCA_CL mcl,
                                  uint8_t event, tMCA_CTRL* p_data) {
  McapMcl* mcap_mcl = FindMclByHandle(mcl);
  McapMdl* mcap_mdl = nullptr;
  printf("%s: mcap_handle=%d, mcl_handle=%d, event=%s (0x%02x)\n", __func__,
         handle, mcl, dump_mcap_events(event), event);
  if (_mcap_handle != handle) {
    LOG(ERROR) << "MCAP handle mismatch, self=" << _mcap_handle
               << ", other=" << handle;
    return;
  }
  switch (event) {
    case MCA_ERROR_RSP_EVT:
      print_mcap_event(&p_data->rsp);
      break;

    case MCA_CREATE_CFM_EVT:
      // Called when MCA_CreateMdl succeeded step 1 when response is received
      print_mcap_event(&p_data->create_cfm);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL " << (int)mcl << " not connected";
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->create_cfm.mdl_id);
      if (!mcap_mdl) {
        LOG(ERROR) << "MDL not found for id " << p_data->create_cfm.mdl_id;
        break;
      }
      if (mcap_mdl->GetResponseCode() >= 0) {
        LOG(ERROR) << "MDL already got response " << mcap_mdl->GetResponseCode()
                   << " for id " << p_data->create_cfm.mdl_id;
        break;
      }
      mcap_mdl->SetResponseCode(p_data->create_cfm.rsp_code);
      break;

    case MCA_CREATE_IND_EVT: {
      // Should be replied with MCA_CreateMdlRsp
      print_mcap_event(&p_data->create_ind);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL " << (int)mcl << " not connected";
        break;
      }
      McapMdep* mcap_mdep = FindMdepByHandle(p_data->create_ind.dep_id);
      if (!mcap_mdep) {
        LOG(ERROR) << "MDEP ID " << (int)p_data->create_ind.dep_id
                   << " does not exist";
        _mcap_test_interface->create_mdl_response(
            mcl, p_data->create_ind.dep_id, p_data->create_ind.mdl_id, 0,
            MCA_RSP_BAD_MDEP, get_test_channel_config());
        break;
      }
      bool ret = mcap_mcl->CreateMdlResponse(
          mcap_mdep->GetHandle(), p_data->create_ind.mdl_id,
          p_data->create_ind.dep_id, p_data->create_ind.cfg);
      LOG(INFO) << (ret ? "SUCCESS" : "FAIL");
      if (!ret) {
        _mcap_test_interface->create_mdl_response(
            mcl, p_data->create_ind.dep_id, p_data->create_ind.mdl_id, 0,
            MCA_RSP_NO_RESOURCE, get_test_channel_config());
      }
      break;
    }
    case MCA_RECONNECT_IND_EVT: {
      // Called when remote device asks to reconnect
      // reply with MCA_ReconnectMdlRsp
      print_mcap_event(&p_data->reconnect_ind);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL " << (int)mcl << " not connected";
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->reconnect_ind.mdl_id);
      if (mcap_mdl && !mcap_mdl->IsConnected()) {
        LOG(INFO) << "Creating reconnect response for MDL "
                  << (int)p_data->reconnect_ind.mdl_id;
        mcap_mdl->ReconnectResponse();
        break;
      }
      LOG_IF(WARNING, mcap_mdl && mcap_mdl->IsConnected())
          << "MDL ID " << (int)p_data->reconnect_ind.mdl_id
          << " is already connected";
      LOG_IF(WARNING, !mcap_mdl) << "No MDL for mdl_id "
                                 << p_data->reconnect_ind.mdl_id;
      tMCA_DEP mdep_handle = 0;
      if (_mdep_list.size() > 0) {
        mdep_handle = _mdep_list[0].GetHandle();
      } else {
        LOG(ERROR) << "Cannot find any available MDEP";
      }
      tMCA_RESULT ret = _mcap_test_interface->reconnect_mdl_response(
          mcl, mdep_handle, p_data->reconnect_ind.mdl_id, MCA_RSP_BAD_MDL,
          get_test_channel_config());
      LOG_IF(INFO, ret != MCA_SUCCESS) << "ret=" << ret;
      break;
    }
    case MCA_RECONNECT_CFM_EVT:
      // Called when MCA_ReconnectMdl step 1, receives a response
      print_mcap_event(&p_data->reconnect_cfm);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL not connected for mcl_handle " << (int)mcl;
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->reconnect_cfm.mdl_id);
      if (!mcap_mdl) {
        LOG(ERROR) << "MDL not found for id " << p_data->reconnect_cfm.mdl_id;
        break;
      }
      if (mcap_mdl->GetResponseCode() >= 0) {
        LOG(ERROR) << "MDL already got response " << mcap_mdl->GetResponseCode()
                   << " for id " << p_data->reconnect_cfm.mdl_id;
        break;
      }
      mcap_mdl->SetResponseCode(p_data->reconnect_cfm.rsp_code);
      break;

    case MCA_ABORT_IND_EVT:
      print_mcap_event(&p_data->abort_ind);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL not connected for mcl_handle " << (int)mcl;
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->abort_ind.mdl_id);
      if (!mcap_mdl) {
        LOG(ERROR) << "MDL not found for id " << (int)p_data->abort_ind.mdl_id;
        break;
      }
      if (mcap_mdl->IsConnected()) {
        LOG(ERROR) << "MDL is already connected for id "
                   << (int)p_data->abort_ind.mdl_id;
      }
      mcap_mcl->RemoveMdl(p_data->abort_ind.mdl_id);
      break;

    case MCA_ABORT_CFM_EVT:
      // Called when MCA_Abort succeeded
      print_mcap_event(&p_data->abort_cfm);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL " << (int)mcl << " not connected";
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->abort_cfm.mdl_id);
      if (!mcap_mdl) {
        LOG(ERROR) << "MDL not found for id " << (int)p_data->abort_cfm.mdl_id;
        break;
      }
      if (mcap_mdl->IsConnected()) {
        LOG(ERROR) << "MDL is already connected for id "
                   << (int)p_data->abort_cfm.mdl_id;
      }
      mcap_mcl->RemoveMdl(p_data->abort_cfm.mdl_id);
      break;

    case MCA_DELETE_IND_EVT:
      print_mcap_event(&p_data->delete_ind);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL " << (int)mcl << " not connected";
        break;
      }
      if (p_data->delete_ind.mdl_id == MCA_ALL_MDL_ID) {
        mcap_mcl->RemoveAllMdl();
      } else {
        mcap_mcl->RemoveMdl(p_data->delete_ind.mdl_id);
      }
      break;

    case MCA_DELETE_CFM_EVT:
      // Called when MCA_Delete succeeded
      print_mcap_event(&p_data->delete_cfm);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL " << (int)mcl << " not connected";
        break;
      }
      if (p_data->delete_cfm.rsp_code) {
        LOG(ERROR) << "No success response " << (int)p_data->delete_cfm.rsp_code
                   << " when deleting MDL_ID "
                   << (int)p_data->delete_cfm.mdl_id;
        break;
      }
      if (p_data->delete_cfm.mdl_id == MCA_ALL_MDL_ID) {
        mcap_mcl->RemoveAllMdl();
      } else {
        mcap_mcl->RemoveMdl(p_data->delete_cfm.mdl_id);
      }
      break;

    case MCA_CONNECT_IND_EVT: {
      // Called when MCA_ConnectReq succeeded
      print_mcap_event(&p_data->connect_ind);
      LOG(INFO) << "Received MCL handle " << (int)mcl;
      RawAddress bd_addr = p_data->connect_ind.bd_addr;
      mcap_mcl = FindMclByPeerAddress(bd_addr);
      if (!mcap_mcl) {
        LOG(INFO) << "Creating new MCL for ID " << (int)mcl;
        _mcl_list.push_back(
            McapMcl(_mcap_test_interface, _mcap_handle, bd_addr));
        mcap_mcl = &_mcl_list[_mcl_list.size() - 1];
      }
      if (mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL is already connected for handle " << (int)mcl;
        break;
      }
      mcap_mcl->SetHandle(mcl);
      mcap_mcl->SetMtu(p_data->connect_ind.mtu);
      break;
    }
    case MCA_DISCONNECT_IND_EVT: {
      // Called when MCA_ConnectReq failed or MCA_DisconnectReq succeeded
      print_mcap_event(&p_data->disconnect_ind);
      RawAddress bd_addr = p_data->disconnect_ind.bd_addr;
      mcap_mcl = FindMclByPeerAddress(bd_addr);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for BD addr " << bd_addr;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(WARNING) << "MCL for " << bd_addr << " is already disconnected";
      }
      mcap_mcl->SetHandle(0);
      mcap_mcl->SetMtu(0);
      mcap_mcl->ResetAllMdl();
      break;
    }
    case MCA_OPEN_IND_EVT:
    // Called when MCA_CreateMdlRsp succeeded step 2, data channel is open
    // Called when MCA_ReconnectMdlRsp succeeded step 2, data channel is open
    case MCA_OPEN_CFM_EVT:
      // Called when MCA_CreateMdl succeeded step 2, data channel is open
      // Called when MCA_ReconnectMdl succeeded step 2, data channel is open
      // Called when MCA_DataChnlCfg succeeded
      print_mcap_event(&p_data->open_ind);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL not connected for mcl_handle " << (int)mcl;
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->open_ind.mdl_id);
      if (mcap_mdl) {
        if (mcap_mdl->IsConnected()) {
          LOG(ERROR) << "MDL is already connected for mcl_handle "
                     << (int)p_data->open_ind.mdl_id;
          break;
        }
        mcap_mdl->SetMtu(p_data->open_ind.mtu);
        mcap_mdl->SetHandle(p_data->open_ind.mdl);
      } else {
        LOG(ERROR) << "No MDL for mdl_id " << (int)p_data->reconnect_ind.mdl_id;
      }
      break;

    case MCA_CLOSE_IND_EVT:
    case MCA_CLOSE_CFM_EVT:
      // Called when MCA_CloseReq is successful
      print_mcap_event(&p_data->close_cfm);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL not connected for mcl_handle " << (int)mcl;
        break;
      }
      mcap_mdl = mcap_mcl->FindMdlById(p_data->close_cfm.mdl_id);
      if (mcap_mdl) {
        mcap_mdl->SetMtu(0);
        mcap_mdl->SetHandle(0);
      } else {
        LOG(WARNING) << "No MDL for mdl_id " << (int)p_data->close_cfm.mdl_id;
      }
      break;

    case MCA_CONG_CHG_EVT:
      print_mcap_event(&p_data->cong_chg);
      if (!mcap_mcl) {
        LOG(ERROR) << "No MCL for mcl_handle " << (int)mcl;
        break;
      }
      if (!mcap_mcl->IsConnected()) {
        LOG(ERROR) << "MCL not connected for mcl_handle " << (int)mcl;
        break;
      }
      break;

    case MCA_RSP_TOUT_IND_EVT:
    case MCA_SYNC_CAP_IND_EVT:
    case MCA_SYNC_CAP_CFM_EVT:
    case MCA_SYNC_SET_IND_EVT:
    case MCA_SYNC_SET_CFM_EVT:
    case MCA_SYNC_INFO_IND_EVT:
      print_mcap_event(&p_data->hdr);
      break;
  }
}

}  // namespace SYSTEM_BT_TOOLS_MCAP_TOOL