/*
 * rk_aiq_algo_aldch_itf.c
 *
 *  Copyright (c) 2019 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_algo_types_int.h"
#include "aldch/rk_aiq_algo_aldch_itf.h"
#include "aldch/rk_aiq_types_aldch_algo_prvt.h"
#include "xcam_log.h"

#define LDCH_CUSTOM_MESH "ldch_custom_mesh.bin"

RKAIQ_BEGIN_DECLARE

static XCamReturn release_ldch_buf(LDCHContext_t* ldchCtx);
static XCamReturn alloc_ldch_buf(LDCHContext_t* ldchCtx)
{
    release_ldch_buf(ldchCtx);
    rk_aiq_share_mem_config_t share_mem_config;
    share_mem_config.alloc_param.width =  ldchCtx->dst_width;
    share_mem_config.alloc_param.height = ldchCtx->dst_height;
    share_mem_config.mem_type = MEM_TYPE_LDCH;
    ldchCtx->share_mem_ops->alloc_mem(ldchCtx->share_mem_ops,
                                      &share_mem_config,
                                      &ldchCtx->share_mem_ctx);
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn release_ldch_buf(LDCHContext_t* ldchCtx)
{
    if (ldchCtx->share_mem_ctx)
        ldchCtx->share_mem_ops->release_mem(ldchCtx->share_mem_ctx);

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn get_ldch_buf(LDCHContext_t* ldchCtx)
{
    ldchCtx->ldch_mem_info = (rk_aiq_ldch_share_mem_info_t *)
            ldchCtx->share_mem_ops->get_free_item(ldchCtx->share_mem_ctx);
    if (ldchCtx->ldch_mem_info == NULL) {
        LOGE_ALDCH( "%s(%d): no free ldch buf", __FUNCTION__, __LINE__);
        return XCAM_RETURN_ERROR_MEM;
    } else {
        LOGD_ALDCH( "get ldch buf fd=%d", ldchCtx->ldch_mem_info->fd);
        ldchCtx->lut_mapxy = (unsigned short*)ldchCtx->ldch_mem_info->addr;
    }

    return XCAM_RETURN_NO_ERROR;
}

static bool
read_mesh_from_file(LDCHContext_t* ldchCtx, const char* fileName)
{
    FILE* ofp;
    ofp = fopen(fileName, "rb");
    if (ofp != NULL) {
        unsigned short hpic, vpic, hsize, vsize, hstep, vstep = 0;

        fread(&hpic, sizeof(unsigned short), 1, ofp);
        fread(&vpic, sizeof(unsigned short), 1, ofp);
        fread(&hsize, sizeof(unsigned short), 1, ofp);
        fread(&vsize, sizeof(unsigned short), 1, ofp);
        fread(&hstep, sizeof(unsigned short), 1, ofp);
        fread(&vstep, sizeof(unsigned short), 1, ofp);
        //fseek(ofp, 0, SEEK_SET);
        LOGW_ALDCH("lut info: [%d-%d-%d-%d-%d-%d]", hpic, vpic, hsize, vsize, hstep, vstep);

        ldchCtx->lut_h_size = hsize;
        ldchCtx->lut_v_size = vsize;
        ldchCtx->lut_mapxy_size = ldchCtx->lut_h_size * ldchCtx->lut_v_size * sizeof(unsigned short);
        alloc_ldch_buf(ldchCtx);
        get_ldch_buf(ldchCtx);
        ldchCtx->lut_h_size = hsize / 2; //word unit

        unsigned int num = fread(ldchCtx->lut_mapxy, 1, ldchCtx->lut_mapxy_size, ofp);
        fclose(ofp);

        if (num != ldchCtx->lut_mapxy_size) {
            ldchCtx->ldch_en = 0;
            LOGE_ALDCH("mismatched lut calib file");
            return false;
        }
        LOGW_ALDCH("check calib file, size: %d, num: %d", ldchCtx->lut_mapxy_size, num);
    } else {
        LOGE_ALDCH("lut calib file %s not exist", fileName);
        return false;
    }

    return true;
}

#if GENMESH_ONLINE
static XCamReturn aiqGenLdchMeshInit(LDCHContext_t* ldchCtx)
{
    if (ldchCtx->genLdchMeshInit) {
        LOGW_ALDCH("genLDCHMesh has been initialized!!\n");
        get_ldch_buf(ldchCtx);
        return XCAM_RETURN_NO_ERROR;
    }

    ldchCtx->ldchParams.isLdchOld = 1;
    ldchCtx->ldchParams.saveMeshX = false;
    if (ldchCtx->ldchParams.saveMeshX)
        sprintf(ldchCtx->ldchParams.meshPath, "/tmp/");
	genLdchMeshInit(ldchCtx->src_width, ldchCtx->src_height,
                    ldchCtx->dst_width, ldchCtx->dst_height,
                    ldchCtx->ldchParams, ldchCtx->camCoeff);

    ldchCtx->lut_h_size = (ldchCtx->ldchParams.meshSizeW + 1) / 2; //word unit
    ldchCtx->lut_v_size = ldchCtx->ldchParams.meshSizeH;
    ldchCtx->lut_mapxy_size = ldchCtx->ldchParams.meshSize * sizeof(unsigned short);
    LOGI_ALDCH("ldch en %d, h/v size(%dx%d), mapxy size(%d), correct_level: %d",
               ldchCtx->ldch_en,
               ldchCtx->lut_h_size,
               ldchCtx->lut_v_size,
               ldchCtx->lut_mapxy_size ,
               ldchCtx->correct_level);
    alloc_ldch_buf(ldchCtx);
    get_ldch_buf(ldchCtx);
    ldchCtx->genLdchMeshInit = true;

    return XCAM_RETURN_NO_ERROR;
}

static bool aiqGenMesh(LDCHContext_t* ldchCtx)
{
    bool success = false;

    if (ldchCtx->correct_level == 0) {
        char filename[512];
        sprintf(filename, "%s/%s",
                ldchCtx->resource_path,
                LDCH_CUSTOM_MESH);
        success = read_mesh_from_file(ldchCtx, filename);
        if (success)
            LOGW_ALDCH("read mesh from %s", filename);
    }

    if (!success)
        success = genLDCMeshNLevel(ldchCtx->ldchParams, ldchCtx->camCoeff,
                                   ldchCtx->correct_level, ldchCtx->lut_mapxy);

    return success;
}
#endif

static XCamReturn
updateCalibConfig(RkAiqAlgoCom* params)
{
    LDCHHandle_t hLDCH = (LDCHHandle_t)params->ctx->hLDCH;
    LDCHContext_t* ldchCtx = (LDCHContext_t*)hLDCH;
    RkAiqAlgoConfigAldchInt* rkaiqAldchConfig = (RkAiqAlgoConfigAldchInt*)params;

    CalibDbV2_LDCH_t* calib_ldch_db =
        (CalibDbV2_LDCH_t*)(CALIBDBV2_GET_MODULE_PTR(rkaiqAldchConfig->rk_com.u.prepare.calibv2, aldch));
    CalibDbV2_Ldch_Param_t* calib_ldch = &calib_ldch_db->param;

    ldchCtx->ldch_en = calib_ldch->ldch_en;
    memcpy(ldchCtx->meshfile, calib_ldch->meshfile, sizeof(ldchCtx->meshfile));

    ldchCtx->camCoeff.cx = calib_ldch->light_center[0];
    ldchCtx->camCoeff.cy = calib_ldch->light_center[1];
    ldchCtx->camCoeff.a0 = calib_ldch->coefficient[0];
    ldchCtx->camCoeff.a2 = calib_ldch->coefficient[1];
    ldchCtx->camCoeff.a3 = calib_ldch->coefficient[2];
    ldchCtx->camCoeff.a4 = calib_ldch->coefficient[3];

    ldchCtx->correct_level = calib_ldch->correct_level;
    ldchCtx->correct_level_max = calib_ldch->correct_level_max;

    if (ldchCtx->correct_level_max != 255)
        ldchCtx->correct_level = MAP_TO_255LEVEL(ldchCtx->correct_level, ldchCtx->correct_level_max);

    aiqGenLdchMeshInit(hLDCH);
    bool success = genLDCMeshNLevel(hLDCH->ldchParams, hLDCH->camCoeff,
            ldchCtx->correct_level, hLDCH->lut_mapxy);
    if (!success) {
        LOGE_ALDCH("lut is not exist");
        return XCAM_RETURN_ERROR_PARAM;
    }
    ldchCtx->isAttribUpdated = true;

    LOGI_ALDCH("en(%d), level(%d-%d), coeff(%f, %f, %f, %f, %f, %f)",
            calib_ldch->ldch_en,
            calib_ldch->correct_level,
            calib_ldch->correct_level_max,
            calib_ldch->light_center[0],
            calib_ldch->light_center[1],
            calib_ldch->coefficient[0],
            calib_ldch->coefficient[1],
            calib_ldch->coefficient[2],
            calib_ldch->coefficient[3]);

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
{
    XCamReturn result = XCAM_RETURN_NO_ERROR;

    LOG1_ALDCH("%s: (enter)\n", __FUNCTION__ );
    RkAiqAlgoContext *ctx = new RkAiqAlgoContext();
    if (ctx == NULL) {
        LOGE_ALDCH( "%s: create aldch context fail!\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_MEM;
    }
    ctx->hLDCH = new LDCHContext_t;
    if (ctx->hLDCH == NULL) {
        LOGE_ALDCH( "%s: create aldch handle fail!\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_MEM;
    }
    /* setup config */
    memset((void *)(ctx->hLDCH), 0, sizeof(LDCHContext_t) );

    /* return handle */
    *context = ctx;

