/*
 * Copyright (c) 2021 by Allwinnertech Co., Ltd.
 *
 * 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 "CameraHALv3_4"
#include "v4l2_camera_hal.h"

#include <android-base/parseint.h>
#include <dirent.h>
#include <fcntl.h>
#include <linux/videodev2.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <algorithm>
#include <cstdlib>
#include <memory>
#include <string>
#include <unordered_set>
#include <iostream>
#include <sstream>

#include "camera_config.h"
#include "v4l2_camera.h"

/*
 * This file serves as the entry point to the HAL. It is modified from the
 * example default HAL available in hardware/libhardware/modules/camera.
 * It contains the module structure and functions used by the framework
 * to load and interface to this HAL, as well as the handles to the individual
 * camera devices.
 */

namespace v4l2_camera_hal {

// Default global camera hal.
static V4L2CameraHAL gCameraHAL;

V4L2CameraHAL::V4L2CameraHAL() : mCameras(), mCallbacks(NULL) {
  HAL_LOG_ENTER();

  // Find /dev/video* nodes.
  // Fix stream is not manager now.
  int ret;
  std::string node;

  // Test each for V4L2 support and uniqueness.
  int id = 0;
  int i = 0;
  char dev_node[16];
  sprintf(dev_node, "/dev/video%d", i);
  ret = access(dev_node, F_OK);
  if (ret == 0) {
    HAL_LOGV("Found video node %s.", dev_node);
  } else {
    HAL_LOGE("Cannot found video node %s. %s", dev_node, strerror(errno));
  }

  hal_merge_stream_flag = false;
  char * s_value;
  int pic_width = 0;
  int pic_height = 0;
  std::string tmp;
  std::vector<std::string> s_data;
  // id == 0 camera facing back;
  // id == 1 camera facing front;

  int MAX_NUM_OF_CAMERAS = CCameraConfig::numberOfCamera();
  for (id = 0; id <MAX_NUM_OF_CAMERAS; id ++) {
    int cameraId = getSupportCameraId(id);
    // camera config information
    std::shared_ptr<CCameraConfig> config =
        std::make_shared<CCameraConfig>(cameraId);
    if (config == 0) {
      HAL_LOGW("create CCameraConfig failed");
    } else {
      config->initParameters();
      config->dumpParameters();
    }
    mCameraConfig.push_back(config);

    s_value = config->supportPictureSizeValue();
    std::string st1 = s_value;
    std::stringstream input(st1);

    while (getline(input, tmp, ',')) {
        s_data.push_back(tmp);
    }
    for(auto s : s_data) {
        sscanf(s.c_str(), "%dx%d", &pic_width,&pic_height);
        if(pic_width * pic_height > 4000*3000) {
            hal_merge_stream_flag = true;
        }
    }

    V4L2Camera* cam(V4L2Camera::NewV4L2Camera(id,
                                              config,
                                              hal_merge_stream_flag));
    if (cam) {
      mCameras.push_back(cam);
    } else {
      HAL_LOGE("Failed to initialize camera at %s.", dev_node);
    }
    mCameraConfig.push_back(config);
    if (getSingleCameraId() == 0)
      break;
  }
}

V4L2CameraHAL::~V4L2CameraHAL() {
  HAL_LOG_ENTER();
  int MAX_NUM_OF_CAMERAS = CCameraConfig::numberOfCamera();
  for (int n = 0; n < MAX_NUM_OF_CAMERAS; n++) {
    if (mCameraConfig[n] != NULL) {
      // delete mCameraConfig[n];
      mCameraConfig[n] = NULL;
    }
    if (getSingleCameraId() == 0)
      break;
  }
}

int V4L2CameraHAL::getNumberOfCameras() {
  HAL_LOGV("returns %zu", mCameras.size());
  return mCameras.size();
}

int V4L2CameraHAL::getCameraInfo(int id, camera_info_t* info) {
  HAL_LOG_ENTER();
  if (id < 0 || id >= static_cast<int>(mCameras.size())) {
    return -EINVAL;
  }
  // TODO(b/29185945): Hotplugging: return -EINVAL if unplugged.
  return mCameras[id]->getInfo(info);
}

int V4L2CameraHAL::setCallbacks(const camera_module_callbacks_t* callbacks) {
  HAL_LOG_ENTER();
  mCallbacks = callbacks;
  return 0;
}

void V4L2CameraHAL::getVendorTagOps(vendor_tag_ops_t* UNUSED(ops)) {
  HAL_LOG_ENTER();
  // No vendor ops for this HAL. From <hardware/camera_common.h>:
  // "leave ops unchanged if no vendor tags are defined."
}

int V4L2CameraHAL::openLegacy(const hw_module_t* /*module*/,
                              const char* /*id*/,
                              uint32_t /*halVersion*/,
                              hw_device_t** /*device*/) {
  HAL_LOG_ENTER();
  // Not supported.
  return -ENOSYS;
}

int V4L2CameraHAL::setTorchMode(const char* camera_id, bool enabled) {
  HAL_LOG_ENTER();
  // TODO(b/29158098): HAL is required to respond appropriately if
  // the desired camera actually does support flash.
  int retVal = 0;
  int cam_id = std::atoi(camera_id);
  if (mCameraConfig[cam_id] != NULL) {
    if (!mCameraConfig[cam_id]->supportFlashMode()) {
      return -ENOSYS;
    }
  }

  HAL_LOGD("enabled:%d cam_id:%d", enabled, cam_id);
  if (cam_id == 1 && mCallbacks != NULL) {
    HAL_LOGV("no flash!cam_id:%d", cam_id);
    mCallbacks->torch_mode_status_change(mCallbacks,
                                         camera_id,
                                         TORCH_MODE_STATUS_NOT_AVAILABLE);
  } else {
    if (enabled) {
      retVal = mCameras[cam_id]->setFlashTorchMode(enabled);
      if (mCallbacks != NULL && !retVal) {
        mCallbacks->torch_mode_status_change(mCallbacks,
                                             camera_id,
                                             TORCH_MODE_STATUS_AVAILABLE_ON);
      }
    } else {
      retVal = mCameras[cam_id]->setFlashTorchMode(enabled);
      if (mCallbacks != NULL && !retVal) {
        mCallbacks->torch_mode_status_change(mCallbacks,
                                             camera_id,
                                             TORCH_MODE_STATUS_AVAILABLE_OFF);
      }
    }
  }
  return retVal;
}

int V4L2CameraHAL::openDevice(const hw_module_t* module,
                              const char* name,
                              hw_device_t** device) {
  HAL_LOG_ENTER();

  if (module != &HAL_MODULE_INFO_SYM.common) {
    HAL_LOGE(
        "Invalid module %p expected %p", module, &HAL_MODULE_INFO_SYM.common);
    return -EINVAL;
  }

  int id;
  if (!android::base::ParseInt(name, &id, 0, getNumberOfCameras() - 1)) {
    return -EINVAL;
  }
  if (mCameraConfig[id]->supportCameraMulplex()) {
    if (mCameras[id]->isBusy()) {
      return -EUSERS;
    }
  } else {
    uint32_t id_tmp;
    for (id_tmp = 0; id_tmp < mCameras.size(); id_tmp++) {
      if (mCameras[id_tmp]->isBusy()) {
        return -EUSERS;
      }
    }
  }

  if (mCallbacks != NULL) {
    const char* camera_id = "0";
    setTorchMode(camera_id, false);
    mCameras[0]->closeFlashTorch();
  }
  // TODO(b/29185945): Hotplugging: return -EINVAL if unplugged.

  return mCameras[id]->openDevice(module, device);
}

/*
 * The framework calls the following wrappers, which in turn
 * call the corresponding methods of the global HAL object.
 */

static int get_number_of_cameras() {
  return gCameraHAL.getNumberOfCameras();
}

static int get_camera_info(int id, struct camera_info* info) {
  return gCameraHAL.getCameraInfo(id, info);
}

static int set_callbacks(const camera_module_callbacks_t* callbacks) {
  return gCameraHAL.setCallbacks(callbacks);
}

static void get_vendor_tag_ops(vendor_tag_ops_t* ops) {
  return gCameraHAL.getVendorTagOps(ops);
}

static int open_legacy(const hw_module_t* module,
                       const char* id,
                       uint32_t halVersion,
                       hw_device_t** device) {
  return gCameraHAL.openLegacy(module, id, halVersion, device);
}

static int set_torch_mode(const char* camera_id, bool enabled) {
  return gCameraHAL.setTorchMode(camera_id, enabled);
}

static int open_dev(const hw_module_t* module,
                    const char* name,
                    hw_device_t** device) {
  return gCameraHAL.openDevice(module, name, device);
}

}  // namespace v4l2_camera_hal

static hw_module_methods_t v4l2_module_methods = {
  .open = v4l2_camera_hal::open_dev};

camera_module_t HAL_MODULE_INFO_SYM __attribute__((visibility("default"))) = {
  .common = {
    .tag = HARDWARE_MODULE_TAG,
    .module_api_version = CAMERA_MODULE_API_VERSION_2_4,
    .hal_api_version = HARDWARE_HAL_API_VERSION,
    .id = CAMERA_HARDWARE_MODULE_ID,
    .name = "V4L2 Camera HAL v3",
    .author = "ZJW",
    .methods = &v4l2_module_methods,
    .dso = nullptr,
    .reserved = {0},
  },
  .get_number_of_cameras = v4l2_camera_hal::get_number_of_cameras,
  .get_camera_info = v4l2_camera_hal::get_camera_info,
  .set_callbacks = v4l2_camera_hal::set_callbacks,
  .get_vendor_tag_ops = v4l2_camera_hal::get_vendor_tag_ops,
  .open_legacy = v4l2_camera_hal::open_legacy,
  .set_torch_mode = v4l2_camera_hal::set_torch_mode,
  .init = nullptr,
  .reserved = {nullptr, nullptr}};