/*
 * Copyright 2020 Rockchip Electronics 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.
 *
 * author: added by <rimon.xu@rock-chips.com>
 *   date: 2020-06-08
 * module: eptz task node
 */
#include <dirent.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <math.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <unistd.h>

#include <pthread.h>

#include <linux/videodev2.h>
//#include <drm_fourcc.h>
#include <drm_fourcc.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

#include <fstream>
#include <iostream>
#include <vector>

//#include "RTMeshGenerator.h"
#include "RTNodeVFilterFec.h"     // NOLINT
#include "RTMediaBuffer.h" // NOLINT
#include "RTNodeCommon.h"

#define ISPP_MAX_VIDEO_NODE 60
#define MESH_PATH "/oem/usr/share/mesh"
#define MESH_PATH_1080 "/oem/usr/share/mesh1080"
#define OPT_FEC_CAMEAR_IDX "cameraIdx"
#define RKISPP_CMD_FEC_IN_OUT                                                  \
  _IOW('V', BASE_VIDIOC_PRIVATE + 10, struct rkispp_fec_in_out)

static int fecFd = -1;
static pthread_mutex_t fecMutex = PTHREAD_MUTEX_INITIALIZER;
#ifdef DEBUG_FEC
#include <sys/syscall.h>
pid_t gettid() { return syscall(SYS_gettid); }
#endif

int readFileList(const char *basePath) {
  DIR *dir;
  int found = -1;
  struct dirent *ptr;
  char filename[1000];

  if ((dir = opendir(basePath)) == NULL) {
    RT_LOGE("Open dir error...\n");
    return found;
  }

  while ((ptr = readdir(dir)) != NULL) {
    if (strcmp(ptr->d_name, ".") == 0 || strcmp(ptr->d_name, "..") == 0) {
      /// current dir OR parrent dir
      continue;
    } else if (ptr->d_type == 8) {
      /// file, check video*/name whether has rkispp_fec info
      if (strcmp(ptr->d_name, "name") == 0) {
        // RT_LOGD("d_name:%s/%s",basePath,ptr->d_name);
        memset(filename, '\0', sizeof(filename));
        strcpy(filename, basePath);
        strcat(filename, "/");
        strcat(filename, ptr->d_name);
        FILE *fp = fopen(filename, "rb");
        if (fp) {
          char buf[128];
          fgets(buf, 128, fp);
          // printf("buf=%s\n", buf);
          if (strstr(buf, "rkispp_fec") != NULL) {
            printf("found ispp fec node");
            found = 1;
            break;
          }
        }
      }
    } else if (ptr->d_type == 10) {
      // TODO: nothing
    } else if (ptr->d_type == 4) {
      // TODO: nothing
    }
  }
  closedir(dir);
  return found;
}

static int findFecEntry(char *entryName) {
  int found = -1;
  char path[128] = {0};
  for (int i = 0; i < ISPP_MAX_VIDEO_NODE; i++) {
    memset(path, 0, sizeof(path));
    snprintf(path, sizeof(path), "/sys/class/video4linux/video%d", i);
    if (0 == access(path, F_OK)) {
      found = readFileList(path);
      if (found > 0) {
        found = i;
        break;
      }
    }
  }

  if (found >= 0) {
    sprintf(entryName, "/dev/video%d", found);
  } else {
    RT_LOGE("failed to found fec entry:%d", found);
  }
  return found;
}

static int doFecProcess(struct rkispp_fec_in_out *fec) {
  pthread_mutex_lock(&fecMutex);
  int ret = -1;
  if (fecFd <= 0) {
    RT_LOGD("***************************\n");
    char fecEntryNode[32];
    ret = findFecEntry(fecEntryNode);
    RT_LOGD("fecEntryNode = %s", fecEntryNode);
    RT_LOGD("***************************\n");
    fecFd = open(fecEntryNode, O_RDWR, 0);
    // findFecNode("/sys/class/video4linux");
  }
  if (fecFd > 0) {
    ret = ioctl(fecFd, RKISPP_CMD_FEC_IN_OUT, fec);
    if (ret == -EAGAIN) // try again
      ret = ioctl(fecFd, RKISPP_CMD_FEC_IN_OUT, fec);
  }
  pthread_mutex_unlock(&fecMutex);
  return ret;
}