#if GENMESH_ONLINE
    ctx->hLDCH->isAttribUpdated = false;
    ctx->hLDCH->aldchReadMeshThread = new RKAiqAldchThread(ctx->hLDCH);
    /* ctx->hLDCH->aldchReadMeshThread->triger_start(); */
    /* ctx->hLDCH->aldchReadMeshThread->start(); */
#endif

    const AlgoCtxInstanceCfgInt* cfg_int = (const AlgoCtxInstanceCfgInt*)cfg;
    LDCHHandle_t ldchCtx = ctx->hLDCH;
    CalibDbV2_LDCH_t* calib_ldch_db =
            (CalibDbV2_LDCH_t*)(CALIBDBV2_GET_MODULE_PTR(cfg_int->calibv2, aldch));
    CalibDbV2_Ldch_Param_t* calib_ldch = &calib_ldch_db->param;

    ldchCtx->ldch_en = calib_ldch->ldch_en;
    memcpy(ldchCtx->meshfile, calib_ldch->meshfile, sizeof(ldchCtx->meshfile));
#if GENMESH_ONLINE
    ldchCtx->camCoeff.cx = calib_ldch->light_center[0];
    ldchCtx->camCoeff.cy = calib_ldch->light_center[1];
    ldchCtx->camCoeff.a0 = calib_ldch->coefficient[0];
    ldchCtx->camCoeff.a2 = calib_ldch->coefficient[1];
    ldchCtx->camCoeff.a3 = calib_ldch->coefficient[2];
    ldchCtx->camCoeff.a4 = calib_ldch->coefficient[3];
    LOGI_ALDCH("(%s) len light center(%.16f, %.16f)\n",
            __FUNCTION__,
            ldchCtx->camCoeff.cx, ldchCtx->camCoeff.cy);
    LOGI_ALDCH("(%s) len coefficient(%.16f, %.16f, %.16f, %.16f)\n",
            __FUNCTION__,
            ldchCtx->camCoeff.a0, ldchCtx->camCoeff.a2,
            ldchCtx->camCoeff.a3, ldchCtx->camCoeff.a4);
