/*
 * rk_aiq_user_api2_camgroup.cpp
 *
 *  Copyright (c) 2021 Rockchip Corporation
 *
 * 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.
 *
 */

#include "rk_aiq_user_api2_sysctl.h"
#include "rk_aiq_user_api2_camgroup.h"
#include "RkAiqCamGroupManager.h"
#include "common/panorama_stitchingApp.h"

using namespace RkCam;
using namespace XCam;

static XCamReturn
_cam_group_bind(rk_aiq_camgroup_ctx_t* camgroup_ctx, rk_aiq_sys_ctx_t* aiq_ctx)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    // bind aiq to group
    ret = camgroup_ctx->cam_group_manager->bind(aiq_ctx->_rkAiqManager.ptr());
    if (ret) {
        LOGE("bind sensor %s aiq ctx %p failed !", aiq_ctx->_sensor_entity_name, aiq_ctx);
        return ret;
    }

    camgroup_ctx->cam_group_manager->setContainerCtx(camgroup_ctx);

    // bind group to aiq
    aiq_ctx->_camGroupManager = camgroup_ctx->cam_group_manager.ptr();
    aiq_ctx->_analyzer->setCamGroupManager(aiq_ctx->_camGroupManager);
    // set first one as main cam
    aiq_ctx->_rkAiqManager->setCamGroupManager(aiq_ctx->_camGroupManager,
                                               camgroup_ctx->cam_ctxs_num == 0 ? true : false);

    camgroup_ctx->cam_ctxs_num++;
    camgroup_ctx->cam_ctxs_array[aiq_ctx->_camPhyId] = aiq_ctx;

    LOGD("%s: bind sensor %s aiq ctx success !", aiq_ctx->_sensor_entity_name, aiq_ctx);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
_cam_group_unbind(rk_aiq_camgroup_ctx_t* camgroup_ctx, rk_aiq_sys_ctx_t* aiq_ctx)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ret = camgroup_ctx->cam_group_manager->unbind(aiq_ctx->_camPhyId);
    if (ret) {
        LOGE("unbind sensor %s aiq ctx 0x%x failed !", aiq_ctx->_sensor_entity_name, aiq_ctx);
        return ret;
    }
    aiq_ctx->_camGroupManager = NULL;
    aiq_ctx->_analyzer->setCamGroupManager(NULL);
    aiq_ctx->_rkAiqManager->setCamGroupManager(NULL, false);
    camgroup_ctx->cam_ctxs_array[aiq_ctx->_camPhyId] = NULL;
    camgroup_ctx->cam_ctxs_num--;

    LOGD("%s: unbind sensor %s aiq ctx success !", aiq_ctx->_sensor_entity_name, aiq_ctx);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

