/*
 * RkAiqCamgroupHandle.h
 *
 *  Copyright (c) 2019-2021 Rockchip Eletronics 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.
 *
 */

#include "RkAiqCamgroupHandle.h"
#include "RkAiqCamGroupManager.h"
#include "RkAiqManager.h"
#include "aiq_core/RkAiqCore.h"

namespace RkCam {

RkAiqCamgroupHandle::RkAiqCamgroupHandle(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg)
    : mDes(des), mGroupMg(camGroupMg), mEnable(true) {
    mDes->create_context(&mAlgoCtx, (const _AlgoCtxInstanceCfg*)(&mGroupMg->mGroupAlgoCtxCfg));
    mConfig       = NULL;
    mProcInParam  = NULL;
    mProcOutParam = NULL;
    updateAtt = false;
    mNextHdl = NULL;
    mParentHdl = NULL;
    mAiqCore = NULL;
}

RkAiqCamgroupHandle::~RkAiqCamgroupHandle() {
    if (mDes) mDes->destroy_context(mAlgoCtx);
}

void RkAiqCamgroupHandle::init() {
    ENTER_ANALYZER_FUNCTION();
    deInit();
    mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoCamGroupPrepare());
    mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoCamGroupProcIn());
    mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoCamGroupProcOut());

    EXIT_ANALYZER_FUNCTION();
}

XCamReturn RkAiqCamgroupHandle::prepare(RkAiqCore* aiqCore) {
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    mAiqCore = aiqCore;

    if (mConfig == NULL) init();

    // assume all single cam runs same algos

    RkAiqAlgoCamGroupPrepare* prepareCfg = (RkAiqAlgoCamGroupPrepare*)mConfig ;

    RkAiqAlgoComCamGroup* gcom = &prepareCfg->gcom;
    RkAiqAlgoCom *com = &gcom->com;
    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    prepareCfg->camIdArrayLen = mGroupMg->mBindAiqsMap.size();

    LOGD_CAMGROUP("camgroup: prepare: relay init params ...");
    int i = 0;
    for (auto it : mGroupMg->mBindAiqsMap) {
        prepareCfg->camIdArray[i++] = it.first;
    }

    prepareCfg->aec.LinePeriodsPerField =
        (float)sharedCom->snsDes.frame_length_lines;
    prepareCfg->aec.PixelClockFreqMHZ =
        (float)sharedCom->snsDes.pixel_clock_freq_mhz;
    prepareCfg->aec.PixelPeriodsPerLine =
        (float)sharedCom->snsDes.line_length_pck;
    prepareCfg->s_calibv2 = mGroupMg->mGroupAlgoCtxCfg.s_calibv2;

    prepareCfg->pCamgroupCalib = mGroupMg->mCamgroupCalib;
    prepareCfg->aec.nr_switch = sharedCom->snsDes.nr_switch;

    LOGD_CAMGROUP("camgroup: prepare: prepare algos ...");

    com->ctx                     = mAlgoCtx;
    com->frame_id                = 0;
    com->u.prepare.working_mode  = sharedCom->working_mode;
    com->u.prepare.sns_op_width  = sharedCom->snsDes.isp_acq_width;
    com->u.prepare.sns_op_height = sharedCom->snsDes.isp_acq_height;
    com->u.prepare.conf_type     = sharedCom->conf_type;
    com->u.prepare.calibv2 =
        const_cast<CamCalibDbV2Context_t*>(prepareCfg->s_calibv2);

    ret = ((RkAiqAlgoDescription*)mDes)->prepare(com);
    if (ret) {
        LOGE("algo %d prepare failed !", mDes->type);
        return ret;
    }

    EXIT_ANALYZER_FUNCTION();

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn RkAiqCamgroupHandle::processing(rk_aiq_singlecam_3a_result_t** params_res_array) {
    ENTER_ANALYZER_FUNCTION();

    XCamReturn ret          = XCAM_RETURN_NO_ERROR;

    RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;

    RkAiqAlgoCamGroupProcIn* procIn =
        (RkAiqAlgoCamGroupProcIn*)mProcInParam;
    RkAiqAlgoCamGroupProcOut* procOut =
        (RkAiqAlgoCamGroupProcOut*)mProcOutParam;

    memset(procIn, 0, sizeof(RkAiqAlgoCamGroupProcIn));
    memset(procOut, 0, sizeof(RkAiqAlgoCamGroupProcOut));

    RkAiqAlgoComCamGroup* gcom = &procIn->gcom;
    RkAiqAlgoCom *com = &gcom->com;

    procIn->arraySize = mGroupMg->mBindAiqsMap.size();
    procOut->arraySize = mGroupMg->mBindAiqsMap.size();

    procIn->camgroupParmasArray = params_res_array;
    procOut->camgroupParmasArray = params_res_array;
    procIn->_gray_mode = sharedCom->gray_mode;
    procIn->working_mode = sharedCom->working_mode;
    procIn->_is_bw_sensor = sharedCom->is_bw_sensor;

    com->ctx         = mAlgoCtx;
    com->frame_id    = params_res_array[0]->_frameId;
    // TODO: remove init info ? algo can maintain the state itself
    com->u.proc.init = mGroupMg->mInit;
    ret = ((RkAiqAlgoDescription*)mDes)->processing((const RkAiqAlgoCom*)procIn,
            (RkAiqAlgoResCom*)procOut);
    if (ret) {
        LOGW_CAMGROUP("group algo %d proc error !", mDes->type);
        return ret;
    }

    EXIT_ANALYZER_FUNCTION();

    return XCAM_RETURN_NO_ERROR;
}

void RkAiqCamgroupHandle::deInit() {
    ENTER_ANALYZER_FUNCTION();

#define RKAIQ_DELLET(a) \
    if (a) {            \
        delete a;       \
        a = NULL;       \
    }

    RKAIQ_DELLET(mConfig);
    RKAIQ_DELLET(mProcInParam);
    RKAIQ_DELLET(mProcOutParam);

    EXIT_ANALYZER_FUNCTION();
}

void
RkAiqCamgroupHandle::waitSignal(rk_aiq_uapi_mode_sync_e sync_mode)
{
    if (mGroupMg->isRunningState()) {
        if (sync_mode == RK_AIQ_UAPI_MODE_ASYNC)
            return;

        mUpdateCond.timedwait(mCfgMutex, 100000);
    } else {
        updateConfig(false);
    }
}

void
RkAiqCamgroupHandle::sendSignal(rk_aiq_uapi_mode_sync_e sync_mode)
{
    if (sync_mode == RK_AIQ_UAPI_MODE_ASYNC)
        return;

    if (mGroupMg->isRunningState())
        mUpdateCond.signal();
}

};  // namespace RkCam