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

#define LOG_TAG "GCH_HidlCameraProvider"
//#define LOG_NDEBUG 0
#include <log/log.h>
#include <regex>

#include "camera_device.h"
#include "hidl_camera_device.h"
#include "hidl_camera_provider.h"
#include "hidl_utils.h"

namespace android {
namespace hardware {
namespace camera {
namespace provider {
namespace V2_7 {
namespace implementation {

namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;

using ::android::google_camera_hal::CameraDevice;
using ::android::hardware::Void;
using ::android::hardware::camera::common::V1_0::CameraDeviceStatus;
using ::android::hardware::camera::common::V1_0::TorchModeStatus;
using ::android::hardware::camera::common::V1_0::VendorTagSection;

const std::string HidlCameraProvider::kProviderName = "internal";
// "device@<version>/internal/<id>"
const std::regex HidlCameraProvider::kDeviceNameRegex(
    "device@([0-9]+\\.[0-9]+)/internal/(.+)");

android::sp<HidlCameraProvider> HidlCameraProvider::Create() {
  android::sp<HidlCameraProvider> provider = new HidlCameraProvider();

  status_t res = provider->Initialize();
  if (res != OK) {
    ALOGE("%s: Initializing HidlCameraProvider failed: %s(%d)", __FUNCTION__,
          strerror(-res), res);
    return nullptr;
  }

  return provider;
}

status_t HidlCameraProvider::Initialize() {
  google_camera_provider_ = CameraProvider::Create();
  if (google_camera_provider_ == nullptr) {
    ALOGE("%s: Creating CameraProvider failed.", __FUNCTION__);
    return NO_INIT;
  }

  camera_provider_callback_ = {
      .camera_device_status_change = google_camera_hal::CameraDeviceStatusChangeFunc(
          [this](std::string camera_id,
                 google_camera_hal::CameraDeviceStatus new_status) {
            if (callbacks_ == nullptr) {
              ALOGE("%s: callbacks_ is null", __FUNCTION__);
              return;
            }
            CameraDeviceStatus hidl_camera_device_status;
            status_t res = hidl_utils::ConvertToHidlCameraDeviceStatus(
                new_status, &hidl_camera_device_status);
            if (res != OK) {
              ALOGE(
                  "%s: Converting to hidl camera device status failed: %s(%d)",
                  __FUNCTION__, strerror(-res), res);
              return;
            }

            std::unique_lock<std::mutex> lock(callbacks_lock_);
            callbacks_->cameraDeviceStatusChange(
                "device@" +
                    device::V3_7::implementation::HidlCameraDevice::kDeviceVersion +
                    "/" + kProviderName + "/" + camera_id,
                hidl_camera_device_status);
          }),
      .physical_camera_device_status_change = google_camera_hal::
          PhysicalCameraDeviceStatusChangeFunc([this](
                                                   std::string camera_id,
                                                   std::string physical_camera_id,
                                                   google_camera_hal::CameraDeviceStatus
                                                       new_status) {
            if (callbacks_ == nullptr) {
              ALOGE("%s: callbacks_ is null", __FUNCTION__);
              return;
            }
            auto castResult =
                provider::V2_6::ICameraProviderCallback::castFrom(callbacks_);
            if (!castResult.isOk()) {
              ALOGE("%s: callbacks_ cannot be casted to version 2.6",
                    __FUNCTION__);
              return;
            }
            sp<provider::V2_6::ICameraProviderCallback> callbacks_2_6_ =
                castResult;
            if (callbacks_2_6_ == nullptr) {
              ALOGE("%s: callbacks_2_6_ is null", __FUNCTION__);
              return;
            }

            CameraDeviceStatus hidl_camera_device_status;
            status_t res = hidl_utils::ConvertToHidlCameraDeviceStatus(
                new_status, &hidl_camera_device_status);
            if (res != OK) {
              ALOGE(
                  "%s: Converting to hidl camera device status failed: %s(%d)",
                  __FUNCTION__, strerror(-res), res);
              return;
            }

            std::unique_lock<std::mutex> lock(callbacks_lock_);
            callbacks_2_6_->physicalCameraDeviceStatusChange(
                "device@" +
                    device::V3_7::implementation::HidlCameraDevice::kDeviceVersion +
                    "/" + kProviderName + "/" + camera_id,
                physical_camera_id, hidl_camera_device_status);
          }),
      .torch_mode_status_change = google_camera_hal::TorchModeStatusChangeFunc(
          [this](std::string camera_id,
                 google_camera_hal::TorchModeStatus new_status) {
            if (callbacks_ == nullptr) {
              ALOGE("%s: callbacks_ is null", __FUNCTION__);
              return;
            }

            TorchModeStatus hidl_torch_status;
            status_t res = hidl_utils::ConvertToHidlTorchModeStatus(
                new_status, &hidl_torch_status);
            if (res != OK) {
              ALOGE("%s: Converting to hidl torch status failed: %s(%d)",
                    __FUNCTION__, strerror(-res), res);
              return;
            }

            std::unique_lock<std::mutex> lock(callbacks_lock_);
            callbacks_->torchModeStatusChange(
                "device@" +
                    device::V3_7::implementation::HidlCameraDevice::kDeviceVersion +
                    "/" + kProviderName + "/" + camera_id,
                hidl_torch_status);
          }),
  };

  google_camera_provider_->SetCallback(&camera_provider_callback_);
  // purge pending malloc pages after initialization
  mallopt(M_PURGE, 0);
  return OK;
}

Return<Status> HidlCameraProvider::setCallback(
    const sp<ICameraProviderCallback>& callback) {
  bool first_time = false;
  {
    std::unique_lock<std::mutex> lock(callbacks_lock_);
    first_time = callbacks_ == nullptr;
    callbacks_ = callback;
  }
  google_camera_provider_->TriggerDeferredCallbacks();
#ifdef __ANDROID_APEX__
  if (first_time) {
    std::string ready_property_name = "vendor.camera.hal.ready.count";
    int ready_count = property_get_int32(ready_property_name.c_str(), 0);
    property_set(ready_property_name.c_str(),
                 std::to_string(++ready_count).c_str());
    ALOGI("HidlCameraProvider::setCallback() first time ready count: %d ",
          ready_count);
  }
#endif
  return Status::OK;
}

Return<void> HidlCameraProvider::getVendorTags(getVendorTags_cb _hidl_cb) {
  hidl_vec<VendorTagSection> hidl_vendor_tag_sections;
  std::vector<google_camera_hal::VendorTagSection> hal_vendor_tag_sections;

  status_t res =
      google_camera_provider_->GetVendorTags(&hal_vendor_tag_sections);
  if (res != OK) {
    ALOGE("%s: Getting vendor tags failed: %s(%d)", __FUNCTION__,
          strerror(-res), res);
    _hidl_cb(Status::INTERNAL_ERROR, hidl_vendor_tag_sections);
    return Void();
  }

  res = hidl_utils::ConvertToHidlVendorTagSections(hal_vendor_tag_sections,
                                                   &hidl_vendor_tag_sections);
  if (res != OK) {
    ALOGE("%s: Converting to hidl vendor tags failed: %s(%d)", __FUNCTION__,
          strerror(-res), res);
    _hidl_cb(Status::INTERNAL_ERROR, hidl_vendor_tag_sections);
    return Void();
  }

  _hidl_cb(Status::OK, hidl_vendor_tag_sections);
  return Void();
}

Return<void> HidlCameraProvider::getCameraIdList(getCameraIdList_cb _hidl_cb) {
  std::vector<uint32_t> camera_ids;
  hidl_vec<hidl_string> hidl_camera_ids;
  status_t res = google_camera_provider_->GetCameraIdList(&camera_ids);
  if (res != OK) {
    ALOGE("%s: Getting camera ID list failed: %s(%d)", __FUNCTION__,
          strerror(-res), res);
    _hidl_cb(Status::INTERNAL_ERROR, hidl_camera_ids);
    return Void();
  }

  hidl_camera_ids.resize(camera_ids.size());
  for (uint32_t i = 0; i < hidl_camera_ids.size(); i++) {
    // camera ID is in the form of "device@<major>.<minor>/<type>/<id>"
    hidl_camera_ids[i] =
        "device@" +
        device::V3_7::implementation::HidlCameraDevice::kDeviceVersion + "/" +
        kProviderName + "/" + std::to_string(camera_ids[i]);
  }

  _hidl_cb(Status::OK, hidl_camera_ids);
  return Void();
}

Return<void> HidlCameraProvider::getConcurrentStreamingCameraIds(
    getConcurrentStreamingCameraIds_cb _hidl_cb) {
  hidl_vec<hidl_vec<hidl_string>> hidl_camera_id_combinations;
  std::vector<std::unordered_set<uint32_t>> camera_id_combinations;
  status_t res = google_camera_provider_->GetConcurrentStreamingCameraIds(
      &camera_id_combinations);
  if (res != OK) {
    ALOGE(
        "%s: Getting the combinations of concurrent streaming camera ids "
        "failed: %s(%d)",
        __FUNCTION__, strerror(-res), res);
    _hidl_cb(Status::INTERNAL_ERROR, hidl_camera_id_combinations);
    return Void();
  }
  hidl_camera_id_combinations.resize(camera_id_combinations.size());
  int i = 0;
  for (auto& combination : camera_id_combinations) {
    hidl_vec<hidl_string> hidl_combination(combination.size());
    int c = 0;
    for (auto& camera_id : combination) {
      hidl_combination[c] = std::to_string(camera_id);
      c++;
    }
    hidl_camera_id_combinations[i] = hidl_combination;
    i++;
  }
  _hidl_cb(Status::OK, hidl_camera_id_combinations);
  return Void();
}

Return<void> HidlCameraProvider::isConcurrentStreamCombinationSupported(
    const hidl_vec<provider::V2_6::CameraIdAndStreamCombination>& configs,
    isConcurrentStreamCombinationSupported_cb _hidl_cb) {
  hidl_vec<CameraIdAndStreamCombination> configs2_7;
  configs2_7.resize(configs.size());
  for (size_t i = 0; i < configs.size(); i++) {
    configs2_7[i].cameraId = configs[i].cameraId;

    hidl_utils::ConvertStreamConfigurationV34ToV37(
        configs[i].streamConfiguration, &configs2_7[i].streamConfiguration);
  }

  return isConcurrentStreamCombinationSupported_2_7(configs2_7, _hidl_cb);
}

Return<void> HidlCameraProvider::isConcurrentStreamCombinationSupported_2_7(
    const hidl_vec<CameraIdAndStreamCombination>& configs,
    isConcurrentStreamCombinationSupported_cb _hidl_cb) {
  std::vector<google_camera_hal::CameraIdAndStreamConfiguration>
      devices_stream_configs(configs.size());
  status_t res = OK;
  size_t c = 0;
  for (auto& config : configs) {
    res = hidl_utils::ConverToHalStreamConfig(
        config.streamConfiguration,
        &devices_stream_configs[c].stream_configuration);
    if (res != OK) {
      ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
      _hidl_cb(Status::INTERNAL_ERROR, false);
      return Void();
    }
    uint32_t camera_id = atoi(config.cameraId.c_str());
    devices_stream_configs[c].camera_id = camera_id;
    c++;
  }
  bool is_supported = false;
  res = google_camera_provider_->IsConcurrentStreamCombinationSupported(
      devices_stream_configs, &is_supported);
  if (res != OK) {
    ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
    _hidl_cb(Status::INTERNAL_ERROR, false);
    return Void();
  }
  _hidl_cb(Status::OK, is_supported);
  return Void();
}

Return<void> HidlCameraProvider::isSetTorchModeSupported(
    isSetTorchModeSupported_cb _hidl_cb) {
  bool is_supported = google_camera_provider_->IsSetTorchModeSupported();
  _hidl_cb(Status::OK, is_supported);
  return Void();
}

Return<void> HidlCameraProvider::getCameraDeviceInterface_V1_x(
    const hidl_string& /*cameraDeviceName*/,
    getCameraDeviceInterface_V1_x_cb _hidl_cb) {
  _hidl_cb(Status::OPERATION_NOT_SUPPORTED, nullptr);
  return Void();
}

bool HidlCameraProvider::ParseDeviceName(const hidl_string& device_name,
                                         std::string* device_version,
                                         std::string* camera_id) {
  std::string device_name_std(device_name.c_str());
  std::smatch sm;

  if (std::regex_match(device_name_std, sm,
                       HidlCameraProvider::kDeviceNameRegex)) {
    if (device_version != nullptr) {
      *device_version = sm[1];
    }
    if (camera_id != nullptr) {
      *camera_id = sm[2];
    }
    return true;
  }
  return false;
}

Return<void> HidlCameraProvider::getCameraDeviceInterface_V3_x(
    const hidl_string& camera_device_name,
    getCameraDeviceInterface_V3_x_cb _hidl_cb) {
  std::unique_ptr<CameraDevice> google_camera_device;

  // Parse camera_device_name.
  std::string camera_id, device_version;

  bool match = ParseDeviceName(camera_device_name, &device_version, &camera_id);
  if (!match) {
    ALOGE("%s: Device name parse fail. ", __FUNCTION__);
    _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
    return Void();
  }

  status_t res = google_camera_provider_->CreateCameraDevice(
      atoi(camera_id.c_str()), &google_camera_device);
  if (res != OK) {
    ALOGE("%s: Creating CameraDevice failed: %s(%d)", __FUNCTION__,
          strerror(-res), res);
    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), nullptr);
    return Void();
  }

  auto hidl_camera_device =
      device::V3_7::implementation::HidlCameraDevice::Create(
          std::move(google_camera_device));
  if (hidl_camera_device == nullptr) {
    ALOGE("%s: Creating HidlCameraDevice failed", __FUNCTION__);
    _hidl_cb(Status::INTERNAL_ERROR, nullptr);
    return Void();
  }

  _hidl_cb(Status::OK, hidl_camera_device.release());
  return Void();
}

Return<void> HidlCameraProvider::notifyDeviceStateChange(
    hardware::hidl_bitfield<DeviceState> /*newState*/) {
  return Void();
}

}  // namespace implementation
}  // namespace V2_7
}  // namespace provider
}  // namespace camera
}  // namespace hardware
}  // namespace android