#include <ctype.h>
#include <errno.h>
#include <fcntl.h>  /* low-level i/o */
#include <getopt.h> /* getopt_long() */
#include <inttypes.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>

#include <linux/videodev2.h>
#include "common/mediactl/mediactl.h"
#include "rk_aiq_user_api_sysctl.h"

#include "../utils/log.h"
#include "config.h"

#define CLEAR(x) memset(&(x), 0, sizeof(x))
#define DBG(...)                              \
  do {                                        \
    if (!silent) printf("DBG: " __VA_ARGS__); \
  } while (0)
#define ERR(...)                          \
  do {                                    \
    fprintf(stderr, "ERR: " __VA_ARGS__); \
  } while (0)

/* Private v4l2 event */
#define CIFISP_V4L2_EVENT_STREAM_START (V4L2_EVENT_PRIVATE_START + 1)
#define CIFISP_V4L2_EVENT_STREAM_STOP (V4L2_EVENT_PRIVATE_START + 2)

#define RKAIQ_FILE_PATH_LEN 64
#define RKAIQ_FLASH_NUM_MAX 2

/* 1 vicap + 2 mipi + 1 bridge + 1 redundance */
#define MAX_MEDIA_NODES 5

#if SYS_START
#define IQ_PATH "/etc/iqfiles"
#elif CONFIG_OEM
#define IQ_PATH "/oem/etc/iqfiles"
#else
#define IQ_PATH "/etc/iqfiles"
#endif

#if CONFIG_DBUS
#if CONFIG_CALLFUNC
#include "call_fun_ipc.h"
#include "fun_map.h"
#endif
#include <gdbus.h>
#endif

#if CONFIG_DBSERVER
#include "db_monitor.h"
#include "isp_func.h"
#include "isp_n2d_ctl.h"
#include "manage.h"
#endif

enum { LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG };

int enable_minilog = 0;
#define LOG_TAG "ispserver"
int ispserver_log_level = LOG_INFO;

#define CLEAR(x) memset(&(x), 0, sizeof(x))
rk_aiq_sys_ctx_t *db_aiq_ctx = NULL;
rk_aiq_working_mode_t mode[MAX_MEDIA_NODES] = {
    RK_AIQ_WORKING_MODE_ISP_HDR2, RK_AIQ_WORKING_MODE_ISP_HDR2,
    RK_AIQ_WORKING_MODE_ISP_HDR2, RK_AIQ_WORKING_MODE_ISP_HDR2,
    RK_AIQ_WORKING_MODE_ISP_HDR2};

static int silent = 0;
static int width = 2688;
static int height = 1520;
static int has_mul_cam = 0;
static int fixfps = -1;
static bool need_sync_db = true;

#if SYS_START
static bool is_quick_start = true;
#else
static bool is_quick_start = false;
#endif

struct rkaiq_media_info {
  char sd_isp_path[RKAIQ_FILE_PATH_LEN];
  char vd_params_path[RKAIQ_FILE_PATH_LEN];
  char vd_stats_path[RKAIQ_FILE_PATH_LEN];
  char mainpath[RKAIQ_FILE_PATH_LEN];
  char sensor_entity_name[32];

  char mdev_path[32];
  int available;
  rk_aiq_sys_ctx_t *aiq_ctx;

  pthread_t pid;
  int camIndex;
};

static struct rkaiq_media_info media_infos[MAX_MEDIA_NODES];

static void errno_exit(const char *s) {
  ERR("%s error %d, %s\n", s, errno, strerror(errno));
  exit(EXIT_FAILURE);
}

static int xioctl(int fh, int request, void *arg) {
  int r;

  do {
    r = ioctl(fh, request, arg);
  } while (-1 == r && EINTR == errno);

  return r;
}

static int save_prepare_status(int cam_id, int status) {
  char pipe_name[128];
  char data[32];
  sprintf(pipe_name, "/tmp/.ispserver_cam%d", cam_id);
  int fd = open(pipe_name, O_RDWR | O_CREAT | O_TRUNC | O_SYNC);
  if (fd > 0) {
    snprintf(data, sizeof(data), "%d", status);
    write(fd, data, strlen(data));
    close(fd);
    sync();
  } else {
    printf("save_prepare_status open err\n");
  }
}