#endif
    ldchCtx->correct_level = calib_ldch->correct_level;
    ldchCtx->correct_level_max = calib_ldch->correct_level_max;

    if (ldchCtx->correct_level_max != 255)
        ldchCtx->correct_level = MAP_TO_255LEVEL(ldchCtx->correct_level, ldchCtx->correct_level_max);

    LOGI_ALDCH("ldch en %d, meshfile: %s, correct_level-max: %d-%d from xml file",
               calib_ldch->ldch_en,
               ldchCtx->meshfile,
               ldchCtx->correct_level,
               ldchCtx->correct_level_max);

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
destroy_context(RkAiqAlgoContext *context)
{
    LDCHHandle_t hLDCH = (LDCHHandle_t)context->hLDCH;
    LDCHContext_t* ldchCtx = (LDCHContext_t*)hLDCH;

#if GENMESH_ONLINE
    ldchCtx->aldchReadMeshThread->triger_stop();
    ldchCtx->aldchReadMeshThread->stop();
#endif

#if GENMESH_ONLINE
	genLdchMeshDeInit(ldchCtx->ldchParams);
#endif
    release_ldch_buf(ldchCtx);
    delete context->hLDCH;
    context->hLDCH = NULL;
    delete context;
    context = NULL;
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
prepare(RkAiqAlgoCom* params)
{
    LDCHHandle_t hLDCH = (LDCHHandle_t)params->ctx->hLDCH;
    LDCHContext_t* ldchCtx = (LDCHContext_t*)hLDCH;
    RkAiqAlgoConfigAldchInt* rkaiqAldchConfig = (RkAiqAlgoConfigAldchInt*)params;

    ldchCtx->src_width = params->u.prepare.sns_op_width;
    ldchCtx->src_height = params->u.prepare.sns_op_height;
    ldchCtx->dst_width = params->u.prepare.sns_op_width;
    ldchCtx->dst_height = params->u.prepare.sns_op_height;
    ldchCtx->resource_path = rkaiqAldchConfig->resource_path;
    ldchCtx->share_mem_ops = rkaiqAldchConfig->mem_ops_ptr;

    bool config_calib = !!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB);
    if (config_calib && ldchCtx->genLdchMeshInit) {
        updateCalibConfig(params);
        return XCAM_RETURN_NO_ERROR;
    }

#if GENMESH_ONLINE
    // process the new attrib set before prepare
    hLDCH->aldchReadMeshThread->triger_stop();
    hLDCH->aldchReadMeshThread->stop();
    if (!hLDCH->aldchReadMeshThread->is_empty()) {
        hLDCH->aldchReadMeshThread->clear_attr();
        ldchCtx->isAttribUpdated = true;
    }

    if (ldchCtx->isAttribUpdated) {
        ldchCtx->ldch_en = ldchCtx->user_config.en;
        ldchCtx->correct_level = ldchCtx->user_config.correct_level;
        ldchCtx->isAttribUpdated = false;
    } else {
        ldchCtx->user_config.en = ldchCtx->ldch_en;
        ldchCtx->user_config.correct_level = ldchCtx->correct_level;
    }

    hLDCH->aldchReadMeshThread->triger_start();
    hLDCH->aldchReadMeshThread->start();
    if (!ldchCtx->ldch_en)
        return XCAM_RETURN_NO_ERROR;

    if (aiqGenLdchMeshInit(ldchCtx) == XCAM_RETURN_NO_ERROR) {
        bool success = aiqGenMesh(hLDCH);
        if (!success) {
            LOGW_ALDCH("lut is not exist");
            ldchCtx->ldch_en = 0;
        }
    }
#else
    if (!ldchCtx->ldch_en)
        return XCAM_RETURN_NO_ERROR;

    char filename[512];
    sprintf(filename, "%s/%s/mesh_level%d.bin",
            ldchCtx->resource_path,
            ldchCtx->meshfile,
            ldchCtx->correct_level);
    bool ret = read_mesh_from_file(ldchCtx, filename);
    if (!ret)
        ldchCtx->ldch_en = 0;
#endif

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    LDCHHandle_t hLDCH = (LDCHHandle_t)inparams->ctx->hLDCH;
    LDCHContext_t* ldchCtx = (LDCHContext_t*)hLDCH;
    RkAiqAlgoProcResAldchInt* ldchPreOut = (RkAiqAlgoProcResAldchInt*)outparams;

    if (inparams->u.proc.init) {
        ldchPreOut->ldch_result.update = 1;
    } else {
        if (ldchCtx->isAttribUpdated) {
            ldchCtx->isAttribUpdated = false;
            ldchPreOut->ldch_result.update = 1;
        } else {
            ldchPreOut->ldch_result.update = 0;
        }

        LOGV_ALDCH("(%s) en(%d), level(%d), user en(%d), level(%d), result update(%d)\n",
                __FUNCTION__,
                ldchCtx->ldch_en,
                ldchCtx->correct_level,
                ldchCtx->user_config.en,
                ldchCtx->user_config.correct_level,
                ldchPreOut->ldch_result.update);
    }

    if (ldchPreOut->ldch_result.update) {
        ldchPreOut->ldch_result.sw_ldch_en = ldchCtx->ldch_en;
        ldchPreOut->ldch_result.lut_h_size = ldchCtx->lut_h_size;
        ldchPreOut->ldch_result.lut_v_size = ldchCtx->lut_v_size;
        ldchPreOut->ldch_result.lut_map_size = ldchCtx->lut_mapxy_size;
        if (ldchCtx->lut_mapxy != NULL && ldchCtx->ldch_en) {
            if (ldchCtx->ldch_mem_info == NULL) {
                LOGE_ALDCH("%s: no available ldch buf!", __FUNCTION__);
                ldchPreOut->ldch_result.update = 0;
                return XCAM_RETURN_NO_ERROR;
            }
            ldchPreOut->ldch_result.lut_mapxy_buf_fd = ldchCtx->ldch_mem_info->fd;
            ldchCtx->ldch_mem_info->state[0] = 1; //mark that this buf is using.
        }
    }

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn
post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    return XCAM_RETURN_NO_ERROR;
}