int alloc_drm_buffer(int fd, int width, int height, int bpp,
                     struct drm_buf *buf) {
  struct drm_mode_create_dumb alloc_arg;
  struct drm_mode_map_dumb mmap_arg;
  struct drm_mode_destroy_dumb destory_arg;
  void *map;
  int ret;

  memset(&alloc_arg, 0, sizeof(alloc_arg));
  alloc_arg.bpp = bpp;
  alloc_arg.width = width;
  alloc_arg.height = height;

  ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &alloc_arg);
  if (ret) {
    printf("failed to create dumb buffer\n");
    return ret;
  }

  memset(&mmap_arg, 0, sizeof(mmap_arg));
  mmap_arg.handle = alloc_arg.handle;
  ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mmap_arg);
  if (ret) {
    printf("failed to create map dumb\n");
    ret = -EINVAL;
    goto destory_dumb;
  }
  map = mmap(0, alloc_arg.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
             mmap_arg.offset);
  if (map == MAP_FAILED) {
    printf("failed to mmap buffer\n");
    ret = -EINVAL;
    goto destory_dumb;
  }
  ret = drmPrimeHandleToFD(fd, alloc_arg.handle, 0, &buf->dmabuf_fd);
  if (ret) {
    printf("failed to get dmabuf fd\n");
    munmap(map, alloc_arg.size);
    ret = -EINVAL;
    goto destory_dumb;
  }
  buf->size = alloc_arg.size;
  buf->map = map;

destory_dumb:
  memset(&destory_arg, 0, sizeof(destory_arg));
  destory_arg.handle = alloc_arg.handle;
  drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destory_arg);
  return ret;
}

int free_drm_buffer(int fd, struct drm_buf *buf) {
  if (buf) {
    close(buf->dmabuf_fd);
    munmap(buf->map, buf->size);
    free(buf);
  }
  return 0;
}

int fec_drm_open() { return drmOpen("rockchip", NULL); }

void fec_drm_close(int drm_fd) { close(drm_fd); }

int fec_open(char *dev) { return open(dev, O_RDWR, 0); }

void fec_close(int fd) { close(fd); }

int load_file(char *filename, int len, void *outbuf) {
  if (filename == nullptr) {
    RT_LOGE("mesh file is null , please check it\n");
    return -1;
  }
  FILE *fp = fopen(filename, "rb");
  int ret = -1;
  if (fp) {
    ret = fread(outbuf, 1, len, fp);
    fclose(fp);
  }
  return ret;
}

RTNodeVFilterFec::RTNodeVFilterFec()
    : width(1280), height(720), xintMesh(nullptr), xfraMesh(nullptr),
      yintMesh(nullptr), yfraMesh(nullptr), mProcessor(nullptr) {
  dumpCnt = 0;
  mLock = new RtMutex();
  std::string path = "/oem/usr/share/mesh/";
  // generateMapParms(path, width, height);
  RT_LOGE("create fec node\n");
}

RTNodeVFilterFec::~RTNodeVFilterFec() {
  free_drm_buffer(drmFd, yfraMesh);
  yfraMesh = nullptr;
  free_drm_buffer(drmFd, yintMesh);
  yintMesh = nullptr;
  free_drm_buffer(drmFd, xfraMesh);
  xfraMesh = nullptr;
  free_drm_buffer(drmFd, xintMesh);
  xintMesh = nullptr;
  fec_drm_close(drmFd);
  rt_safe_delete(mLock);
}

