/*
 *Copyright (c) 2020, The Linux Foundation. All rights reserved.
 */

/******************************************************************************
 *
 *  Copyright 2018 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 "bt_target.h"
#include "bta_vcp_controller_api.h"
#include "bta_gatt_api.h"
#include "btm_int.h"
#include "device/include/controller.h"
#include "gap_api.h"
#include "gatt_api.h"
#include "gattc_ops_queue.h"
#include "osi/include/properties.h"

#include <base/bind.h>
#include <base/callback.h>
#include <base/logging.h>
#include <base/strings/string_number_conversions.h>
#include <hardware/bt_vcp_controller.h>
#include <vector>

using base::Closure;
using bluetooth::Uuid;
using bluetooth::bap::GattOpsQueue;
using bluetooth::vcp_controller::ConnectionState;

// Assigned Numbers for VCS
Uuid VCS_UUID          = Uuid::FromString("1844");
Uuid VCS_VOLUME_STATE_UUID      = Uuid::FromString("2B7D");
Uuid VCS_VOLUME_CONTROL_POINT_UUID   = Uuid::FromString("2B7E");
Uuid VCS_VOLUME_FLAGS_UUID      = Uuid::FromString("2B7F");

#define VCS_RETRY_SET_ABS_VOL 0x01
#define VCS_RETRY_SET_MUTE_STATE 0x02

// VCS Application Error Code
#define VCS_INVALID_CHANGE_COUNTER 0x80
#define VCS_OPCODE_NOT_SUPPORTED 0x81

void vcp_controller_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data);
void vcp_controller_encryption_callback(const RawAddress*, tGATT_TRANSPORT, void*, tBTM_STATUS);
const char* vcp_controller_gatt_callback_evt_str(uint8_t event);
const char* vcp_controller_handle_vcs_evt_str(uint8_t event);

class VcpControllerImpl;
static VcpControllerImpl* instance;

class RendererDevices {
 private:

 public:
  void Add(RendererDevice device) {
    if (FindByAddress(device.address) != nullptr) return;
    devices.push_back(device);
  }

  void Remove(const RawAddress& address) {
    for (auto it = devices.begin(); it != devices.end();) {
      if (it->address != address) {
        ++it;
        continue;
      }

      it = devices.erase(it);
      return;
    }
  }

  RendererDevice* FindByAddress(const RawAddress& address) {
    auto iter = std::find_if(devices.begin(), devices.end(),
                             [&address](const RendererDevice& device) {
                               return device.address == address;
                             });

    return (iter == devices.end()) ? nullptr : &(*iter);
  }

  RendererDevice* FindByConnId(uint16_t conn_id) {
    auto iter = std::find_if(devices.begin(), devices.end(),
                             [&conn_id](const RendererDevice& device) {
                               return device.conn_id == conn_id;
                             });

    return (iter == devices.end()) ? nullptr : &(*iter);
  }

  size_t size() { return (devices.size()); }

  std::vector<RendererDevice> devices;
};

class VcpControllerImpl : public VcpController {
 private:
  uint8_t gatt_if;
  bluetooth::vcp_controller::VcpControllerCallbacks* callbacks;
  RendererDevices rendererDevices;

 public:
  virtual ~VcpControllerImpl() = default;

  VcpControllerImpl(bluetooth::vcp_controller::VcpControllerCallbacks* callbacks)
      : gatt_if(0),
        callbacks(callbacks) {
    LOG(INFO) << "VcpControllerImpl gattc app register";

    BTA_GATTC_AppRegister(
        vcp_controller_gattc_callback,
        base::Bind(
            [](uint8_t client_id, uint8_t status) {
              if (status != GATT_SUCCESS) {
                LOG(ERROR) << "Can't start Vcp profile - no gatt "
                              "clients left!";
                return;
              }
              instance->gatt_if = client_id;
            }), true);
  }

  void Connect(const RawAddress& address, bool isDirect) override {
    LOG(INFO) << __func__ << " " << address << ", isDirect = " << logbool(isDirect);
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);

    if (rendererDevice) {
      LOG(INFO) << "Device already in connected/connecting state" << address;
      return;
    }

    rendererDevices.Add(RendererDevice(address));
    rendererDevice = rendererDevices.FindByAddress(address);
    if (!rendererDevice) {
      LOG(INFO) << "Device address could not be foundL";
      return;
    }
    rendererDevice->state = BTA_VCP_CONNECTING;
    callbacks->OnConnectionState(ConnectionState::CONNECTING, rendererDevice->address);

    if (!isDirect) {
      rendererDevice->bg_conn = true;
    }

    BTA_GATTC_Open(gatt_if, address, isDirect, GATT_TRANSPORT_LE, false);
  }

  void Disconnect(const RawAddress& address) override {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);

    if (!rendererDevice) {
      LOG(INFO) << "Device not connected to profile" << address;
      return;
    }

    LOG(INFO) << __func__ << " " << address;
    rendererDevice->state = BTA_VCP_DISCONNECTING;
    callbacks->OnConnectionState(ConnectionState::DISCONNECTING, rendererDevice->address);
    VcpGattClose(rendererDevice);
  }

  void SetAbsVolume(const RawAddress& address, uint8_t volume) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);

    if (!rendererDevice) {
      LOG(INFO) << "Device not connected to profile" << address;
      return;
    }

    if (rendererDevice->conn_id == 0) {
        LOG(INFO) << __func__ << ": GATT is not connected, skip set absolute volume";
        return;
    }

    if (rendererDevice->state != BTA_VCP_CONNECTED) {
      LOG(INFO)
          << __func__ << ": VCP is not connected, skip set absolute volume, state = "
          << loghex(rendererDevice->state);
      return;
    }
    // Send the data packet
    LOG(INFO) << __func__ << ": Set abs volume. device=" << rendererDevice->address
              << ", volume=" << loghex(volume);

    rendererDevice->vcs.pending_volume_setting = volume;

    uint8_t p_buf[256];
    SetAbsVolumeOp set_abs_vol_op;
    set_abs_vol_op.op_id  = VCS_CONTROL_POINT_OP_SET_ABS_VOL;
    set_abs_vol_op.change_counter = rendererDevice->vcs.volume_state.change_counter;
    set_abs_vol_op.volume_setting = volume;

    memcpy(p_buf, &set_abs_vol_op , sizeof(set_abs_vol_op));
    std::vector<uint8_t> vect_val(p_buf, p_buf + sizeof(set_abs_vol_op));

    GattOpsQueue::WriteCharacteristic(gatt_if,
        rendererDevice->conn_id, rendererDevice->vcs.volume_control_point_handle, vect_val,
        GATT_WRITE, VcpControllerImpl::OnSetAbsVolumeStatic, nullptr);
  }

  void Mute(const RawAddress& address) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);

    if (!rendererDevice) {
      LOG(INFO) << "Device not connected to profile" << address;
      return;
    }

    if (rendererDevice->conn_id == 0) {
        LOG(INFO) << __func__ << ": GATT is not connected, skip mute";
        return;
    }

    if (rendererDevice->state != BTA_VCP_CONNECTED) {
      LOG(INFO)
          << __func__ << ": VCP is not connected, skip mute, state = "
          << loghex(rendererDevice->state);
      return;
    }
    // Send the data packet
    LOG(INFO) << __func__ << ": Mute device=" << rendererDevice->address;

    rendererDevice->vcs.pending_mute_setting = VCS_MUTE_STATE;

    uint8_t p_buf[256];
    MuteOp mute_op;
    mute_op.op_id  = VCS_CONTROL_POINT_OP_MUTE;
    mute_op.change_counter = rendererDevice->vcs.volume_state.change_counter;

    memcpy(p_buf, &mute_op , sizeof(mute_op));
    std::vector<uint8_t> vect_val(p_buf, p_buf + sizeof(mute_op));

    GattOpsQueue::WriteCharacteristic(gatt_if,
        rendererDevice->conn_id, rendererDevice->vcs.volume_control_point_handle, vect_val,
        GATT_WRITE, VcpControllerImpl::OnMuteStatic, nullptr);
  }

  void Unmute(const RawAddress& address) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);

    if (!rendererDevice) {
      LOG(WARNING) << "Device not connected to profile" << address;
      return;
    }

    if (rendererDevice->conn_id == 0) {
        LOG(INFO) << __func__ << ": GATT is not connected, skip unmute.";
        return;
    }

    if (rendererDevice->state != BTA_VCP_CONNECTED) {
      LOG(INFO)
          << __func__ << ": VCP is not connected, skip unmute, state = "
          << loghex(rendererDevice->state);
      return;
    }
    // Send the data packet
    LOG(INFO) << __func__ << ": unmute device=" << rendererDevice->address;

    rendererDevice->vcs.pending_mute_setting = VCS_UNMUTE_STATE;

    uint8_t p_buf[256];
    UnmuteOp unmute_op;
    unmute_op.op_id  = VCS_CONTROL_POINT_OP_UNMUTE;
    unmute_op.change_counter = rendererDevice->vcs.volume_state.change_counter;

    memcpy(p_buf, &unmute_op , sizeof(unmute_op));
    std::vector<uint8_t> vect_val(p_buf, p_buf + sizeof(unmute_op));

    GattOpsQueue::WriteCharacteristic(gatt_if,
        rendererDevice->conn_id, rendererDevice->vcs.volume_control_point_handle, vect_val,
        GATT_WRITE, VcpControllerImpl::OnUnmuteStatic, nullptr);
  }

  void VcpGattClose(RendererDevice* rendererDevice) {
    LOG(INFO) << __func__ << " " << rendererDevice->address;

    // Removes all registrations for connection.
    BTA_GATTC_CancelOpen(gatt_if, rendererDevice->address, false);
    rendererDevice->bg_conn = false;

    if (rendererDevice->conn_id) {
      GattOpsQueue::Clean(rendererDevice->conn_id);
      BTA_GATTC_Close(rendererDevice->conn_id);
    } else {
       // cancel pending direct connect
      BTA_GATTC_CancelOpen(gatt_if, rendererDevice->address, true);
      PostDisconnected(rendererDevice);
    }
  }

  void OnGattConnected(tGATT_STATUS status, uint16_t conn_id,
                       tGATT_IF client_if, RawAddress address,
                       tBTA_TRANSPORT transport, uint16_t mtu) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);
    LOG(INFO) << __func__ <<  ": address=" << address << ", conn_id=" << conn_id;

    if (!rendererDevice) {
      LOG(WARNING) << "Closing connection to non volume renderer device, address="
                   << address;
      BTA_GATTC_Close(conn_id);
      return;
    }

    if (status != GATT_SUCCESS) {
      if (rendererDevice->bg_conn) {
        // whitelist connection failed, that's ok.
        LOG(INFO) << "bg conn failed, return immediately";
        return;
      }

      LOG(INFO) << "Failed to connect to volume renderer device";
      rendererDevices.Remove(address);
      callbacks->OnConnectionState(ConnectionState::DISCONNECTED, address);
      return;
    }

    if (rendererDevice->bg_conn) {
        LOG(INFO) << __func__ <<  ": backgound connection from: address=" << address;
    }

    rendererDevice->bg_conn = false;
    rendererDevice->conn_id = conn_id;

    /* verify bond */
    uint8_t sec_flag = 0;
    BTM_GetSecurityFlagsByTransport(address, &sec_flag, BT_TRANSPORT_LE);

    LOG(INFO) << __func__ <<  ": sec_flag =" << loghex(sec_flag);
    if (sec_flag & BTM_SEC_FLAG_ENCRYPTED) {
      /* if link has been encrypted */
      OnEncryptionComplete(address, true);
      return;
    }

    if (sec_flag & BTM_SEC_FLAG_LKEY_KNOWN) {
      /* if bonded and link not encrypted */
      sec_flag = BTM_BLE_SEC_ENCRYPT;
      BTM_SetEncryption(address, BTA_TRANSPORT_LE, vcp_controller_encryption_callback, nullptr,
                        sec_flag);
      return;
    }

    /* otherwise let it go through */
    OnEncryptionComplete(address, true);
  }

  void OnGattDisconnected(tGATT_STATUS status, uint16_t conn_id,
                          tGATT_IF client_if, RawAddress remote_bda,
                          tBTA_GATT_REASON reason) {
    RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

    if (!rendererDevice) {
      LOG(WARNING) << "Skipping unknown device disconnect, conn_id="
              << loghex(conn_id);
      return;
    }
    LOG(INFO) << __func__ << ": conn_id=" << loghex(conn_id)
            << ", reason=" << loghex(reason) << ", remote_bda=" << remote_bda;

    PostDisconnected(rendererDevice);
  }

  void PostDisconnected(RendererDevice* rendererDevice) {
    LOG(INFO) << __func__ << " " << rendererDevice->address;
    rendererDevice->state = BTA_VCP_DISCONNECTED;

    if(rendererDevice->vcs.volume_state_handle != 0xFFFF) {
      BTIF_TRACE_WARNING("%s: Deregister notifications", __func__);
      BTA_GATTC_DeregisterForNotifications(gatt_if,
                         rendererDevice->address,
                         rendererDevice->vcs.volume_state_handle);
    }
    if(rendererDevice->vcs.volume_flags_handle != 0xFFFF) {
      BTIF_TRACE_WARNING("%s: Deregister notifications", __func__);
      BTA_GATTC_DeregisterForNotifications(gatt_if,
                         rendererDevice->address,
                         rendererDevice->vcs.volume_flags_handle);
    }

    if (rendererDevice->conn_id) {
      GattOpsQueue::Clean(rendererDevice->conn_id);
      rendererDevice->conn_id = 0;
    }

    callbacks->OnConnectionState(ConnectionState::DISCONNECTED, rendererDevice->address);
    rendererDevices.Remove(rendererDevice->address);
  }

  void OnEncryptionComplete(const RawAddress& address, bool success) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);
    LOG(INFO) << __func__ << " " << address;

    if (!rendererDevice) {
      LOG(WARNING)  << "Skipping unknown device" << address;
      return;
    }

    if (!success) {
      LOG(ERROR) << "encryption failed";
      BTA_GATTC_Close(rendererDevice->conn_id);
      return;
    }

     BTA_GATTC_ServiceSearchRequest(rendererDevice->conn_id, &VCS_UUID);
  }

  void OnServiceSearchComplete(uint16_t conn_id, tGATT_STATUS status) {
    RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);
    LOG(INFO) << __func__;

    if (!rendererDevice) {
      LOG(WARNING)  << "Skipping unknown device, conn_id=" << loghex(conn_id);
      return;
    }

    if (status != GATT_SUCCESS) {
      /* close connection and report service discovery complete with error */
      LOG(ERROR) << "Service discovery failed";
      VcpGattClose(rendererDevice);
      return;
    }

    const std::vector<gatt::Service>* services = BTA_GATTC_GetServices(conn_id);

    const gatt::Service* service = nullptr;
    if (services) {
      for (const gatt::Service& tmp : *services) {
        if (tmp.uuid == Uuid::From16Bit(UUID_SERVCLASS_GATT_SERVER)) {
            /*
          LOG(INFO) << "Found UUID_SERVCLASS_GATT_SERVER, handle="
                    << loghex(tmp.handle);
          const gatt::Service* service_changed_service = &tmp;
          FindServerChangedCCCHandle(conn_id, service_changed_service);
          */
        } else if (tmp.uuid == VCS_UUID) {
          LOG(INFO) << "Found Volume Control service, handle=" << loghex(tmp.handle);
          service = &tmp;
        }
      }
    } else {
      LOG(ERROR) << "no services found for conn_id: " << conn_id;
      return;
    }

    if (!service) {
      LOG(ERROR) << "No VCS found";
      VcpGattClose(rendererDevice);
      return;
    }

    for (const gatt::Characteristic& charac : service->characteristics) {
      if (charac.uuid == VCS_VOLUME_STATE_UUID) {
        rendererDevice->vcs.volume_state_handle = charac.value_handle;

        rendererDevice->vcs.volume_state_ccc_handle =
            FindCccHandle(conn_id, charac.value_handle);
        if (!rendererDevice->vcs.volume_state_ccc_handle) {
          LOG(ERROR) << __func__ << ": cannot find volume state CCC descriptor";
          continue;
        }

        LOG(INFO) << __func__
                  << ": vcs volume_state_handle=" << loghex(charac.value_handle)
                  << ", ccc=" << loghex(rendererDevice->vcs.volume_state_ccc_handle);
      } else if (charac.uuid == VCS_VOLUME_FLAGS_UUID) {
        rendererDevice->vcs.volume_flags_handle = charac.value_handle;

        rendererDevice->vcs.volume_flags_ccc_handle =
            FindCccHandle(conn_id, charac.value_handle);
        if (!rendererDevice->vcs.volume_flags_ccc_handle) {
          LOG(ERROR) << __func__ << ": cannot find volume flags CCC descriptor";
          continue;
        }

        LOG(INFO) << __func__
                  << ": vcs volume_flags_handle=" << loghex(charac.value_handle)
                  << ", ccc=" << loghex(rendererDevice->vcs.volume_flags_ccc_handle);
      } else if (charac.uuid == VCS_VOLUME_CONTROL_POINT_UUID) {
        // store volume control point!
        rendererDevice->vcs.volume_control_point_handle = charac.value_handle;
      } else {
        LOG(WARNING) << "Unknown characteristic found:" << charac.uuid;
      }
    }

    LOG(WARNING) << "reading vcs volume_state_handle";
    GattOpsQueue::ReadCharacteristic(gatt_if,
        conn_id, rendererDevice->vcs.volume_state_handle,
        VcpControllerImpl::OnVolumeStateReadStatic, nullptr);

  }

  void OnServiceChangeEvent(const RawAddress& address) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);
    if (!rendererDevice) {
      VLOG(2) << "Skipping unknown device" << address;
      return;
    }
    LOG(INFO) << __func__ << ": address=" << address;
    rendererDevice->service_changed_rcvd = true;
    GattOpsQueue::Clean(rendererDevice->conn_id);
  }

  void OnServiceDiscDoneEvent(const RawAddress& address) {
    RendererDevice* rendererDevice = rendererDevices.FindByAddress(address);
    if (!rendererDevice) {
      VLOG(2) << "Skipping unknown device" << address;
      return;
    }
    if (rendererDevice->service_changed_rcvd) {
      BTA_GATTC_ServiceSearchRequest(rendererDevice->conn_id, &VCS_UUID);
    }
  }

  void OnVolumeStateRead(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                 uint16_t handle, uint16_t len, uint8_t* value, void* data) {
    RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

    if (!rendererDevice) {
      LOG(WARNING)  << "Skipping unknown read event, conn_id=" << loghex(conn_id);
      return;
    }

    LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status)
                        << ", renderer device state: " << loghex(rendererDevice->state);

    if (status != GATT_SUCCESS) {
      LOG(ERROR) << "Error reading Volume State for device" << rendererDevice->address;
    } else {
      uint8_t* p = value;
      uint8_t volume_setting;
      STREAM_TO_UINT8(volume_setting, p);
      rendererDevice->vcs.volume_state.volume_setting = volume_setting;

      uint8_t mute;
      STREAM_TO_UINT8(mute, p);
      rendererDevice->vcs.volume_state.mute = mute;

      uint8_t change_counter;
      STREAM_TO_UINT8(change_counter, p);
      rendererDevice->vcs.volume_state.change_counter = change_counter;
    }

    HandleVCSEvent(rendererDevice, VCS_VOLUME_STATE_READ_CMPL_EVT, status);
  }

  void OnVolumeFlagsRead(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                 uint16_t handle, uint16_t len, uint8_t* value, void* data) {
    RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

    if (!rendererDevice) {
      LOG(WARNING)  << "Skipping unknown read event, conn_id=" << loghex(conn_id);
      return;
    }

    LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status);

    if (status != GATT_SUCCESS) {
      LOG(ERROR) << "Error reading Volume Flags for device" << rendererDevice->address;
    } else {
      uint8_t* p = value;
      uint8_t volume_flags;
      STREAM_TO_UINT8(volume_flags, p);
      rendererDevice->vcs.volume_flags = volume_flags;
    }

    HandleVCSEvent(rendererDevice, VCS_VOLUME_FLAGS_READ_CMPL_EVT, status);
  }

   void OnVolumeStateCCCWrite(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                                 uint16_t handle, void* data) {
     RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

     if (!rendererDevice) {
       LOG(WARNING)  << "Skipping unknown read event, conn_id=" << loghex(conn_id);
       return;
     }

     LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status);

     HandleVCSEvent(rendererDevice, VCS_VOLUME_STATE_CCC_WRITE_CMPL_EVT, status);
   }

   void OnVolumeFlagsCCCWrite(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                                 uint16_t handle, void* data) {
     RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

     if (!rendererDevice) {
       LOG(WARNING)  << "Skipping unknown read event, conn_id=" << loghex(conn_id);
       return;
     }

     LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status);

     HandleVCSEvent(rendererDevice, VCS_VOLUME_FLAGS_CCC_WRITE_CMPL_EVT, status);
   }

   void OnSetAbsVolume(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                                 uint16_t handle, void* data) {
     RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

     if (!rendererDevice) {
       LOG(WARNING) << "Skipping unknown read event, conn_id=" << loghex(conn_id);
       return;
     }

     LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status);

     if (status != GATT_SUCCESS) {
       // Check for VCS Invalid Change Counter error, it may
       // conflict with GATT_NO_RESOURCES error.
       if (status == VCS_INVALID_CHANGE_COUNTER ||
           status == VCS_OPCODE_NOT_SUPPORTED) {
         LOG(ERROR) << __func__  << ": Error code: " << status
                               << " device: " << rendererDevice->address
                               << " Read Volume State to update change counter";

         rendererDevice->vcs.retry_cmd |= VCS_RETRY_SET_ABS_VOL;
         GattOpsQueue::ReadCharacteristic(gatt_if,
             conn_id, rendererDevice->vcs.volume_state_handle,
             VcpControllerImpl::OnVolumeStateReadStatic, nullptr);
       } else {
         LOG(ERROR) <<  __func__ << ": Other errors, not retry";
       }
     } else {
       rendererDevice->vcs.retry_cmd &= ~VCS_RETRY_SET_ABS_VOL;
       LOG(INFO) << "Set abs volume success " << rendererDevice->address;
     }
   }

   void OnMute(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                                 uint16_t handle, void* data) {
     RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

     if (!rendererDevice) {
       LOG(WARNING) << "Skipping unknown read event, conn_id=" << loghex(conn_id);
       return;
     }

     LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status);

     if (status != GATT_SUCCESS) {
       LOG(ERROR) << "Volume State Write failed" << rendererDevice->address
                            << "Read Volume State";

       rendererDevice->vcs.retry_cmd |= VCS_RETRY_SET_MUTE_STATE;
       GattOpsQueue::ReadCharacteristic(gatt_if,
           conn_id, rendererDevice->vcs.volume_state_handle,
           VcpControllerImpl::OnVolumeStateReadStatic, nullptr);
     } else {
       LOG(INFO) << "Mute success" << rendererDevice->address;
     }

   }

   void OnUnmute(uint16_t client_id, uint16_t conn_id, tGATT_STATUS status,
                                 uint16_t handle, void* data) {
     RendererDevice* rendererDevice = rendererDevices.FindByConnId(conn_id);

     if (!rendererDevice) {
       LOG(WARNING) << "Skipping unknown read event, conn_id=" << loghex(conn_id);
       return;
     }

     LOG(INFO) << __func__ << " " << rendererDevice->address << ", status: " << loghex(status);

     if (status != GATT_SUCCESS) {
       LOG(ERROR) << "Volume State Write failed" << rendererDevice->address
                            << "Read Volume State";

       rendererDevice->vcs.retry_cmd |= VCS_RETRY_SET_MUTE_STATE;
       GattOpsQueue::ReadCharacteristic(gatt_if,
           conn_id, rendererDevice->vcs.volume_state_handle,
           VcpControllerImpl::OnVolumeStateReadStatic, nullptr);
     } else {
       LOG(INFO) << "Unmute success" << rendererDevice->address;
     }
   }

  void RetryVolumeControlOp(RendererDevice* rendererDevice) {
    LOG(INFO) << __func__ << " " << rendererDevice->address;

    if (rendererDevice->vcs.retry_cmd & VCS_RETRY_SET_ABS_VOL) {
      rendererDevice->vcs.retry_cmd &= ~VCS_RETRY_SET_ABS_VOL;
      SetAbsVolume(rendererDevice->address, rendererDevice->vcs.pending_volume_setting);
    }

    if (rendererDevice->vcs.retry_cmd & VCS_RETRY_SET_MUTE_STATE) {
      rendererDevice->vcs.retry_cmd &= ~VCS_RETRY_SET_MUTE_STATE;
      if (rendererDevice->vcs.pending_mute_setting == VCS_MUTE_STATE) {
        Mute(rendererDevice->address);
      } else {
        Unmute(rendererDevice->address);
      }
    }
  }

  static void OnVolumeStateReadStatic(uint16_t client_id, uint16_t conn_id,
                                             tGATT_STATUS status,
                                             uint16_t handle, uint16_t len,
                                             uint8_t* value, void* data) {
    if (instance)
      instance->OnVolumeStateRead(client_id, conn_id, status, handle, len, value,
                                         data);
  }

  static void OnVolumeFlagsReadStatic(uint16_t client_id, uint16_t conn_id,
                                             tGATT_STATUS status,
                                             uint16_t handle, uint16_t len,
                                             uint8_t* value, void* data) {
    if (instance)
      instance->OnVolumeFlagsRead(client_id, conn_id, status, handle, len, value,
                                         data);
  }

  static void OnVolumeStateCCCWriteStatic(uint16_t client_id, uint16_t conn_id,
                                 tGATT_STATUS status, uint16_t handle, void* data) {
    if (instance)
      instance->OnVolumeStateCCCWrite(client_id, conn_id, status, handle, data);
  }

  static void OnVolumeFlagsCCCWriteStatic(uint16_t client_id, uint16_t conn_id,
                                 tGATT_STATUS status, uint16_t handle, void* data) {
    if (instance)
      instance->OnVolumeFlagsCCCWrite(client_id, conn_id, status, handle, data);
  }

  static void OnSetAbsVolumeStatic(uint16_t client_id, uint16_t conn_id,
                                 tGATT_STATUS status, uint16_t handle, void* data) {
    if (instance)
      instance->OnSetAbsVolume(client_id, conn_id, status, handle, data);
  }

  static void OnMuteStatic(uint16_t client_id, uint16_t conn_id,
                                 tGATT_STATUS status, uint16_t handle, void* data) {
    if (instance)
      instance->OnMute(client_id, conn_id, status, handle, data);
  }

  static void OnUnmuteStatic(uint16_t client_id, uint16_t conn_id,
                                 tGATT_STATUS status, uint16_t handle, void* data) {
    if (instance)
      instance->OnUnmute(client_id, conn_id, status, handle, data);
  }


  void OnNotificationEvent(uint16_t conn_id, uint16_t handle, uint16_t len,
                           uint8_t* value) {
    RendererDevice* device = rendererDevices.FindByConnId(conn_id);

    if (!device) {
      LOG(INFO) << __func__
                << ": Skipping unknown device, conn_id=" << loghex(conn_id);
      return;
    }

    if (handle == device->vcs.volume_state_handle) {
      if ( len != sizeof(device->vcs.volume_state)) {
        LOG(ERROR) << __func__ << ": Data Length mismatch, len=" << len
                << ", expecting " << sizeof(device->vcs.volume_state);
        return;
      }

      LOG(INFO) << __func__ << " " << device->address << " volume state notification";
      memcpy(&device->vcs.volume_state, value, len);
      callbacks->OnVolumeStateChange(device->vcs.volume_state.volume_setting,
              device->vcs.volume_state.mute, device->address);
    } else if (handle == device->vcs.volume_flags_handle) {
      if ( len != sizeof(device->vcs.volume_flags)) {
        LOG(ERROR) << __func__ << ": Data Length mismatch, len=" << len
                << ", expecting " << sizeof(device->vcs.volume_flags);
        return;
      }

      LOG(INFO) << __func__ << " " << device->address << " volume flags notification";
      memcpy(&device->vcs.volume_flags, value, len);
      callbacks->OnVolumeFlagsChange(device->vcs.volume_flags, device->address);
    } else {
      LOG(INFO) << __func__ << ": Mismatched handle, "
                << loghex(device->vcs.volume_state_handle)
                << " or " << loghex(device->vcs.volume_flags_handle)
                << "!=" << loghex(handle);
      return;
    }
  }

  void OnCongestionEvent(uint16_t conn_id, bool congested) {
    RendererDevice* device = rendererDevices.FindByConnId(conn_id);
    if (!device) {
      LOG(INFO) << __func__
                << ": Skipping unknown device, conn_id=" << loghex(conn_id);
      return;
    }

    LOG(WARNING) << __func__ << ": conn_id:" << loghex(conn_id)
                             << ", congested: " << congested;
    GattOpsQueue::CongestionCallback(conn_id, congested);
  }

  void HandleVCSEvent(RendererDevice* rendererDevice, uint32_t event, tGATT_STATUS status) {
    LOG(INFO) << __func__ << " event = " << vcp_controller_handle_vcs_evt_str(event);

    if (status != GATT_SUCCESS) {
      if (rendererDevice->state == BTA_VCP_CONNECTING) {
        LOG(ERROR) << __func__ << ": Error status while VCP connecting, Close GATT for device: "
                              << rendererDevice->address;
        VcpGattClose(rendererDevice);
        return;
      } else if  (rendererDevice->state == BTA_VCP_CONNECTED) {
        LOG(ERROR) << __func__ << ": Error status while VCP is connected for device: "
                              << rendererDevice->address;
        if (rendererDevice->vcs.retry_cmd != 0) {
          rendererDevice->vcs.retry_cmd = 0;
        }
        return;
      } else {
        LOG(ERROR) << __func__ << ": Error status in disconnected or disconnecting "
                              << "Igore handle VCS Event  for device: " << rendererDevice->address;
        return;
      }
    }

    switch (event) {
      case VCS_VOLUME_STATE_READ_CMPL_EVT: {
         if (rendererDevice->state == BTA_VCP_CONNECTING) {
          LOG(WARNING) << "Setup VCP connection, reading vcs volume_flags_handle";
          GattOpsQueue::ReadCharacteristic(gatt_if,
              rendererDevice->conn_id, rendererDevice->vcs.volume_flags_handle,
              VcpControllerImpl::OnVolumeFlagsReadStatic, nullptr);
          break;
        } else if (rendererDevice->state == BTA_VCP_CONNECTED) {
          if (rendererDevice->vcs.retry_cmd != 0) {
            RetryVolumeControlOp(rendererDevice);
          }
        }
        break;
      }

      case VCS_VOLUME_FLAGS_READ_CMPL_EVT: {
        if (rendererDevice->state == BTA_VCP_CONNECTING) {
          /* Register and enable the Volume State Notification */
          tGATT_STATUS register_status;
          register_status = BTA_GATTC_RegisterForNotifications(
              gatt_if, rendererDevice->address, rendererDevice->vcs.volume_state_handle);
          if (register_status != GATT_SUCCESS) {
            LOG(ERROR) << __func__
                       << ": BTA_GATTC_RegisterForNotifications failed, status="
                       << loghex(register_status);
            VcpGattClose(rendererDevice);
            return;
          }

          std::vector<uint8_t> value(2);
          uint8_t* ptr = value.data();
          UINT16_TO_STREAM(ptr, GATT_CHAR_CLIENT_CONFIG_NOTIFICATION);
          GattOpsQueue::WriteDescriptor(gatt_if,
                  rendererDevice->conn_id, rendererDevice->vcs.volume_state_ccc_handle,
                  std::move(value), GATT_WRITE, VcpControllerImpl::OnVolumeStateCCCWriteStatic,
                  nullptr);
        }
        break;
      }

      case VCS_VOLUME_STATE_CCC_WRITE_CMPL_EVT: {
        if (rendererDevice->state == BTA_VCP_CONNECTING) {
          /* Register and enable the Volume State Notification */
          tGATT_STATUS register_status;
          register_status = BTA_GATTC_RegisterForNotifications(
              gatt_if, rendererDevice->address, rendererDevice->vcs.volume_flags_handle);
          if (register_status != GATT_SUCCESS) {
            LOG(ERROR) << __func__
                   << ": BTA_GATTC_RegisterForNotifications failed, status="
                   << loghex(register_status);
            VcpGattClose(rendererDevice);
            return;
          }

          std::vector<uint8_t> value(2);
          uint8_t* ptr = value.data();
          UINT16_TO_STREAM(ptr, GATT_CHAR_CLIENT_CONFIG_NOTIFICATION);
          GattOpsQueue::WriteDescriptor(gatt_if,
                  rendererDevice->conn_id, rendererDevice->vcs.volume_flags_ccc_handle,
                  std::move(value), GATT_WRITE, VcpControllerImpl::OnVolumeFlagsCCCWriteStatic,
                  nullptr);
        }
        break;
      }

      case VCS_VOLUME_FLAGS_CCC_WRITE_CMPL_EVT: {
        if (rendererDevice->state == BTA_VCP_CONNECTING) {
            LOG(INFO) << __func__ << ": VCP Connection Setup complete";
            rendererDevice->state = BTA_VCP_CONNECTED;
            callbacks->OnConnectionState(ConnectionState::CONNECTED, rendererDevice->address);
            callbacks->OnVolumeFlagsChange(rendererDevice->vcs.volume_flags,
                    rendererDevice->address);
            callbacks->OnVolumeStateChange(rendererDevice->vcs.volume_state.volume_setting,
                    rendererDevice->vcs.volume_state.mute, rendererDevice->address);
            break;
        }
        break;
      }

      default:
        LOG(INFO) << __func__ << ": unexpected VCS event";
        break;
    }
  }

    // Find the handle for the client characteristics configuration of a given
  // characteristics
  uint16_t FindCccHandle(uint16_t conn_id, uint16_t char_handle) {
    const gatt::Characteristic* p_char =
        BTA_GATTC_GetCharacteristic(conn_id, char_handle);
    LOG(INFO) << __func__ << " " << ", conn_id: " << conn_id << ", char_handle: " << char_handle;

    if (!p_char) {
      LOG(WARNING) << __func__ << ": No such characteristic: " << char_handle;
      return 0;
    }

    for (const gatt::Descriptor& desc : p_char->descriptors) {
      if (desc.uuid == Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG))
        return desc.handle;
    }
    return 0;
  }

  void CleanUp() {
    LOG(INFO) << __func__;
    BTA_GATTC_AppDeregister(gatt_if);
    for (RendererDevice& device : rendererDevices.devices) {
      PostDisconnected(&device);
    }

    rendererDevices.devices.clear();
  }
};

