/*
 * rk_aiq_algo_ae_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 "atmo/rk_aiq_algo_atmo_itf.h"
#include "xcam_log.h"
#include "atmo/rk_aiq_atmo_algo.h"
#include "atmo/rk_aiq_types_atmo_algo_prvt.h"


RKAIQ_BEGIN_DECLARE

static XCamReturn AtmoCreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
{

    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    RESULT ret = ATMO_RET_SUCCESS;
    RkAiqAlgoContext *ctx = new RkAiqAlgoContext();
    AlgoCtxInstanceCfgInt* instanc_int = (AlgoCtxInstanceCfgInt*)cfg;
    if (ctx == NULL) {
        LOGE_ATMO( "%s: create atmo context fail!\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_MEM;
    }
    memset(&ctx->AtmoInstConfig, 0x00, sizeof(AtmoInstanceConfig_t));
    ret = AtmoInit(&ctx->AtmoInstConfig, instanc_int->calibv2);

    if (ret != ATMO_RET_SUCCESS) {
        LOGE_ATMO("%s ATMO Init failed: %d", __FUNCTION__, ret);
        return(XCAM_RETURN_ERROR_FAILED);
    }

    *context = ctx;

    LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
    return(XCAM_RETURN_NO_ERROR);
}

static XCamReturn AtmoDestroyCtx(RkAiqAlgoContext *context)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    RESULT ret = ATMO_RET_SUCCESS;

    if(context != NULL) {
        AtmoHandle_t pAtmoCtx = (AtmoHandle_t)context->AtmoInstConfig.hAtmo;
        ret = AtmoRelease(pAtmoCtx);
        if (ret != ATMO_RET_SUCCESS) {
            LOGE_ATMO("%s Atmo Release failed: %d", __FUNCTION__, ret);
            return(XCAM_RETURN_ERROR_FAILED);
        }
        delete context;
        context = NULL;
    }

    LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
    return(XCAM_RETURN_NO_ERROR);
}

static XCamReturn AtmoPrepare(RkAiqAlgoCom* params)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    RESULT ret = ATMO_RET_SUCCESS;

    AtmoHandle_t pAtmoCtx = params->ctx->AtmoInstConfig.hAtmo;
    RkAiqAlgoConfigAtmoInt* AtmoCfgParam = (RkAiqAlgoConfigAtmoInt*)params; //come from params in html
    const CamCalibDbContext_t* pCalibDb = AtmoCfgParam->rk_com.u.prepare.calib;
    const CamCalibDbV2Context_t* pCalibDbv2 = AtmoCfgParam->rk_com.u.prepare.calibv2;
    pAtmoCtx->width = AtmoCfgParam->rawWidth;
    pAtmoCtx->height = AtmoCfgParam->rawHeight;

    if (AtmoCfgParam->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR2)
        pAtmoCtx->FrameNumber = 1;
    else if (AtmoCfgParam->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3 &&
             AtmoCfgParam->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2)
        pAtmoCtx->FrameNumber = 2;
    else
        pAtmoCtx->FrameNumber = 3;

    CalibDbV2_tmo_t* calibv2_atmo_calib =
        (CalibDbV2_tmo_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbv2, atmo_calib));

    if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
        LOGD_ATMO("%s: Ahdr Reload Para!\n", __FUNCTION__);
        memcpy(&pAtmoCtx->pCalibDB, calibv2_atmo_calib, sizeof(CalibDbV2_tmo_t));//load iq paras
    }

    if(/* !params->u.prepare.reconfig*/true) {
        AtmoStop(pAtmoCtx); // stop firstly for re-preapre
        ret = AtmoStart(pAtmoCtx);
        if (ret != ATMO_RET_SUCCESS) {
            LOGE_ATMO("%s Atmo Start failed: %d", __FUNCTION__, ret);
            return(XCAM_RETURN_ERROR_FAILED);
        }
    }

    //get aec delay frame
    CalibDb_Aec_ParaV2_t* aec =
        (CalibDb_Aec_ParaV2_t*)CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbv2, ae_calib);
    pAtmoCtx->CurrAeResult.AecDelayframe = MAX(aec->CommCtrl.AecDelayFrmNum.BlackDelay,
                                           aec->CommCtrl.AecDelayFrmNum.WhiteDelay);

    LOGD_ATMO("%s:AecDelayframe:%d\n", __FUNCTION__, pAtmoCtx->CurrAeResult.AecDelayframe);

    LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
    return(XCAM_RETURN_NO_ERROR);
}

static XCamReturn AtmoPreProcess(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    RESULT ret = ATMO_RET_SUCCESS;

    AtmoHandle_t pAtmoCtx = inparams->ctx->AtmoInstConfig.hAtmo;
    RkAiqAlgoConfigAtmoInt* AtmoCfgParam = (RkAiqAlgoConfigAtmoInt*)inparams;

    if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_TOOL) {
        newMalloc(&pAtmoCtx->AtmoConfig, &pAtmoCtx->tmoAttr.stTool);
        AtmoUpdateConfig(pAtmoCtx, &pAtmoCtx->tmoAttr.stTool);
    }
    else {
        newMalloc(&pAtmoCtx->AtmoConfig, &pAtmoCtx->pCalibDB);
        AtmoUpdateConfig(pAtmoCtx, &pAtmoCtx->pCalibDB);
    }

    LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
    return(XCAM_RETURN_NO_ERROR);
}