int RTNodeVFilterFec::allocMeshBufs() {
  int ret = -1;
  drmFd = fec_drm_open();
  if (drmFd < 0) {
    printf("failed to open rockchip drm");
    goto err_alloc;
  }
  meshSize[0] = calFecMeshsize(width, height);
  meshSize[1] = meshSize[0] * 2;

  RT_LOGD("\nmesh_size:%d", meshSize[0]);
  xintMesh = (struct drm_buf *)malloc(sizeof(struct drm_buf));
  ret = alloc_drm_buffer(drmFd, meshSize[0] * 2, 1, 8, xintMesh);
  if (ret)
    goto err_alloc;
  RT_LOGD("xint fd:%d size:%d", xintMesh->dmabuf_fd, xintMesh->size);

  xfraMesh = (struct drm_buf *)malloc(sizeof(struct drm_buf));
  ret = alloc_drm_buffer(drmFd, meshSize[0], 1, 8, xfraMesh);
  if (ret)
    goto err_alloc;
  RT_LOGD("xfra fd:%d size:%d", xfraMesh->dmabuf_fd, xfraMesh->size);

  yintMesh = (struct drm_buf *)malloc(sizeof(struct drm_buf));
  ret = alloc_drm_buffer(drmFd, meshSize[0] * 2, 1, 8, yintMesh);
  if (ret)
    goto err_alloc;
  RT_LOGD("yint fd:%d size:%d", yintMesh->dmabuf_fd, yintMesh->size);

  yfraMesh = (struct drm_buf *)malloc(sizeof(struct drm_buf));
  ret = alloc_drm_buffer(drmFd, meshSize[0], 1, 8, yfraMesh);
  if (ret)
    goto err_alloc;
  RT_LOGD("yfra fd:%d size:%d\n", yfraMesh->dmabuf_fd, yfraMesh->size);

  return 0;
err_alloc:
  free_drm_buffer(drmFd, yfraMesh);
  yfraMesh = nullptr;
  free_drm_buffer(drmFd, yintMesh);
  yintMesh = nullptr;
  free_drm_buffer(drmFd, xfraMesh);
  xfraMesh = nullptr;
  free_drm_buffer(drmFd, xintMesh);
  xintMesh = nullptr;
  fec_drm_close(drmFd);
  return -1;
}

int RTNodeVFilterFec::calFecMeshsize(int width, int height) {
  int mesh_size, mesh_left_height;
  int w = 32 * ((width + 31) / 32);
  int h = 32 * ((height + 31) / 32);
  int spb_num = (h + 127) >> 7;
  int left_height = h & 127;
  bool density = (width > 1920) ? true : false;
  int mesh_width = density ? (w / 32 + 1) : (w / 16 + 1);
  int mesh_height = density ? 9 : 17;

  if (!left_height)
    left_height = 128;
  mesh_left_height = density ? (left_height / 16 + 1) : (left_height / 8 + 1);
  mesh_size =
      (spb_num - 1) * mesh_width * mesh_height + mesh_width * mesh_left_height;

  return mesh_size;
}

int RTNodeVFilterFec::loadMeshfiles(const char *path) {
  if (!xintMesh || !xfraMesh || !yintMesh || !yfraMesh)
    return -1;

  char filename[64] = {0};
  int nRead = 0;
  snprintf(filename, sizeof(filename), "%s/meshxi_level%d", path, cameraIdx);
  nRead = load_file(filename, meshSize[1], xintMesh->map);
  RT_LOGD("mesh file: %s %d (%d)", filename, nRead, meshSize[1]);
  if (nRead <= 0)
    goto err_read;
  snprintf(filename, sizeof(filename), "%s/meshxf_level%d", path, cameraIdx);
  nRead = load_file(filename, meshSize[0], xfraMesh->map);
  RT_LOGD("mesh file: %s %d(%d)", filename, nRead, meshSize[0]);
  if (nRead <= 0)
    goto err_read;
  snprintf(filename, sizeof(filename), "%s/meshyi_level%d", path, cameraIdx);
  nRead = load_file(filename, meshSize[1], yintMesh->map);
  RT_LOGD("mesh file: %s %d", filename, nRead);
  if (nRead <= 0)
    goto err_read;
  snprintf(filename, sizeof(filename), "%s/meshyf_level%d", path, cameraIdx);
  nRead = load_file(filename, meshSize[0], yfraMesh->map);
  if (nRead <= 0)
    goto err_read;
  RT_LOGD("mesh file: %s %d", filename, nRead);
  return 0;
err_read:
  RT_LOGE("failed to read mesh files %s\n", path);
  return -1;
}

RT_RET RTNodeVFilterFec::open(RTTaskNodeContext *context) {
  RtMetaData *inputMeta = context->options();
  char fecEntryNode[32];
  RT_RET err = RT_OK;
  int ret = 0;

  fpsCtr = 0;
  fpsAbandonSet = 0;
  fpsInCount = 0;
  fpsAbandonCount = 0;

  cameraIdx = 0;
  inputMeta->findInt32(OPT_FEC_CAMEAR_IDX, &cameraIdx);
  inputMeta->findInt32("opt_width", &width);
  inputMeta->findInt32("opt_height", &height);
  inputMeta->findInt32("opt_fps_ctr", &fpsCtr);
  RT_LOGE("fec mesh files: %s cameraIdx=%d width=%d height=%d fpsCtr=%d\n",
          MESH_PATH, cameraIdx, width, height, fpsCtr);

  ret = findFecEntry(fecEntryNode);
  if (ret >= 0) {
    //   fpsAbandonSet = fpsCtr;
    ret = allocMeshBufs();
    if (ret == 0) {
      if (width == 1280)
        loadMeshSuccess = loadMeshfiles(MESH_PATH);
      else
        loadMeshSuccess = loadMeshfiles(MESH_PATH_1080);
    } else {
      RT_LOGE("failed to allock buffers for mesh files\n");
    }
  } else {
    mProcessor = new RTFECProcessor();
  }
  return err;
}

