// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "v4l2_stream.h"

#include <cstring>
#include <fcntl.h>

#include "control.h"

ispp_t rkispp_hw_info;
isp_t rkisp_hw_info;

namespace easymedia
{

    V4L2Context::V4L2Context(enum v4l2_buf_type cap_type, v4l2_io io_func, const std::string device)
        : fd(-1), capture_type(cap_type), vio(io_func), started(false)
#ifndef NDEBUG
          ,
          path(device)
#endif
    {
        const char* dev = device.c_str();
        fd = v4l2_open(dev, O_RDWR | O_CLOEXEC, 0);
        if (fd < 0) {
            LOG("open %s failed %m\n", dev);
        }
        LOG("open %s, fd %d\n", dev, fd);
    }

    V4L2Context::~V4L2Context()
    {
        if (fd >= 0) {
            SetStarted(false);
            v4l2_close(fd);
            LOGD("close %s, fd %d\n", path.c_str(), fd);
        }
    }

    bool V4L2Context::SetStarted(bool val)
    {
        std::lock_guard<std::mutex> _lk(mtx);
        if (started == val) {
            return true;
        }
        enum v4l2_buf_type cap_type = capture_type;
        unsigned int request = val ? VIDIOC_STREAMON : VIDIOC_STREAMOFF;
        if (IoCtrl(request, &cap_type) < 0) {
            LOG("ioctl(%d): %m\n", (int)request);
            return false;
        }
        started = val;
        return true;
    }

    int V4L2Context::IoCtrl(unsigned long int request, void* arg)
    {
        if (fd < 0) {
            errno = EINVAL;
            return -1;
        }
        return V4L2IoCtl(&vio, fd, request, arg);
    }

    V4L2MediaCtl::V4L2MediaCtl()
    {
    }

    V4L2MediaCtl::~V4L2MediaCtl()
    {
    }

    int get_ispp_subdevs(struct media_device* device, const char* devpath, ispp_t* ispp_info)
    {
        media_entity* entity = NULL;
        const char* entity_name = NULL;

        if (!device || !ispp_info || !devpath) {
            return -1;
        }

        strncpy(ispp_info->media_dev_path, devpath, sizeof(ispp_info->media_dev_path));

        entity = media_get_entity_by_name(device, "rkispp_m_bypass", strlen("rkispp_m_bypass"));
        if (entity) {
            entity_name = media_entity_get_devname(entity);
            if (entity_name) {
                strncpy(ispp_info->ispp_m_bypass_path, entity_name, sizeof(ispp_info->ispp_m_bypass_path));
            }
        }
        entity = media_get_entity_by_name(device, "rkispp_scale0", strlen("rkispp_scale0"));
        if (entity) {
            entity_name = media_entity_get_devname(entity);
            if (entity_name) {
                strncpy(ispp_info->ispp_scale0_path, entity_name, sizeof(ispp_info->ispp_scale0_path));
            }
        }
        entity = media_get_entity_by_name(device, "rkispp_scale1", strlen("rkispp_scale1"));
        if (entity) {
            entity_name = media_entity_get_devname(entity);
            if (entity_name) {
                strncpy(ispp_info->ispp_scale1_path, entity_name, sizeof(ispp_info->ispp_scale1_path));
            }
        }
        entity = media_get_entity_by_name(device, "rkispp_scale2", strlen("rkispp_scale2"));
        if (entity) {
            entity_name = media_entity_get_devname(entity);
            if (entity_name) {
                strncpy(ispp_info->ispp_scale2_path, entity_name, sizeof(ispp_info->ispp_scale2_path));
            }
        }

        return 0;
    }

    int get_isp_subdevs(struct media_device* device, const char* devpath, isp_t* isp_info)
    {
        media_entity* entity = NULL;
        const char* entity_name = NULL;

        if (!device || !isp_info || !devpath) {
            return -1;
        }

        strncpy(isp_info->media_dev_path, (char*)devpath, sizeof(isp_info->media_dev_path));
        entity = media_get_entity_by_name(device, "rkisp_mainpath", strlen("rkisp_mainpath"));
        if (entity) {
            entity_name = media_entity_get_devname(entity);
            if (entity_name) {
                strncpy(isp_info->isp_main_path, (char*)entity_name, sizeof(isp_info->isp_main_path));
            }
        }
        entity = media_get_entity_by_name(device, "rkisp_selfpath", strlen("rkisp_selfpath"));
        if (entity) {
            entity_name = media_entity_get_devname(entity);
            if (entity_name) {
                strncpy(isp_info->isp_self_path, (char*)entity_name, sizeof(isp_info->isp_self_path));
            }
        }

        return 0;
    }