static int rkaiq_get_devname(struct media_device *device, const char *name,
                             char *dev_name) {
  const char *devname;
  struct media_entity *entity = NULL;

  entity = media_get_entity_by_name(device, name, strlen(name));
  if (!entity) return -1;

  devname = media_entity_get_devname(entity);

  if (!devname) {
    fprintf(stderr, "can't find %s device path!", name);
    return -1;
  }

  strncpy(dev_name, devname, RKAIQ_FILE_PATH_LEN);

  DBG("get %s devname: %s\n", name, dev_name);

  return 0;
}

int rkaiq_get_media_info(struct rkaiq_media_info *media_info) {
  struct media_device *device = NULL;
  const char *sensor_name;
  int ret;

  device = media_device_new(media_info->mdev_path);
  if (!device) return -ENOMEM;
  /* Enumerate entities, pads and links. */
  ret = media_device_enumerate(device);
  if (ret) return ret;
  if (!ret) {
    /* Try rkisp */
    ret =
        rkaiq_get_devname(device, "rkisp-isp-subdev", media_info->sd_isp_path);
    ret |= rkaiq_get_devname(device, "rkisp-input-params",
                             media_info->vd_params_path);
    ret |= rkaiq_get_devname(device, "rkisp-statistics",
                             media_info->vd_stats_path);
    ret |= rkaiq_get_devname(device, "rkisp_mainpath", media_info->mainpath);
  }
  if (ret) {
    fprintf(stderr, "Cound not find rkisp dev names, skipped %s\n",
            media_info->mdev_path);
    media_device_unref(device);
    return ret;
  }
  printf("=======mainpath=%s\n", media_info->mainpath);
  sensor_name = rk_aiq_uapi_sysctl_getBindedSnsEntNmByVd(media_info->mainpath);
  if (sensor_name == NULL || strlen(sensor_name) == 0) {
    fprintf(stderr, "ERR: No sensor attached to %s\n", media_info->mdev_path);
    media_device_unref(device);
    return -EINVAL;
  }
  printf("get sensor name=%s\n", sensor_name);
  strcpy(media_info->sensor_entity_name, sensor_name);

  media_device_unref(device);

  return ret;
}

static void db_config_sync(char *hdr_mode) {
#if CONFIG_DBSERVER
  if (need_sync_db && !is_quick_start) {
    /* IMAGE_ADJUSTMENT */
    int brightness = 50;
    int contrast = 50;
    int saturation = 50;
    int sharpness = 50;
    int hue = 50;
    hash_image_adjustment_get(&brightness, &contrast, &saturation, &sharpness,
                              &hue);
    LOG_INFO(
        "brightness:%d, contrast:%d, saturation:%d, sharpness:%d, hue:%d\n\n",
        brightness, contrast, saturation, sharpness, hue);
    brightness_set(brightness);
    contrast_set(contrast);
    saturation_set(saturation);
    sharpness_set(sharpness);
    hue_set(hue);
    /* EXPOSURE */
    exposure_para_set_by_hash();
    /* BLC */
    if (0 != atoi(hdr_mode)) {
      int hdr_level = 0;
      hash_image_blc_get(NULL, &hdr_level, NULL, NULL, NULL);
      blc_hdr_level_enum_set(hdr_level);
    } else {
      blc_normal_mode_para_set_by_hash();
    }
    /* IMAGE_ENHANCEMENT */
    nr_mode_t hash_nr_mode;
    dc_mode_t hash_dc_mode;
    work_mode_2_t dehaze_mode;
    int spatial_level = 0;
    int temporal_level = 0;
    int fec_level = 0;
    int dehaze_level = 0;
    int ldch_level = 0;
    int rotation_angle = 0;
    hash_image_enhancement_get(&hash_nr_mode, &hash_dc_mode, &dehaze_mode,
                               &spatial_level, &temporal_level, &dehaze_level,
                               &ldch_level, &fec_level, &rotation_angle);
    LOG_INFO(
        "nr_mode:%d, distortion_correction_mode:%d, dehaze_mode:%d, "
        "spatial_level:%d, temporal_level:%d, dehaze_level:%d, "
        "ldch_level:%d, fec_level:%d, rotation_angle: %d\n\n",
        hash_nr_mode, hash_dc_mode, dehaze_mode, spatial_level, temporal_level,
        dehaze_level, ldch_level, fec_level, rotation_angle);

    nr_para_set(hash_nr_mode, spatial_level, temporal_level);

    /* IMAGE_ADJUSTMENT */
    expPwrLineFreq_t frequency_mode;
    flip_mode_t mirror_mode;
    hash_image_video_adjustment_get(&frequency_mode, &mirror_mode);
    LOG_INFO("frequency_mode is %d, mirror_mode is %d\n\n", frequency_mode,
             mirror_mode);
    frequency_mode_set(frequency_mode);

    dehaze_para_set(dehaze_mode, dehaze_level);
    dc_para_set(hash_dc_mode, ldch_level, fec_level);

    /* WHITE_BALANCE */
    white_balance_set_by_hash_table();

    mirror_mode_set(mirror_mode);
    /* only for fbc*/
    bypass_stream_rotation_set(rotation_angle);
    /* NIGHT_TO_DAY*/
    night_to_day_para_cap_set_db();
    night2day_loop_run();
  }
#endif
}