RT_RET RTNodeVFilterFec::close(RTTaskNodeContext *context) {
  RT_RET err = RT_OK;
  if (mProcessor)
    delete mProcessor;
  mProcessor = NULL;
  return err;
}

RT_RET RTNodeVFilterFec::doGpuProcess(RTTaskNodeContext *context) {
  // RT_LOGE("*******%d*", (int)gettid());
  RT_RET err = RT_OK;
  RTMediaBuffer *inputBuffer = RT_NULL;
  RTMediaBuffer *outputBuffer = RT_NULL;
  RTFECInfo mInfos;
  int ret = 0;

  outputBuffer = context->dequeOutputBuffer();
  if (outputBuffer == RT_NULL) {
    RT_LOGE("outputBuffer = RT_NULL");
    return RT_OK;
  }

  inputBuffer = context->dequeInputBuffer();
  if (inputBuffer == RT_NULL) {
    RT_LOGE("inputBuffer = RT_NULL");
    return err;
  }

  if (mProcessor) {
    mInfos.inputBuffer = inputBuffer;
    mInfos.outputBuffer = outputBuffer;
    mInfos.inW = width;
    mInfos.inH = height;
    mInfos.outW = width;
    mInfos.outH = height;
    mInfos.inFormat = DRM_FORMAT_NV12;
    mInfos.outFormat = DRM_FORMAT_NV12;
    mInfos.context = context;
    mInfos.mtx = &fecLock;
    mInfos.cv = &cv;
    mProcessor->process(mInfos);
    std::unique_lock<std::mutex> lck(fecLock);
    cv.wait(lck);
  } else {
    // TODO: send inputBuffer to next node ...
    inputBuffer = context->dequeInputBuffer();
    inputBuffer->getMetaData()->setInt32(OPT_FILTER_WIDTH, width);
    inputBuffer->getMetaData()->setInt32(OPT_FILTER_HEIGHT, height);
    inputBuffer->getMetaData()->setCString(OPT_STREAM_FMT_IN, "image:nv12");
    inputBuffer->getMetaData()->setInt32(kKeyFrameW, width);
    inputBuffer->getMetaData()->setInt32(kKeyFrameH, height);
    context->queueOutputBuffer(inputBuffer);
  }
  RT_LOGD("end");
  return err;
}