static XCamReturn AtmoProcess(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    RESULT ret = ATMO_RET_SUCCESS;

    AtmoHandle_t pAtmoCtx = (AtmoHandle_t)inparams->ctx->AtmoInstConfig.hAtmo;
    RkAiqAlgoProcAtmoInt* AtmoParams = (RkAiqAlgoProcAtmoInt*)inparams;
    RkAiqAlgoProcResAtmoInt* AtmoProcResParams = (RkAiqAlgoProcResAtmoInt*)outparams;
    AtmoGetStats(pAtmoCtx, &AtmoParams->ispAtmoStats);

    RkAiqAlgoProcResAeInt* ae_proc_res_int =
        (RkAiqAlgoProcResAeInt*)(AtmoParams->rk_com.u.proc.proc_res_comb->ae_proc_res);

    if (ae_proc_res_int)
        AtmoGetSensorInfo(pAtmoCtx, ae_proc_res_int->ae_proc_res_rk);
    else {
        AecProcResult_t AeProcResult;
        memset(&AeProcResult, 0x0, sizeof(AecProcResult_t));
        LOGW_ATMO("%s: Ae Proc result is null!!!\n", __FUNCTION__);
        AtmoGetSensorInfo(pAtmoCtx, AeProcResult);
    }

    RkAiqAlgoPreResAeInt* ae_pre_res_int =
        (RkAiqAlgoPreResAeInt*)(AtmoParams->rk_com.u.proc.pre_res_comb->ae_pre_res);
    RkAiqAlgoPreResAfInt* af_pre_res_int =
        (RkAiqAlgoPreResAfInt*)(AtmoParams->rk_com.u.proc.pre_res_comb->af_pre_res);
    if (ae_pre_res_int && af_pre_res_int)
        AtmoProcessing(pAtmoCtx,
                       ae_pre_res_int->ae_pre_res_rk,
                       af_pre_res_int->af_pre_result);
    else if (ae_pre_res_int) {
        af_preprocess_result_t AfPreResult;
        memset(&AfPreResult, 0x0, sizeof(af_preprocess_result_t));
        LOGW_ATMO("%s: af Pre result is null!!!\n", __FUNCTION__);
        AtmoProcessing(pAtmoCtx,
                       ae_pre_res_int->ae_pre_res_rk,
                       AfPreResult);
    }
    else {
        AecPreResult_t AecHdrPreResult;
        af_preprocess_result_t AfPreResult;
        memset(&AfPreResult, 0x0, sizeof(af_preprocess_result_t));
        memset(&AecHdrPreResult, 0x0, sizeof(AecPreResult_t));
        LOGW_ATMO("%s: ae/af Pre result is null!!!\n", __FUNCTION__);
        AtmoProcessing(pAtmoCtx,
                       AecHdrPreResult,
                       AfPreResult);
    }

    pAtmoCtx->ProcRes.LongFrameMode = pAtmoCtx->SensorInfo.LongFrmMode;
    AtmoProcResParams->AtmoProcRes.LongFrameMode = pAtmoCtx->ProcRes.LongFrameMode;
    AtmoProcResParams->AtmoProcRes.isHdrGlobalTmo = pAtmoCtx->ProcRes.isHdrGlobalTmo;
    AtmoProcResParams->AtmoProcRes.bTmoEn = pAtmoCtx->ProcRes.bTmoEn;
    AtmoProcResParams->AtmoProcRes.isLinearTmo = pAtmoCtx->ProcRes.isLinearTmo;
    memcpy(&AtmoProcResParams->AtmoProcRes.Res, &pAtmoCtx->ProcRes.Res, sizeof(TmoProcRes_t));
    memcpy(&AtmoProcResParams->AtmoProcRes.TmoFlicker, &pAtmoCtx->ProcRes.TmoFlicker, sizeof(TmoFlickerPara_t));

    LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
    return(XCAM_RETURN_NO_ERROR);
}

static XCamReturn AtmoPostProcess(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    RESULT ret = ATMO_RET_SUCCESS;

    //TODO

    LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
    return(XCAM_RETURN_NO_ERROR);
}

RkAiqAlgoDescription g_RkIspAlgoDescAtmo = {
    .common = {
        .version = RKISP_ALGO_ATMO_VERSION,
        .vendor  = RKISP_ALGO_ATMO_VENDOR,
        .description = RKISP_ALGO_ATMO_DESCRIPTION,
        .type    = RK_AIQ_ALGO_TYPE_ATMO,
        .id      = 0,
        .create_context  = AtmoCreateCtx,
        .destroy_context = AtmoDestroyCtx,
    },
    .prepare = AtmoPrepare,
    .pre_process = AtmoPreProcess,
    .processing = AtmoProcess,
    .post_process = AtmoPostProcess,
};

RKAIQ_END_DECLARE