static void init_engine(struct rkaiq_media_info *media_info) {
  int index;

#if CONFIG_DBSERVER
  if (need_sync_db && !is_quick_start) {
    rk_aiq_working_mode_t hdr_mode_db = RK_AIQ_WORKING_MODE_NORMAL;
    while (hash_image_hdr_mode_get4init(&hdr_mode_db)) {
      LOG_INFO("Get data is empty, please start dbserver\n");
      sleep(1);
    }
    LOG_INFO("hdr_mode_db: %d \n", hdr_mode_db);
    switch (hdr_mode_db) {
      case RK_AIQ_WORKING_MODE_NORMAL: {
        setenv("HDR_MODE", "0", 1);
        LOG_DEBUG("set hdr normal\n");
        break;
      }
      case RK_AIQ_WORKING_MODE_ISP_HDR2: {
        setenv("HDR_MODE", "1", 1);
        break;
      }
      case RK_AIQ_WORKING_MODE_ISP_HDR3: {
        setenv("HDR_MODE", "2", 1);
        break;
      }
    }
  }
#endif

  char *hdr_mode = getenv("HDR_MODE");
  if (hdr_mode) {
    LOG_INFO("hdr mode: %s\n", hdr_mode);
    if (0 == atoi(hdr_mode))
      mode[media_info->camIndex] = RK_AIQ_WORKING_MODE_NORMAL;
    else if (1 == atoi(hdr_mode))
      mode[media_info->camIndex] = RK_AIQ_WORKING_MODE_ISP_HDR2;
    else if (2 == atoi(hdr_mode))
      mode[media_info->camIndex] = RK_AIQ_WORKING_MODE_ISP_HDR3;
  } else {
    mode[media_info->camIndex] = RK_AIQ_WORKING_MODE_NORMAL;
  }
  /* if (media_info[media_info->camIndex].fix_nohdr_mode)
    mode[media_info->camIndex] = RK_AIQ_WORKING_MODE_NORMAL;
  for (index = 0; index < RKAIQ_CAMS_NUM_MAX; index++)
    if (media_info[cam_id].cams[index].link_enabled) break; */

  media_info->aiq_ctx = rk_aiq_uapi_sysctl_init(media_info->sensor_entity_name,
                                                IQ_PATH, NULL, NULL);
  if (has_mul_cam) rk_aiq_uapi_sysctl_setMulCamConc(media_info->aiq_ctx, 1);

#if CONFIG_DBSERVER
  /* sync fec from db*/
  if (need_sync_db && !is_quick_start) {
    int fec_en;
    hash_image_fec_enable_get4init(&fec_en, NULL);
    int fec_ret = rk_aiq_uapi_setFecEn(media_info->aiq_ctx, fec_en);
    LOG_INFO("set fec_en: %d, ret is %d\n", fec_en, fec_ret);
  }
  /* sync hdr mode for quick_start */
  if (!need_sync_db || is_quick_start) {
    hdr_global_value_set(mode[media_info->camIndex]);
  }
#endif

  if (rk_aiq_uapi_sysctl_prepare(media_info->aiq_ctx, width, height,
                                 RK_AIQ_WORKING_MODE_NORMAL)) {
    ERR("rkaiq engine prepare failed !\n");
    exit(-1);
  }
  db_aiq_ctx = media_info->aiq_ctx;
  save_prepare_status(media_info->camIndex, 1);

#if CONFIG_DBSERVER
  set_stream_on();
#endif

  if (fixfps > 0) {
#if CONFIG_DBSERVER
    isp_fix_fps_set(fixfps);
#else
    frameRateInfo_t fps_info;
    memset(&fps_info, 0, sizeof(fps_info));
    fps_info.fps = fixfps;
    fps_info.mode = OP_MANUAL;
    rk_aiq_uapi_setFrameRate(media_info->aiq_ctx, fps_info);
#endif
  }
  db_config_sync(hdr_mode);
}

