/******************************************************************************
 *
 *  Copyright (C) 2018-2021 NXP Semiconductors
 *
 *  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 "NxpEse.h"
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include "phNxpEse_Api.h"
#ifdef NXP_BOOTTIME_UPDATE
#include "eSEClient.h"
#endif

namespace vendor {
namespace nxp {
namespace nxpese {
namespace V1_0 {
namespace implementation {
using android::base::StringPrintf;
// using android::hardware::secure_element::V1_0::implementation::SecureElement;
static android::sp<ISecureElementHalCallback> seCallback;
static android::sp<
    ::android::hardware::secure_element::V1_1::ISecureElementHalCallback>
    seCallback_1_1;
static android::sp<ISecureElementHalCallback> virtualISOCallback;
static android::sp<
    ::android::hardware::secure_element::V1_1::ISecureElementHalCallback>
    virtualISOCallback_1_1;
bool isSeHalV1_1 = false;
// Methods from ::vendor::nxp::nxpese::V1_0::INxpEse follow.
Return<void> NxpEse::setSeCallBack(
    const android::sp<ISecureElementHalCallback>& clientCallback) {
  seCallback = clientCallback;
  return Void();
}

Return<void> NxpEse::setSeCallBack_1_1(
    const sp<
        ::android::hardware::secure_element::V1_1::ISecureElementHalCallback>&
        clientCallback) {
  seCallback_1_1 = clientCallback;
  isSeHalV1_1 = true;
  return Void();
}

Return<void> NxpEse::setVirtualISOCallBack(
    const android::sp<ISecureElementHalCallback>& clientCallback) {
  virtualISOCallback = clientCallback;
  return Void();
}

Return<void> NxpEse::setVirtualISOCallBack_1_1(
    const android::sp<
        ::android::hardware::secure_element::V1_1::ISecureElementHalCallback>&
        clientCallback) {
  virtualISOCallback_1_1 = clientCallback;
  isSeHalV1_1 = true;
  return Void();
}
void NxpEse::initSEService() {
  ESESTATUS status = ESESTATUS_SUCCESS;
  ESESTATUS deInitStatus = ESESTATUS_SUCCESS;
  phNxpEse_initParams initParams;
  memset(&initParams, 0x00, sizeof(phNxpEse_initParams));
  initParams.initMode = ESE_MODE_NORMAL;
  initParams.mediaType = ESE_PROTOCOL_MEDIA_SPI_APDU_GATE;

  if (!seCallback && !isSeHalV1_1) return;

  if (!seCallback_1_1 && isSeHalV1_1) return;

  status = phNxpEse_open(initParams);
  if (status != ESESTATUS_SUCCESS) {
    goto exit;
  }

  status = phNxpEse_SetEndPoint_Cntxt(0);
  if (status != ESESTATUS_SUCCESS) {
    goto exit1;
  }
  status = phNxpEse_init(initParams);
  if (status != ESESTATUS_SUCCESS) {
    goto exit1;
  }
  status = phNxpEse_ResetEndPoint_Cntxt(0);
  if (status != ESESTATUS_SUCCESS) {
    goto exit2;
  }

  LOG(INFO) << "ESE SPI init complete !!!";
exit2:
  deInitStatus = phNxpEse_deInit();
exit1:
  status = phNxpEse_close(deInitStatus);
exit:
  if (status == ESESTATUS_SUCCESS) {
    if (isSeHalV1_1)
      seCallback_1_1->onStateChange_1_1(true, "NXP SE HAL init ok");
    else
      seCallback->onStateChange(true);
  } else {
    LOG(ERROR) << "eSE-Hal Init failed";
    if (isSeHalV1_1)
      seCallback_1_1->onStateChange_1_1(false, "NXP SE HAL init not ok");
    else
      seCallback->onStateChange(false);
  }
}

void NxpEse::initVIrtualISOService() {
  ESESTATUS status = ESESTATUS_SUCCESS;
  phNxpEse_initParams initParams;
  ESESTATUS deInitStatus = ESESTATUS_SUCCESS;
  memset(&initParams, 0x00, sizeof(phNxpEse_initParams));
  initParams.initMode = ESE_MODE_NORMAL;
  initParams.mediaType = ESE_PROTOCOL_MEDIA_SPI_APDU_GATE;

  if (!virtualISOCallback && !isSeHalV1_1) return;

  if (!virtualISOCallback_1_1 && isSeHalV1_1) return;

  status = phNxpEse_SetEndPoint_Cntxt(1);
  if (status != ESESTATUS_SUCCESS) {
    goto exit1;
  }
  status = phNxpEse_init(initParams);
  if (status != ESESTATUS_SUCCESS) {
    goto exit1;
  }
  status = phNxpEse_ResetEndPoint_Cntxt(1);
  if (status != ESESTATUS_SUCCESS) {
    goto exit2;
  }

  LOG(INFO) << "ESE SPI init complete !!!";
exit2:
  deInitStatus = phNxpEse_deInit();
exit1:
  status = phNxpEse_close(deInitStatus);

  if (status == ESESTATUS_SUCCESS) {
    if (isSeHalV1_1)
      virtualISOCallback_1_1->onStateChange_1_1(true, "NXP SE HAL init ok");
    else
      virtualISOCallback->onStateChange(true);
  } else {
    LOG(ERROR) << "eSE-Hal Init failed";
    if (isSeHalV1_1)
      virtualISOCallback_1_1->onStateChange_1_1(false,
                                                "NXP SE HAL init not ok");
    else
      virtualISOCallback->onStateChange(false);
  }
}
#ifdef NXP_BOOTTIME_UPDATE
Return<void> NxpEse::ioctlHandler(uint64_t ioctlType,
                                  ese_nxp_IoctlInOutData_t& inpOutData) {
  switch (ioctlType) {
    case HAL_ESE_IOCTL_NFC_JCOP_DWNLD: {
      // nfc_nci_IoctlInOutData_t* inpOutData =
      // (nfc_nci_IoctlInOutData_t*)inpOutData;
      int update_state = inpOutData.inp.data.nxpCmd.p_cmd[0];
      if (update_state == ESE_JCOP_UPDATE_COMPLETED ||
          update_state == ESE_LS_UPDATE_COMPLETED) {
        seteSEClientState(update_state);
        eSEClientUpdate_SE_Thread();
      }
    } break;
  }
  return Void();
}
#endif

Return<void> NxpEse::ioctl(uint64_t ioctlType,
                           const hidl_vec<uint8_t>& inOutData,
                           ioctl_cb _hidl_cb) {
  ese_nxp_IoctlInOutData_t inpOutData;
  ese_nxp_IoctlInOutData_t* pInOutData =
      (ese_nxp_IoctlInOutData_t*)&inOutData[0];

  /*data from proxy->stub is copied to local data which can be updated by
   * underlying HAL implementation since it's an inout argument*/
  memcpy(&inpOutData, pInOutData, sizeof(ese_nxp_IoctlInOutData_t));
  ESESTATUS status = phNxpEse_spiIoctl(ioctlType, &inpOutData);
#ifdef NXP_BOOTTIME_UPDATE
  ioctlHandler(ioctlType, inpOutData);
#endif
  /*copy data and additional fields indicating status of ioctl operation
   * and context of the caller. Then invoke the corresponding proxy callback*/
  inpOutData.out.ioctlType = ioctlType;
  inpOutData.out.result = status;
#ifdef NXP_BOOTTIME_UPDATE
  if (ioctlType == HAL_ESE_IOCTL_GET_ESE_UPDATE_STATE) {
    inpOutData.out.data.status =
        (getJcopUpdateRequired() | (getLsUpdateRequired() << 8));
  }
#endif
  hidl_vec<uint8_t> outputData;
  outputData.setToExternal((uint8_t*)&inpOutData.out,
                           sizeof(ese_nxp_ExtnOutputData_t));
  LOG(ERROR) << "GET ESE update state2 = " << inpOutData.out.data.status;
  _hidl_cb(outputData);
  return Void();
}

// Methods from ::android::hidl::base::V1_0::IBase follow.

}  // namespace implementation
}  // namespace V1_0
}  // namespace nxpese
}  // namespace nxp
}  // namespace vendor