rk_aiq_camgroup_ctx_t*
rk_aiq_uapi2_camgroup_create(rk_aiq_camgroup_instance_cfg_t* cfg)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rk_aiq_camgroup_ctx_t* camgroup_ctx = NULL;
    rk_aiq_sys_ctx_t* aiq_ctx = NULL;
    std::string single_iq_file;
    std::string camgroup_iq_file;
    std::string overlap_map_file;

    camgroup_ctx = new rk_aiq_camgroup_ctx_t();

    if (!camgroup_ctx)
        goto error;

    camgroup_ctx->cam_group_manager = new RkAiqCamGroupManager();
    if (!camgroup_ctx->cam_group_manager.ptr())
        goto error;

    camgroup_ctx->_apiMutex = new Mutex();
    //RKAIQ_API_SMART_LOCK(camgroup_ctx);

    if (cfg->sns_num > RK_AIQ_CAM_GROUP_MAX_CAMS) {
        LOGE("nums %s is over the max cams %d !", cfg->sns_num, RK_AIQ_CAM_GROUP_MAX_CAMS);
        return NULL;
    }

    camgroup_ctx->cam_type = RK_AIQ_CAM_TYPE_GROUP;
    camgroup_ctx->cam_ctxs_num = 0;
    memset(camgroup_ctx->cam_ctxs_array, 0, sizeof(camgroup_ctx->cam_ctxs_array));
    camgroup_ctx->_srcOverlapMap_s = NULL;
    camgroup_ctx->_camgroup_calib = NULL;

    if (cfg->config_file_dir) {
        if (cfg->single_iq_file) {
            //single_iq_file += cfg->config_file_dir;
            //single_iq_file += "/";
            single_iq_file += cfg->single_iq_file;
        }
        if (cfg->group_iq_file) {
            camgroup_iq_file += cfg->config_file_dir;
            camgroup_iq_file += "/";
            camgroup_iq_file += cfg->group_iq_file;
        }
        if (cfg->overlap_map_file) {
            overlap_map_file += cfg->config_file_dir;
            overlap_map_file += "/";
            overlap_map_file += cfg->overlap_map_file;
        }
    }

    if (overlap_map_file.length()) {
        camgroup_ctx->_srcOverlapMap_s = new RK_PS_SrcOverlapMap();
        ret = rk_aiq_uapi2_camgroup_getOverlapMap_from_file(overlap_map_file.c_str(),
                                                           &camgroup_ctx->_srcOverlapMap_s);
        if (ret) {
            delete camgroup_ctx->_srcOverlapMap_s;
            camgroup_ctx->_srcOverlapMap_s = NULL;
        }
    }

    for (int i = 0; i < cfg->sns_num; i++) {
        if (single_iq_file.length())
            rk_aiq_uapi_sysctl_preInit(cfg->sns_ent_nm_array[i],
                                       RK_AIQ_WORKING_MODE_NORMAL, /* nonsense */
                                       single_iq_file.c_str());

        if (cfg->pHwEvt_cb)
            rk_aiq_uapi2_sysctl_regHwEvtCb(cfg->sns_ent_nm_array[i],
                                           cfg->pHwEvt_cb,
                                           cfg->pHwEvtCbCtx);

        aiq_ctx = rk_aiq_uapi_sysctl_init(cfg->sns_ent_nm_array[i],
                                          cfg->config_file_dir, NULL, NULL);
        if (!aiq_ctx) {
           LOGE("init aiq ctx %d for %s failed !", i, cfg->sns_ent_nm_array[i]);
           goto error;
        }
        // notify single cam work as multiple mode
        rk_aiq_uapi_sysctl_setMulCamConc(aiq_ctx, true);

        if (camgroup_ctx->_srcOverlapMap_s) {
            aiq_ctx->_hw_info.module_rotation =
                camgroup_ctx->_srcOverlapMap_s->srcOverlapPositon[i];

            // update module rotation info
            aiq_ctx->_analyzer->setHwInfos(aiq_ctx->_hw_info);
        }

        ret = _cam_group_bind(camgroup_ctx, aiq_ctx);
        if (ret) {
            LOGE("%s: bind sensor %s aiq ctx 0x%x failed !",
                 __func__, aiq_ctx->_sensor_entity_name, aiq_ctx);
            goto error;
        }
    }

    if (camgroup_iq_file.length())
        camgroup_ctx->_camgroup_calib = RkAiqCalibDbV2::createCalibDbCamgroup(camgroup_iq_file.c_str());

    ret = camgroup_ctx->cam_group_manager->setCamgroupCalib(camgroup_ctx->_camgroup_calib);
    if (ret) {
        LOGE("%s: set camgroup calib failed !", __func__);
        goto error;
    }
    ret = camgroup_ctx->cam_group_manager->init();
    if (ret) {
        LOGE("%s: init failed !", __func__);
        goto error;
    }

    LOGD("%s: create camgroup 0x%x success !", __func__, camgroup_ctx);

    EXIT_XCORE_FUNCTION();

    return camgroup_ctx;

error:
    LOGE("%s failed", __func__);
    if (camgroup_ctx)
        rk_aiq_uapi2_camgroup_destroy(camgroup_ctx);
#endif
    return NULL;
}

struct RK_PS_SrcOverlapMap*
rk_aiq_uapi2_camgroup_getOverlapMap(rk_aiq_camgroup_ctx_t* camgroup_ctx)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    if (camgroup_ctx->_srcOverlapMap_s)
        return camgroup_ctx->_srcOverlapMap_s;
    else
        return NULL;
#else
    return NULL;
#endif
}