static void start_engine(struct rkaiq_media_info *media_info) {
  DBG("device manager start\n");
  rk_aiq_uapi_sysctl_start(media_info->aiq_ctx);
  if (media_info->aiq_ctx == NULL) {
    ERR("rkisp_init engine failed\n");
    exit(-1);
  } else {
#if CONFIG_DBSERVER
#if SYS_START
    send_stream_on_signal();
#endif
#endif
    DBG("rkisp_init engine succeed\n");
  }
}

static void stop_engine(struct rkaiq_media_info *media_info) {
  rk_aiq_uapi_sysctl_stop(media_info->aiq_ctx, false);
}

static void deinit_engine(struct rkaiq_media_info *media_info) {
#if CONFIG_DBSERVER
  if (need_sync_db) {
    set_stream_off();
    night2day_loop_stop();
  }
#endif
  save_prepare_status(media_info->camIndex, 0);
  rk_aiq_uapi_sysctl_deinit(media_info->aiq_ctx);
}

// blocked func
static int wait_stream_event(int fd, unsigned int event_type, int time_out_ms) {
  int ret;
  struct v4l2_event event;

  CLEAR(event);

  do {
    /*
     * xioctl instead of poll.
     * Since poll() cannot wait for input before stream on,
     * it will return an error directly. So, use ioctl to
     * dequeue event and block until sucess.
     */
    ret = xioctl(fd, VIDIOC_DQEVENT, &event);
    if (ret == 0 && event.type == event_type) return 0;
  } while (true);

  return -1;
}

static int subscrible_stream_event(struct rkaiq_media_info *media_info, int fd,
                                   bool subs) {
  struct v4l2_event_subscription sub;
  int ret = 0;

  CLEAR(sub);
  sub.type = CIFISP_V4L2_EVENT_STREAM_START;
  ret = xioctl(fd, subs ? VIDIOC_SUBSCRIBE_EVENT : VIDIOC_UNSUBSCRIBE_EVENT,
               &sub);
  if (ret) {
    ERR("can't subscribe %s start event!\n", media_info->vd_params_path);
    exit(EXIT_FAILURE);
  }

  CLEAR(sub);
  sub.type = CIFISP_V4L2_EVENT_STREAM_STOP;
  ret = xioctl(fd, subs ? VIDIOC_SUBSCRIBE_EVENT : VIDIOC_UNSUBSCRIBE_EVENT,
               &sub);
  if (ret) {
    ERR("can't subscribe %s stop event!\n", media_info->vd_params_path);
  }

  DBG("subscribe events from %s success !\n", media_info->vd_params_path);

  return 0;
}