RkAiqAlgoDescription g_RkIspAlgoDescAldch = {
    .common = {
        .version = RKISP_ALGO_ALDCH_VERSION,
        .vendor  = RKISP_ALGO_ALDCH_VENDOR,
        .description = RKISP_ALGO_ALDCH_DESCRIPTION,
        .type    = RK_AIQ_ALGO_TYPE_ALDCH,
        .id      = 0,
        .create_context  = create_context,
        .destroy_context = destroy_context,
    },
    .prepare = prepare,
    .pre_process = pre_process,
    .processing = processing,
    .post_process = post_process,
};

RKAIQ_END_DECLARE


bool RKAiqAldchThread::loop()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    ENTER_ANALYZER_FUNCTION();

    const static int32_t timeout = -1;
    SmartPtr<rk_aiq_ldch_cfg_t> attrib = mAttrQueue.pop (timeout);

    if (!attrib.ptr()) {
        LOGW_ANALYZER("RKAiqAldchThread got empty attrib, stop thread");
        return false;
    }
#if GENMESH_ONLINE
    if (attrib->en && (hLDCH->ldch_en != attrib->en || \
	    attrib->correct_level != hLDCH->correct_level)) {
        aiqGenLdchMeshInit(hLDCH);
        bool success = aiqGenMesh(hLDCH);
        if (!success)
            LOGW_ALDCH("lut is not exist");
    }
    hLDCH->ldch_en = hLDCH->user_config.en;
    hLDCH->correct_level = hLDCH->user_config.correct_level;
#endif
    if (ret == XCAM_RETURN_NO_ERROR) {
        hLDCH->isAttribUpdated = true;
        LOGV_ANALYZER("ldch en(%d), level(%d)\n", hLDCH->ldch_en, hLDCH->correct_level);
        return true;
    }

    LOGE_ANALYZER("RKAiqAldchThread failed to read mesh table!");

    EXIT_ANALYZER_FUNCTION();

    return false;
}