XCamReturn
rk_aiq_uapi2_camgroup_getOverlapMap_from_file(const char* map_file, struct RK_PS_SrcOverlapMap** overlapMap)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    FILE *fp2 = fopen(map_file, "rb");

    if (fp2) {
        fread(*overlapMap, sizeof(RK_PS_SrcOverlapMap), 1, fp2);
        fclose(fp2);
        return XCAM_RETURN_NO_ERROR;
    } else {
        LOGE("get overlap data from %s error!", map_file);
        return XCAM_RETURN_ERROR_FAILED;
    }
#else
    return XCAM_RETURN_ERROR_FAILED;
#endif
}

rk_aiq_sys_ctx_t*
rk_aiq_uapi2_camgroup_getAiqCtxBySnsNm(rk_aiq_camgroup_ctx_t* camgroup_ctx, const char* sns_entity_name)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    RKAIQ_API_SMART_LOCK(camgroup_ctx);

    for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
        if (camgroup_ctx->cam_ctxs_array[i]) {
            if (strcmp(camgroup_ctx->cam_ctxs_array[i]->_sensor_entity_name, sns_entity_name) == 0) {
                LOGD("%s: get sensor %s aiq ctx 0x%x success !",
                     __func__, sns_entity_name, camgroup_ctx->cam_ctxs_array[i]);
                return camgroup_ctx->cam_ctxs_array[i];
            }
        }
    }

    LOGD("%s: get sensor %s aiq ctx failed !", __func__, sns_entity_name);

    EXIT_XCORE_FUNCTION();
#endif

    return NULL;

}

XCamReturn
rk_aiq_uapi2_camgroup_bind(rk_aiq_camgroup_ctx_t* camgroup_ctx, rk_aiq_sys_ctx_t** ctx, int num)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RKAIQ_API_SMART_LOCK(camgroup_ctx);

    if (camgroup_ctx->cam_ctxs_num + num > RK_AIQ_CAM_GROUP_MAX_CAMS) {
        LOGE("binded num %d + num %d > max %d !", camgroup_ctx->cam_ctxs_num, num, RK_AIQ_CAM_GROUP_MAX_CAMS);
        return XCAM_RETURN_ERROR_OUTOFRANGE;
    }

    for (int j = 0; j < num; j++) {
        // query bind status firstly
        bool need_bind = true;
        for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
            if (camgroup_ctx->cam_ctxs_array[i] == ctx[j]) {
                LOGI("already binded for ctx 0x%x", ctx[j]);
                need_bind = false;
                break;
            }
        }
        // find a empty slot
        if (need_bind) {
            for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
                if (camgroup_ctx->cam_ctxs_array[i] == NULL) {
                    ret = _cam_group_bind(camgroup_ctx, ctx[j]);
                    if (ret) {
                        LOGE("%s: bind sensor %s aiq ctx 0x%x failed !",
                             __func__, ctx[j]->_sensor_entity_name, ctx[j]);
                        break;
                    }
                }
            }
        }
    }

    LOGD("%s: bind sensor aiq ctxs success !", __func__);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi2_camgroup_unbind(rk_aiq_camgroup_ctx_t* camgroup_ctx, rk_aiq_sys_ctx_t** ctx, int num)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    RKAIQ_API_SMART_LOCK(camgroup_ctx);

    for (int j = 0; j < num; j++) {
        for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
            if (camgroup_ctx->cam_ctxs_array[i] == ctx[j]) {
                if (_cam_group_unbind(camgroup_ctx, ctx[j])) {
                    LOGE("%s: unbind sensor %s aiq ctx 0x%x failed !",
                         __func__, ctx[j]->_sensor_entity_name, ctx[j]);
                    break;
                }
            }
        }
    }

    LOGD("%s: unbind sensor aiq ctxs success !", __func__);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi2_camgroup_prepare(rk_aiq_camgroup_ctx_t* camgroup_ctx, rk_aiq_working_mode_t mode)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RKAIQ_API_SMART_LOCK(camgroup_ctx);

    for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
        rk_aiq_sys_ctx_t* aiq_ctx = camgroup_ctx->cam_ctxs_array[i];
        if (aiq_ctx) {
            ret = rk_aiq_uapi_sysctl_prepare(aiq_ctx, 0, 0, mode);
            if (ret) {
                LOGE("%s: prepare failed for aiq ctx 0x%x !", __func__, aiq_ctx);
                continue;
            }
        }
    }

    ret = camgroup_ctx->cam_group_manager->prepare();
    if (ret) {
        LOGE("%s: prepare failed !", __func__);
        return ret;
    }

    LOGD("%s: prepare camgroup success !", __func__);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi2_camgroup_start(rk_aiq_camgroup_ctx_t* camgroup_ctx)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RKAIQ_API_SMART_LOCK(camgroup_ctx);

    ret = camgroup_ctx->cam_group_manager->start();
    if (ret) {
        LOGE("%s: start failed !", __func__);
        return ret;
    }

    for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
        rk_aiq_sys_ctx_t* aiq_ctx = camgroup_ctx->cam_ctxs_array[i];
        if (aiq_ctx) {
            ret = rk_aiq_uapi_sysctl_start(aiq_ctx);
            if (ret) {
                LOGE("%s: start failed for aiq ctx 0x%x !", __func__, aiq_ctx);
                continue;
            }
        }
    }

    LOGD("%s: start camgroup success !", __func__);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi2_camgroup_stop(rk_aiq_camgroup_ctx_t* camgroup_ctx)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RKAIQ_API_SMART_LOCK(camgroup_ctx);

    ret = camgroup_ctx->cam_group_manager->stop();
    if (ret) {
        LOGE("%s: stop failed !", __func__);
        return ret;
    }

    for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
        rk_aiq_sys_ctx_t* aiq_ctx = camgroup_ctx->cam_ctxs_array[i];
        if (aiq_ctx) {
            ret = rk_aiq_uapi_sysctl_stop(aiq_ctx, false);
            if (ret) {
                LOGE("%s: stop failed for aiq ctx 0x%x !", __func__, aiq_ctx);
                continue;
            }
        }
    }

    LOGD("%s: stop camgroup success !", __func__);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;

}