void *wait_thread_func() {
  LOG_INFO("wait_thread_func...q: %d, db: %d\n", is_quick_start, need_sync_db);
#if CONFIG_DBSERVER
  database_hash_init();
  while (!wait_dbus_init_func()) {
    if (dbus_warn_log_status_get()) {
      dbus_warn_log_close();
    }
    LOG_INFO("wait for dbus init\n");
    usleep(100000);
  }
  if (need_sync_db) {
    dbus_warn_log_open();
  }
  database_init();
  manage_init();
  rk_aiq_working_mode_t hdr_mode_db = RK_AIQ_WORKING_MODE_NORMAL;
  hash_image_hdr_mode_get4init(&hdr_mode_db);
  hdr_mode_set4db(hdr_mode_db);
  switch (hdr_mode_db) {
    case RK_AIQ_WORKING_MODE_NORMAL:
      is_quick_start = false;
      db_config_sync("0");
      break;
    case RK_AIQ_WORKING_MODE_ISP_HDR2:
      is_quick_start = false;
      db_config_sync("1");
      break;
    case RK_AIQ_WORKING_MODE_ISP_HDR3:
      is_quick_start = false;
      db_config_sync("2");
      break;
    default:
      LOG_ERROR("undefine hdr mode: %d, fail to sync db config\n", hdr_mode_db);
      break;
  }
#endif
}

static void main_exit(void) {
  LOG_INFO("server %s\n", __func__);
  for (int id = 0; id < MAX_MEDIA_NODES; id++) {
    if (media_infos[id].available) {
      LOG_INFO("stop engine camera index %d...\n", id);
      stop_engine(&media_infos[id]);
      LOG_INFO("deinit engine camera index %d...\n", id);
      deinit_engine(&media_infos[id]);
      media_infos[id].available = 0;
    }
  }
#if CONFIG_DBUS
#if CONFIG_CALLFUNC
  LOG_INFO("deinit call_fun_ipc_server...\n");
  call_fun_ipc_server_deinit();
#endif
#endif
}

void signal_crash_handler(int sig) {
#if CONFIG_DBUS
#if CONFIG_CALLFUNC
  call_fun_ipc_server_deinit();
#endif
#endif
  exit(-1);
}

void signal_exit_handler(int sig) {
#if CONFIG_DBUS
#if CONFIG_CALLFUNC
  call_fun_ipc_server_deinit();
#endif
#endif
  exit(0);
}

void parse_args(int argc, char **argv) {
  int c;
  int digit_optind = 0;

  while (1) {
    int this_option_optind = optind ? optind : 1;
    int option_index = 0;
    static struct option long_options[] = {
        {"silent", no_argument, 0, 's'},
        {"help", no_argument, 0, 'h'},
        {"nsd", no_argument, NULL, 'n'},
        {"fps", required_argument, NULL, 'f'},
        {0, 0, 0, 0}};

    c = getopt_long(argc, argv, "shnf", long_options, &option_index);
    if (c == -1) break;

    switch (c) {
      case 'w':
        width = atoi(optarg);
        break;
      case 'h':
        height = atoi(optarg);
        break;
      case 's':
        silent = 1;
        break;
      case 'f':
        fixfps = atoi(optarg);
        LOG_INFO("## fixfps: %d\n", fixfps);
        break;
      case 'n':
        need_sync_db = false;
        LOG_INFO("## need_sync_db: %d\n", need_sync_db);
        break;
      case '?':
        ERR("Usage: %s to start 3A engine\n"
            "         --silent,  optional, subpress debug log\n",
            argv[0]);
        exit(-1);

      default:
        ERR("?? getopt returned character code %c ??\n", c);
    }
  }
}