RT_RET RTNodeVFilterFec::process(RTTaskNodeContext *context) {
  RT_RET err = RT_OK;
  RTMediaBuffer *inputBuffer = RT_NULL;
  RTMediaBuffer *outputBuffer = RT_NULL;
  RT_BOOL doFec = RT_TRUE;
  int ret = 0;
  RtMutex::RtAutolock autoLock(mLock);
  if (mProcessor) {
    doGpuProcess(context);
    return err;
  }

  if (!xintMesh || !xfraMesh || !yintMesh || !yfraMesh)
    return err;
  if (fpsCtr) {
    if (fpsAbandonCount >= fpsAbandonSet) {
      fpsAbandonCount = 0;
    } else {
      doFec = RT_FALSE;
      if (!context->inputIsEmpty()) {
        fpsAbandonCount++;
        inputBuffer = context->dequeInputBuffer();
        inputBuffer->release();
      }
    }
  }

  if (doFec) {
    if (!context->inputIsEmpty() && loadMeshSuccess == 0) {
      outputBuffer = context->dequeOutputBuffer();
      if (outputBuffer == RT_NULL) {
        RT_LOGD("outputBuffer = RT_NULL");
        return RT_OK;
      }

      inputBuffer = context->dequeInputBuffer();

      struct rkispp_fec_in_out fec;
      fec.width = width;
      fec.height = height;
      fec.in_fourcc = V4L2_PIX_FMT_NV12;
      fec.out_fourcc = V4L2_PIX_FMT_NV12;
      fec.in_pic_fd = inputBuffer->getFd();
      fec.out_pic_fd = outputBuffer->getFd();
      fec.mesh_xint_fd = xintMesh->dmabuf_fd;
      fec.mesh_xfra_fd = xfraMesh->dmabuf_fd;
      fec.mesh_yint_fd = yintMesh->dmabuf_fd;
      fec.mesh_yfra_fd = yfraMesh->dmabuf_fd;

      outputBuffer->getMetaData()->setInt32(OPT_FILTER_WIDTH, width);
      outputBuffer->getMetaData()->setInt32(OPT_FILTER_HEIGHT, height);
      outputBuffer->getMetaData()->setCString(OPT_STREAM_FMT_IN, "image:nv12");
      outputBuffer->getMetaData()->setInt32(kKeyFrameW, width);
      outputBuffer->getMetaData()->setInt32(kKeyFrameH, height);

      ret = doFecProcess(&fec);
      if (ret == 0) {
        context->queueOutputBuffer(outputBuffer);
        inputBuffer->release();
      } else {
        RT_LOGE("failed to do fec");
        inputBuffer->getMetaData()->setInt32(OPT_FILTER_WIDTH, width);
        inputBuffer->getMetaData()->setInt32(OPT_FILTER_HEIGHT, height);
        inputBuffer->getMetaData()->setCString(OPT_STREAM_FMT_IN, "image:nv12");
        inputBuffer->getMetaData()->setInt32(kKeyFrameW, width);
        inputBuffer->getMetaData()->setInt32(kKeyFrameH, height);
        context->queueOutputBuffer(inputBuffer);
        outputBuffer->release();
        // RT_LOGD("doFilter fail, release inputBuffer");
        err = RT_OK;
      }
    } else if (!context->inputIsEmpty()) {
      // TODO: send inputBuffer to next node ...
      inputBuffer = context->dequeInputBuffer();
      inputBuffer->getMetaData()->setInt32(OPT_FILTER_WIDTH, width);
      inputBuffer->getMetaData()->setInt32(OPT_FILTER_HEIGHT, height);
      inputBuffer->getMetaData()->setCString(OPT_STREAM_FMT_IN, "image:nv12");
      inputBuffer->getMetaData()->setInt32(kKeyFrameW, width);
      inputBuffer->getMetaData()->setInt32(kKeyFrameH, height);
      context->queueOutputBuffer(inputBuffer);
      if (loadMeshSuccess != 0) {
        if (width == 1280)
          loadMeshSuccess = loadMeshfiles(MESH_PATH);
        else
          loadMeshSuccess = loadMeshfiles(MESH_PATH_1080);
      }
    } else {
      RT_LOGD("found no input buffer");
      err = RT_OK;
    }
  }
  return err;
}

RT_RET RTNodeVFilterFec::invokeInternal(RtMetaData *meta) {
  if (fpsCtr) {
    const char *command;
    meta->findCString(kKeyPipeInvokeCmd, &command);
    RT_LOGD("invoke(%s) internally.", command);
    RTSTRING_SWITCH(command) {
      RTSTRING_CASE("nn_fps_set")
          : meta->findInt32("nn_fps_set", &fpsAbandonSet);
      RT_LOGE("fpsAbandonSet %d", fpsAbandonSet);
      break;
    default:
      RT_LOGD("unsupported command=%d", command);
      break;
    }
  }
  return RT_OK;
}

static RTTaskNode *createFecFilter() { return new RTNodeVFilterFec(); }

/*****************************************
 * register node stub to RTTaskNodeFactory
 *****************************************/
RTNodeStub node_stub_filter_fec{
    .mUid = MKTAG('f', 'e', 'c', 'p'),
    .mName = NODE_NAME_RK_FEC,
    .mVersion = "v1.0",
    .mCreateObj = createFecFilter,
    .mCapsSrc      = { "video/x-raw", RT_PAD_SRC, RT_MB_TYPE_VFRAME, {RT_NULL, RT_NULL}, },
    .mCapsSink     = { "video/x-raw", RT_PAD_SINK, RT_MB_TYPE_VFRAME, {RT_NULL, RT_NULL} },
};

RT_NODE_FACTORY_REGISTER_STUB(node_stub_filter_fec);