void vcp_controller_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data) {
  LOG(INFO) << __func__ << " event = " << vcp_controller_gatt_callback_evt_str(event);

  if (p_data == nullptr) return;

  switch (event) {
    case BTA_GATTC_DEREG_EVT:
      break;

    case BTA_GATTC_OPEN_EVT: {
      if (!instance) return;
      tBTA_GATTC_OPEN& o = p_data->open;
      instance->OnGattConnected(o.status, o.conn_id, o.client_if, o.remote_bda,
                                o.transport, o.mtu);
      break;
    }

    case BTA_GATTC_CLOSE_EVT: {
      if (!instance) return;
      tBTA_GATTC_CLOSE& c = p_data->close;
      instance->OnGattDisconnected(c.status, c.conn_id, c.client_if,
                                   c.remote_bda, c.reason);
    } break;

    case BTA_GATTC_SEARCH_CMPL_EVT:
      if (!instance) return;
      instance->OnServiceSearchComplete(p_data->search_cmpl.conn_id,
                                        p_data->search_cmpl.status);
      break;

    case BTA_GATTC_NOTIF_EVT:
      if (!instance) return;
      if (!p_data->notify.is_notify || p_data->notify.len > GATT_MAX_ATTR_LEN) {
        LOG(ERROR) << __func__ << ": rejected BTA_GATTC_NOTIF_EVT. is_notify="
                   << p_data->notify.is_notify
                   << ", len=" << p_data->notify.len;
        break;
      }
      instance->OnNotificationEvent(p_data->notify.conn_id,
                                    p_data->notify.handle, p_data->notify.len,
                                    p_data->notify.value);
      break;

    case BTA_GATTC_ENC_CMPL_CB_EVT:
      if (!instance) return;
      instance->OnEncryptionComplete(p_data->enc_cmpl.remote_bda, true);
      break;

    case BTA_GATTC_SRVC_CHG_EVT:
      if (!instance) return;
      instance->OnServiceChangeEvent(p_data->remote_bda);
      break;

    case BTA_GATTC_SRVC_DISC_DONE_EVT:
      if (!instance) return;
      instance->OnServiceDiscDoneEvent(p_data->remote_bda);
      break;

    case BTA_GATTC_CONGEST_EVT:
      if (!instance) return;
      instance->OnCongestionEvent(p_data->congest.conn_id,
                                  p_data->congest.congested);
      break;

    case BTA_GATTC_SEARCH_RES_EVT:
    case BTA_GATTC_CANCEL_OPEN_EVT:
    case BTA_GATTC_CONN_UPDATE_EVT:

    default:
      break;
  }
}