void *engine_thread(void *arg) {
  int ret = 0;
  int isp_fd;
  unsigned int stream_event = -1;
  struct rkaiq_media_info *media_info;

  media_info = (struct rkaiq_media_info *)arg;

  isp_fd = open(media_info->vd_params_path, O_RDWR);
  if (isp_fd < 0) {
    ERR("open %s failed %s\n", media_info->vd_params_path, strerror(errno));
    return NULL;
  }

  subscrible_stream_event(media_info, isp_fd, true);
  init_engine(media_info);

  for (;;) {
    DBG("%s: wait stream start event...\n", media_info->mdev_path);
    wait_stream_event(isp_fd, CIFISP_V4L2_EVENT_STREAM_START, -1);
    DBG("%s: wait stream start event success ...\n", media_info->mdev_path);

    start_engine(media_info);

    DBG("%s: wait stream stop event...\n", media_info->mdev_path);
    wait_stream_event(isp_fd, CIFISP_V4L2_EVENT_STREAM_STOP, -1);
    DBG("%s: wait stream stop event success ...\n", media_info->mdev_path);

    stop_engine(media_info);

#if CONFIG_DBSERVER
    if (!check_stream_status()) break;
#endif
  }

  deinit_engine(media_info);
  subscrible_stream_event(media_info, isp_fd, false);
  close(isp_fd);

  return NULL;
}

int main(int argc, char **argv) {
#ifdef ENABLE_MINILOGGER
  enable_minilog = 1;
  __minilog_log_init(argv[0], NULL, false, false, "ispserver", "1.0.0");
#endif

  int ret, i;
  int threads = 0;

  /* Line buffered so that printf can flash every line if redirected to
   * no-interactive device.
   */
  setlinebuf(stdout);

  parse_args(argc, argv);

  for (i = 0; i < MAX_MEDIA_NODES; i++) {
    sprintf(media_infos[i].mdev_path, "/dev/media%d", i);
    if (rkaiq_get_media_info(&media_infos[i])) {
      ERR("Bad media topology for: %s\n", media_infos[i].mdev_path);
      media_infos[i].available = 0;
      continue;
    }
    media_infos[i].available = 1;
    media_infos[i].camIndex = i;
    threads++;
  }

  if (threads > 1) has_mul_cam = 1;

#if CONFIG_DBSERVER
  if (!need_sync_db) dbus_warn_log_close();

  if (wait_dbus_init_func()) {
    LOG_INFO("dbus init complete, alter quick start false\n");
    is_quick_start = false;
  }

  if (!is_quick_start && (need_sync_db || wait_dbus_init_func())) {
    LOG_INFO("init for db\n");
    database_hash_init();
    database_init();
    manage_init();
  }

  LOG_INFO("before enter wait thread q: %d, db: %d\n", is_quick_start,
            need_sync_db);
  if (is_quick_start || !need_sync_db) {
    pthread_t wait_db_p;
    if (pthread_create(&wait_db_p, NULL, wait_thread_func, NULL) != 0) {
      LOG_INFO("enter wait thread for db error\n");
    }
  }
#endif

  for (i = 0; i < MAX_MEDIA_NODES; i++) {
    if (!media_infos[i].available) continue;
    ret = pthread_create(&media_infos[i].pid, NULL, engine_thread,
                         &media_infos[i]);
    if (ret) {
      media_infos[i].pid = 0;
      ERR("Failed to create camera engine thread for: %s\n",
          media_infos[i].mdev_path);
      errno_exit("Create thread failed");
    }
  }

#if CONFIG_DBUS
  pthread_detach(pthread_self());
  GMainLoop *main_loop;
  atexit(main_exit);
  signal(SIGTERM, signal_exit_handler);
  signal(SIGINT, signal_exit_handler);
  signal(SIGPIPE, SIG_IGN);
  signal(SIGBUS, signal_crash_handler);
  signal(SIGSEGV, signal_crash_handler);
  signal(SIGFPE, signal_crash_handler);
  signal(SIGABRT, signal_crash_handler);

#if CONFIG_CALLFUNC
  call_fun_ipc_server_init(map, sizeof(map) / sizeof(struct FunMap), DBUS_NAME,
                           DBUS_IF, DBUS_PATH, 0);
  LOG_INFO("call_fun_ipc_demo_server init\n");
#endif

  main_loop = g_main_loop_new(NULL, FALSE);

  g_main_loop_run(main_loop);
  if (main_loop) g_main_loop_unref(main_loop);
#endif

  for (i = 0; i < MAX_MEDIA_NODES; i++) {
    if (!media_infos[i].available || media_infos[i].pid == 0) continue;
    pthread_join(media_infos[i].pid, NULL);
  }

  return 0;
}