    int V4L2MediaCtl::InitHwInfos()
    {
        char sys_path[64];
        FILE* fp = NULL;
        struct media_device* device = NULL;
        uint32_t i = 0;

        while (i < MAX_MEDIA_INDEX) {
            snprintf(sys_path, 64, "/dev/media%d", i++);
            fp = fopen(sys_path, "r");
            if (!fp) {
                continue;
            }
            fclose(fp);
            device = media_device_new(sys_path);

            /* Enumerate entities, pads and links. */
            media_device_enumerate(device);

            struct media_entity* entity = nullptr;
            entity = media_get_entity_by_name(device, RKISP_SUBDEV_NAME, strlen(RKISP_SUBDEV_NAME));
            if (entity != NULL) {
                LOG("find %s: %s\n", sys_path, RKISP_SUBDEV_NAME);
                get_isp_subdevs(device, sys_path, &rkisp_hw_info);
                goto media_unref;
            }

            entity = media_get_entity_by_name(device, RKIISPP_SUBDEV_NAME, strlen(RKIISPP_SUBDEV_NAME));
            if (entity != NULL) {
                LOG("find %s: %s\n", sys_path, RKIISPP_SUBDEV_NAME);
                get_ispp_subdevs(device, sys_path, &rkispp_hw_info);
                goto media_unref;
            }

        media_unref:
            media_device_unref(device);
        }
        return 0;
    }

    V4L2Stream::V4L2Stream(const char* param) : use_libv4l2(false), fd(-1), capture_type(V4L2_BUF_TYPE_VIDEO_CAPTURE)
    {
        memset(&vio, 0, sizeof(vio));
        std::map<std::string, std::string> params;
        std::list<std::pair<const std::string, std::string&>> req_list;
        std::string str_libv4l2;
        req_list.push_back(std::pair<const std::string, std::string&>(KEY_USE_LIBV4L2, str_libv4l2));
        req_list.push_back(std::pair<const std::string, std::string&>(KEY_DEVICE, device));
        req_list.push_back(std::pair<const std::string, std::string&>(KEY_SUB_DEVICE, sub_device));
        std::string cap_type;
        req_list.push_back(std::pair<const std::string, std::string&>(KEY_V4L2_CAP_TYPE, cap_type));
        int ret = parse_media_param_match(param, params, req_list);
        if (ret == 0) {
            return;
        }
        if (!str_libv4l2.empty()) {
            use_libv4l2 = !!std::stoi(str_libv4l2);
        }
        if (!cap_type.empty())
            capture_type = static_cast<enum v4l2_buf_type>(GetV4L2Type(cap_type.c_str()));
        v4l2_medctl = std::make_shared<V4L2MediaCtl>();
        if (v4l2_medctl) {
            ret = v4l2_medctl->InitHwInfos();
            if (ret) {
                return;
            }
        }
    }

    int V4L2Stream::Open()
    {
        if (!SetV4L2IoFunction(&vio, use_libv4l2)) {
            return -EINVAL;
        }
        if (!sub_device.empty()) {
            // TODO:
        }

        if (!strcmp(device.c_str(), MB_ENTITY_NAME)) {
            devname = std::string(rkispp_hw_info.ispp_m_bypass_path);
        } else if (!strcmp(device.c_str(), S0_ENTITY_NAME)) {
            devname = std::string(rkispp_hw_info.ispp_scale0_path);
        } else if (!strcmp(device.c_str(), S1_ENTITY_NAME)) {
            devname = std::string(rkispp_hw_info.ispp_scale1_path);
        } else if (!strcmp(device.c_str(), S2_ENTITY_NAME)) {
            devname = std::string(rkispp_hw_info.ispp_scale2_path);
        } else if (!strcmp(device.c_str(), "rkisp_mainpath")) {
            devname = std::string(rkisp_hw_info.isp_main_path);
        } else if (!strcmp(device.c_str(), "rkisp_selfpath")) {
            devname = std::string(rkisp_hw_info.isp_self_path);
        } else {
            devname = device;
        }
        v4l2_ctx = std::make_shared<V4L2Context>(capture_type, vio, devname);
        if (!v4l2_ctx) {
            return -ENOMEM;
        }
        fd = v4l2_ctx->GetDeviceFd();
        if (fd < 0) {
            v4l2_ctx = nullptr;
            return -1;
        }
        return 0;
    }

    int V4L2Stream::Close()
    {
        if (v4l2_ctx) {
            v4l2_ctx->SetStarted(false);
            v4l2_ctx = nullptr; // release reference
        }
        fd = -1;
        return 0;
    }

    int V4L2Stream::IoCtrl(unsigned long int request, ...)
    {
        va_list vl;
        va_start(vl, request);
        void* arg = va_arg(vl, void*);
        va_end(vl);
        switch (request) {
            case S_SUB_REQUEST: {
                auto sub = (SubRequest*)arg;
                return V4L2IoCtl(&vio, fd, sub->sub_request, sub->arg);
            }
            case S_STREAM_OFF: {
                return v4l2_ctx->SetStarted(false) ? 0 : -1;
            }
        }
        return -1;
    }

} // namespace easymedia