void vcp_controller_encryption_callback(const RawAddress* address,
                            UNUSED_ATTR tGATT_TRANSPORT transport,
                            UNUSED_ATTR void* data, tBTM_STATUS status) {
  if (instance) {
    instance->OnEncryptionComplete(*address,
                                   status == BTM_SUCCESS ? true : false);
  }
}

void VcpController::Initialize(
            bluetooth::vcp_controller::VcpControllerCallbacks* callbacks) {
  LOG(INFO) << __func__ ;

  if (instance) {
    LOG(ERROR) << "Already initialized!";
  }

  instance = new VcpControllerImpl(callbacks);
}

bool VcpController::IsVcpControllerRunning() { return instance; }

VcpController* VcpController::Get() {
  CHECK(instance);
  return instance;
};

int VcpController::GetDeviceCount() {
  if (!instance) {
    LOG(INFO) << __func__ << ": Not initialized yet";
    return 0;
  }

  return (instance->GetDeviceCount());
}

void VcpController::CleanUp() {
  VcpControllerImpl* ptr = instance;
  instance = nullptr;

  ptr->CleanUp();

  delete ptr;
};

/*******************************************************************************
 *  Debugging functions
 ******************************************************************************/
#define CASE_RETURN_STR(const) \
  case const:                  \
    return #const;