XCamReturn
rk_aiq_uapi2_camgroup_destroy(rk_aiq_camgroup_ctx_t* camgroup_ctx)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    {
        RKAIQ_API_SMART_LOCK(camgroup_ctx);
        for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
            rk_aiq_sys_ctx_t* aiq_ctx = camgroup_ctx->cam_ctxs_array[i];
            if (aiq_ctx) {
                ret = _cam_group_unbind(camgroup_ctx, aiq_ctx);
                if (ret) {
                    LOGE("%s: unbind sensor %s aiq ctx 0x%x failed !",
                         __func__, aiq_ctx->_sensor_entity_name, aiq_ctx);
                    continue;
                }
                rk_aiq_uapi_sysctl_deinit(aiq_ctx);
            }
        }

        if (camgroup_ctx->cam_ctxs_num > 0) {
            LOGE("impossible case, some aiq ctx may not deinit !");
        }
        ret = camgroup_ctx->cam_group_manager->deInit();
        if (ret) {
            LOGE("%s: deinit failed !", __func__);
            return ret;
        }
        camgroup_ctx->cam_group_manager.release();
    }
    if (camgroup_ctx->_camgroup_calib) {
        RkAiqCalibDbV2::CamCalibDbCamgroupFree(camgroup_ctx->_camgroup_calib);
    }
    if (camgroup_ctx->_srcOverlapMap_s)
        delete camgroup_ctx->_srcOverlapMap_s;
    camgroup_ctx->_apiMutex.release();
    delete camgroup_ctx;

    LOGD("%s: destroy camgroup success !", __func__);

    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi2_camgroup_getCamInfos(rk_aiq_camgroup_ctx_t* camgroup_ctx, rk_aiq_camgroup_camInfos_t* camInfos)
{
#ifdef RKAIQ_ENABLE_CAMGROUP
    ENTER_XCORE_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    {
        RKAIQ_API_SMART_LOCK(camgroup_ctx);
        if (!camInfos) {
            LOGE("null params !");
            return XCAM_RETURN_ERROR_PARAM;
        }

        camInfos->valid_sns_num = camgroup_ctx->cam_ctxs_num;

        for (int i = 0, j = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
            rk_aiq_sys_ctx_t* aiq_ctx = camgroup_ctx->cam_ctxs_array[i];

            if (aiq_ctx) {
                camInfos->sns_ent_nm[j] = aiq_ctx->_sensor_entity_name;
                camInfos->sns_camPhyId[j] = aiq_ctx->_camPhyId;
                j++;
            }
        }
    }
    EXIT_XCORE_FUNCTION();
#endif

    return XCAM_RETURN_NO_ERROR;
}