const char* vcp_controller_gatt_callback_evt_str(uint8_t event) {
  switch (event) {
    CASE_RETURN_STR(BTA_GATTC_DEREG_EVT)
    CASE_RETURN_STR(BTA_GATTC_OPEN_EVT)
    CASE_RETURN_STR(BTA_GATTC_CLOSE_EVT)
    CASE_RETURN_STR(BTA_GATTC_SEARCH_CMPL_EVT)
    CASE_RETURN_STR(BTA_GATTC_NOTIF_EVT)
    CASE_RETURN_STR(BTA_GATTC_ENC_CMPL_CB_EVT)
    CASE_RETURN_STR(BTA_GATTC_SEARCH_RES_EVT)
    CASE_RETURN_STR(BTA_GATTC_CANCEL_OPEN_EVT)
    CASE_RETURN_STR(BTA_GATTC_SRVC_CHG_EVT)
    CASE_RETURN_STR(BTA_GATTC_CONN_UPDATE_EVT)
    CASE_RETURN_STR(BTA_GATTC_SRVC_DISC_DONE_EVT)
    CASE_RETURN_STR(BTA_GATTC_CONGEST_EVT)
    default:
      return (char*)"Unknown GATT Callback Event";
  }
}

const char* vcp_controller_handle_vcs_evt_str(uint8_t event) {
  switch (event) {
    CASE_RETURN_STR(VCS_VOLUME_STATE_READ_CMPL_EVT)
    CASE_RETURN_STR(VCS_VOLUME_FLAGS_READ_CMPL_EVT)
    CASE_RETURN_STR(VCS_VOLUME_STATE_CCC_WRITE_CMPL_EVT)
    CASE_RETURN_STR(VCS_VOLUME_FLAGS_CCC_WRITE_CMPL_EVT)
    default:
      return (char*)"Unknown handling VCS Event";
  }
}