/*
 * 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 "RkAiqAnalyzeGroupManager.h"

#include <algorithm>
#include <functional>
#include <sstream>

#include "smart_buffer_priv.h"

#define ANALYZER_SUBM (0x1)

namespace RkCam {

RkAiqAnalyzerGroup::RkAiqAnalyzerGroup(RkAiqCore* aiqCore, enum rk_aiq_core_analyze_type_e type,
                                       const uint64_t flag, const RkAiqGrpConditions_t* grpConds,
                                       const bool singleThrd)
    : mAiqCore(aiqCore), mGroupType(type), mDepsFlag(flag) {
    if (grpConds)
        mGrpConds = *grpConds;
    if (!singleThrd) {
        std::stringstream ss;
        ss << "g-" << std::hex << mGroupType << std::hex << ":" << mDepsFlag;
        mRkAiqGroupMsgHdlTh = new RkAiqAnalyzeGroupMsgHdlThread(ss.str().c_str(), this);
    } else {
        mRkAiqGroupMsgHdlTh = nullptr;
    }
}

XCamReturn RkAiqAnalyzerGroup::start() {
    if (mRkAiqGroupMsgHdlTh.ptr()) {
        mRkAiqGroupMsgHdlTh->triger_start();
        mRkAiqGroupMsgHdlTh->start();
    }

    return XCAM_RETURN_NO_ERROR;
}

void RkAiqAnalyzerGroup::msgReduction(std::map<uint32_t, GroupMessage>& msgMap) {
    // TODO(Cody): Workaround for current implementation
    // Should let message thread handle the reduction
    if (mGroupMsgMap.size() > 0) {
        const auto originalSize = mGroupMsgMap.size();
        const int numToErase    = originalSize - 5;
        if (numToErase > 0) {
            int32_t unreadyFlag = mDepsFlag & ~mGroupMsgMap.begin()->second.msg_flags;
            // print missing params
            std::string missing_conds;
            uint32_t i = 0;
            while (unreadyFlag) {
                if (unreadyFlag % 2) {
                    missing_conds.append(MessageType2Str[i]);
                    missing_conds.append(",");
                }
                unreadyFlag >>= 1;
                i++;
            }
            LOGW_ANALYZER_SUBM(ANALYZER_SUBM,
                    "camId:%d group(%s): id[%d] map size is %d, erase %d, element, missing conditions: %s",
                    mAiqCore->mAlogsComSharedParams.mCamPhyId,
                    AnalyzerGroupType2Str[mGroupType], mGroupMsgMap.begin()->first,
                    originalSize, numToErase,
                    missing_conds.c_str());

            auto eraseIter = mGroupMsgMap.begin();
            std::advance(eraseIter, numToErase);
            mGroupMsgMap.erase(mGroupMsgMap.begin(), eraseIter);
        }
    }
}

bool RkAiqAnalyzerGroup::pushMsg(const SmartPtr<XCamMessage>& msg) {
    //msgReduction(mGroupMsgMap);
    if (mRkAiqGroupMsgHdlTh.ptr()) {
        mRkAiqGroupMsgHdlTh->push_msg(msg);
    }
    return true;
}

int8_t RkAiqAnalyzerGroup::getMsgDelayCnt(XCamMessageType &msg_id) {
    uint32_t i = 0, delayCnt = 0;
    for (i = 0; i < mGrpConds.size; i++) {
        if (mGrpConds.conds[i].cond == msg_id)
           return mGrpConds.conds[i].delay;
    }

    if (i == mGrpConds.size)
        LOGE_ANALYZER_SUBM(ANALYZER_SUBM, "don't match msgId(0x%x) in mGrpConds", msg_id);

    return 0;
}

XCamReturn RkAiqAnalyzerGroup::msgHandle(const SmartPtr<XCamMessage>& msg) {
    if (!msg.ptr()) {
        LOGW_ANALYZER_SUBM(ANALYZER_SUBM, "msg is nullptr!");
        return XCAM_RETURN_ERROR_PARAM;
    }
    if (!((1ULL << msg->msg_id) & mDepsFlag)) {
        return XCAM_RETURN_BYPASS;
    }

    uint32_t delayCnt = getMsgDelayCnt(msg->msg_id);
    uint32_t userId = msg->frame_id + delayCnt;
    GroupMessage& msgWrapper = mGroupMsgMap[userId];
    msgWrapper.msg_flags |= 1ULL << msg->msg_id;
    msgWrapper.msgList.push_back(msg);
    LOGD_ANALYZER_SUBM(ANALYZER_SUBM,
        "camId: %d, group(%s): id[%d] push msg(%s), msg delayCnt(%d), map size is %d",
         mAiqCore->mAlogsComSharedParams.mCamPhyId,
         AnalyzerGroupType2Str[mGroupType], msg->frame_id,
         MessageType2Str[msg->msg_id], delayCnt, mGroupMsgMap.size());

    uint64_t msg_flags = msgWrapper.msg_flags;
    if (!(msg_flags ^ mDepsFlag)) {
        for (auto it = mGroupMsgMap.begin(); it != mGroupMsgMap.end();) {
            if ((*it).first < userId) {
                it = mGroupMsgMap.erase(it);
            } else {
                break;//it++;
            }
        }
        std::vector<SmartPtr<XCamMessage>>& msgList = msgWrapper.msgList;
        mHandler(msgList, userId, getType());
        mGroupMsgMap.erase(userId);
        LOGD_ANALYZER("%s, group %s erase frame(%d) msg map\n", __FUNCTION__, AnalyzerGroupType2Str[mGroupType], userId);
    } else {
        msgReduction(mGroupMsgMap);
        return XCAM_RETURN_BYPASS;
    }

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn RkAiqAnalyzerGroup::stop() {
    if (mRkAiqGroupMsgHdlTh.ptr()) {
        mRkAiqGroupMsgHdlTh->triger_stop();
        mRkAiqGroupMsgHdlTh->stop();
    }
    mGroupMsgMap.clear();

    return XCAM_RETURN_NO_ERROR;
}

bool RkAiqAnalyzeGroupMsgHdlThread::loop() {
    ENTER_ANALYZER_FUNCTION();

    const static int32_t timeout = -1;
    bool res = false;

    //XCAM_STATIC_FPS_CALCULATION(GROUPMSGTH, 100);
    SmartPtr<XCamMessage> msg = mMsgsQueue.pop(timeout);
    if (!msg.ptr()) {
        LOGW_ANALYZER_SUBM(ANALYZER_SUBM, "RkAiqAnalyzeGroupMsgHdlThread got empty msg, stop thread");
        return false;
    }

    for (auto& grp : mHandlerGroups) {
        XCamReturn ret = grp->msgHandle(msg);
        if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_ERROR_TIMEOUT ||
            ret == XCAM_RETURN_BYPASS)
            res = true;
    }

    EXIT_ANALYZER_FUNCTION();

    return res;
}

RkAiqAnalyzeGroupManager::RkAiqAnalyzeGroupManager(RkAiqCore* aiqCore, bool single_thread)
    : mAiqCore(aiqCore), mSingleThreadMode(single_thread), mMsgThrd(nullptr) {}

uint64_t RkAiqAnalyzeGroupManager::getGrpDeps(rk_aiq_core_analyze_type_e group) {
    auto res = std::find_if(std::begin(mGroupMap), std::end(mGroupMap),
                            [&group](const std::pair<uint64_t, SmartPtr<RkAiqAnalyzerGroup>>& grp) {
                                return group == grp.second->getType();
                            });
    if (res != std::end(mGroupMap)) {
        return res->second->getDepsFlag();
    }

    return 0;
}

XCamReturn RkAiqAnalyzeGroupManager::setGrpDeps(rk_aiq_core_analyze_type_e group,
                                                uint64_t new_deps) {
    auto res = std::find_if(std::begin(mGroupMap), std::end(mGroupMap),
                            [&group](const std::pair<uint64_t, SmartPtr<RkAiqAnalyzerGroup>>& grp) {
                                return group == grp.second->getType();
                            });
    if (res != std::end(mGroupMap)) {
        uint64_t old_deps = res->second->getDepsFlag();

        if (old_deps == new_deps)
            return XCAM_RETURN_NO_ERROR;

        res->second->setDepsFlag(new_deps);
        mGroupMap[new_deps] = res->second;
        mGroupMap.erase(old_deps);
        return XCAM_RETURN_NO_ERROR;
    }

    return XCAM_RETURN_ERROR_PARAM;
}

XCamReturn RkAiqAnalyzeGroupManager::firstAnalyze() {

    RkAiqCore::RkAiqAlgosGroupShared_t* shared = nullptr;
    for (auto& it : mGroupMap) {
        uint64_t grpMask = mAiqCore->grpId2GrpMask(it.second->getType());
        mAiqCore->getGroupSharedParams(grpMask, shared);
        XCAM_ASSERT(shared != nullptr);
        mAiqCore->groupAnalyze(it.second->getType(), shared);
    }
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn RkAiqAnalyzeGroupManager::start() {
    if (mSingleThreadMode) {
        mMsgThrd->triger_start();
        mMsgThrd->start();
    } else {
        for (auto& it : mGroupMap) {
            it.second->start();
        }
    }

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn RkAiqAnalyzeGroupManager::stop() {
    if (mSingleThreadMode) {
        mMsgThrd->triger_stop();
        mMsgThrd->stop();
    } else {
        for (auto& it : mGroupMap) {
            it.second->stop();
        }
    }
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn RkAiqAnalyzeGroupManager::groupMessageHandler(std::vector<SmartPtr<XCamMessage>>& msgs,
                                                         uint32_t id, uint64_t grpId) {
    uint64_t grpMask                           = mAiqCore->grpId2GrpMask(grpId);
    RkAiqCore::RkAiqAlgosGroupShared_t* shared = nullptr;
    mAiqCore->getGroupSharedParams(grpMask, shared);
    XCAM_ASSERT(shared != nullptr);
    SmartPtr<RkAiqCoreVdBufMsg> vdBufMsg;
    shared->frameId = id;
    for (auto& msg : msgs) {
        switch (msg->msg_id) {
            case XCAM_MESSAGE_SOF_INFO_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) {
                    auto sofInfoMsg =
                        vdBufMsg->msg.dynamic_cast_ptr<RkAiqSofInfoWrapperProxy>();
                    shared->curExp = sofInfoMsg->data()->curExp->data()->aecExpInfo;
                    shared->preExp = sofInfoMsg->data()->preExp->data()->aecExpInfo;
                    shared->nxtExp = sofInfoMsg->data()->nxtExp->data()->aecExpInfo;
                    shared->sof    = sofInfoMsg->data()->sof;
                }
                break;
            case XCAM_MESSAGE_ISP_STATS_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->ispStats = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_AEC_STATS_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->aecStatsBuf = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_AWB_STATS_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->awbStatsBuf = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_AF_STATS_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->afStatsBuf = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_ISP_POLL_SP_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->sp = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_ISP_GAIN_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->ispGain = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_ISP_POLL_TX_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->tx = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_ISPP_GAIN_KG_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->kgGain = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_ISPP_GAIN_WR_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->wrGain = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_ORB_STATS_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->orbStats = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_NR_IMG_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr()) shared->nrImg = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_PDAF_STATS_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr())
                    shared->pdafStatsBuf = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;

            case XCAM_MESSAGE_AE_PRE_RES_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr())
                    shared->res_comb.ae_pre_res = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_AE_PROC_RES_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr())
                    shared->res_comb.ae_proc_res = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_AWB_PROC_RES_OK:
                vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                if (vdBufMsg.ptr())
                    shared->res_comb.awb_proc_res = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            case XCAM_MESSAGE_AMD_PROC_RES_OK:
                // vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();
                // if (vdBufMsg.ptr()) xCamAmdProcRes = convert_to_XCamVideoBuffer(vdBufMsg->msg);
                break;
            default:
                break;
        }
    }
    msgs.clear();

    mAiqCore->groupAnalyze(grpId, shared);

    if (shared->aecStatsBuf) {
        shared->aecStatsBuf->unref(shared->aecStatsBuf);
        shared->aecStatsBuf = nullptr;
    }
    if (shared->awbStatsBuf) {
        shared->awbStatsBuf->unref(shared->awbStatsBuf);
        shared->awbStatsBuf = nullptr;
    }
    if (shared->afStatsBuf) {
        shared->afStatsBuf->unref(shared->afStatsBuf);
        shared->afStatsBuf = nullptr;
    }
    if (shared->ispStats) {
        shared->ispStats->unref(shared->ispStats);
        shared->ispStats = nullptr;
    }
    if (shared->tx) {
        shared->tx->unref(shared->tx);
        shared->tx = nullptr;
    }
    if (shared->sp) {
        shared->sp->unref(shared->sp);
        shared->sp = nullptr;
    }
    if (shared->ispGain) {
        shared->ispGain->unref(shared->ispGain);
        shared->ispGain = nullptr;
    }
    if (shared->kgGain) {
        shared->kgGain->unref(shared->kgGain);
        shared->kgGain = nullptr;
    }
    if (shared->wrGain) {
        shared->wrGain->unref(shared->wrGain);
        shared->wrGain = nullptr;
    }
    if (shared->orbStats) {
        shared->orbStats->unref(shared->orbStats);
        shared->orbStats = nullptr;
    }
    if (shared->nrImg) {
        shared->nrImg->unref(shared->nrImg);
        shared->nrImg = nullptr;
    }
    if (shared->pdafStatsBuf) {
        shared->pdafStatsBuf->unref(shared->pdafStatsBuf);
        shared->pdafStatsBuf = nullptr;
    }
    if (shared->res_comb.ae_pre_res) {
        shared->res_comb.ae_pre_res->unref(shared->res_comb.ae_pre_res);
        shared->res_comb.ae_pre_res = nullptr;
    }
    if (shared->res_comb.ae_proc_res) {
        shared->res_comb.ae_proc_res->unref(shared->res_comb.ae_proc_res);
        shared->res_comb.ae_proc_res = nullptr;
    }
    if (shared->res_comb.awb_proc_res) {
        shared->res_comb.awb_proc_res->unref(shared->res_comb.awb_proc_res);
        shared->res_comb.awb_proc_res = nullptr;
    }

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn RkAiqAnalyzeGroupManager::thumbnailsGroupMessageHandler(
    std::vector<SmartPtr<XCamMessage>>& msgs, uint32_t id, uint64_t grpId) {
    //XCAM_STATIC_FPS_CALCULATION(THUMBHANDLER, 100);
    rkaiq_image_source_t thumbnailsSrc;
    SmartPtr<XCamMessage> msg            = msgs.front();
    SmartPtr<RkAiqCoreVdBufMsg> vdBufMsg = msg.dynamic_cast_ptr<RkAiqCoreVdBufMsg>();

    if (!vdBufMsg.ptr()) return XCAM_RETURN_BYPASS;

    if (msg->msg_id == XCAM_MESSAGE_ISP_POLL_SP_OK) {
        XCamVideoBuffer* sp = NULL;
        sp                  = convert_to_XCamVideoBuffer(vdBufMsg->msg);

        thumbnailsSrc.frame_id     = msg->frame_id;
        thumbnailsSrc.src_type     = RKISP20_STREAM_SP;
        thumbnailsSrc.image_source = sp;
    } else if (msg->msg_id == XCAM_MESSAGE_NR_IMG_OK) {
        XCamVideoBuffer* nrImg = NULL;
        nrImg                  = convert_to_XCamVideoBuffer(vdBufMsg->msg);

        thumbnailsSrc.frame_id     = msg->frame_id;
        thumbnailsSrc.src_type     = RKISP20_STREAM_NR;
        thumbnailsSrc.image_source = nrImg;
    }

    mAiqCore->thumbnailsGroupAnalyze(thumbnailsSrc);

    return XCAM_RETURN_NO_ERROR;
}

void RkAiqAnalyzeGroupManager::parseAlgoGroup(const struct RkAiqAlgoDesCommExt* algoDes) {
    uint64_t enAlgosMask = mAiqCore->getCustomEnAlgosMask();
    if (mSingleThreadMode) {
        mMsgThrd = new RkAiqAnalyzeGroupMsgHdlThread("GrpMsgThrd", nullptr);
        XCAM_ASSERT(mMsgThrd.ptr() != nullptr);
    }
    for (size_t i = 0; algoDes[i].des != NULL; i++) {
        int algo_type = algoDes[i].des->type;
        if (!((1ULL << algo_type) & enAlgosMask))
            continue;
        int deps_flag = 0;
        for (size_t j = 0; j < algoDes[i].grpConds.size; j++)
            deps_flag |= 1ULL << algoDes[i].grpConds.conds[j].cond;
        rk_aiq_core_analyze_type_e group = algoDes[i].group;
        mGroupAlgoListMap[group].push_back(*mAiqCore->getCurAlgoTypeHandle(algo_type));
        mGroupAlgoListMap[RK_AIQ_CORE_ANALYZE_ALL].push_back(*mAiqCore->getCurAlgoTypeHandle(algo_type));
        if (mGroupMap.count(deps_flag)) {
            continue;
        }
        mGroupMap[deps_flag] = new RkAiqAnalyzerGroup(mAiqCore, group, deps_flag,
                                                      &algoDes[i].grpConds, mSingleThreadMode);
        if (mSingleThreadMode) mMsgThrd->add_group(mGroupMap[deps_flag].ptr());
        if (group == RK_AIQ_CORE_ANALYZE_THUMBNAILS) {
            mGroupMap[deps_flag]->setConcreteHandler(
                std::bind(&RkAiqAnalyzeGroupManager::thumbnailsGroupMessageHandler, this,
                          std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
        } else {
            mGroupMap[deps_flag]->setConcreteHandler(
                std::bind(&RkAiqAnalyzeGroupManager::groupMessageHandler, this,
                          std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
        }
        LOGD_ANALYZER_SUBM(ANALYZER_SUBM, "Created group %" PRIx64 " for dep flags %" PRIx64"", group, deps_flag);
    }
}

XCamReturn RkAiqAnalyzeGroupManager::handleMessage(const SmartPtr<XCamMessage> &msg) {
    //XCAM_STATIC_FPS_CALCULATION(HANDLEMSG, 100);
    if (mSingleThreadMode) {
        mMsgThrd->push_msg(msg);
        LOGD_ANALYZER_SUBM(ANALYZER_SUBM, "Handle message(%s) id[%d]", MessageType2Str[msg->msg_id],
                           msg->frame_id);
    } else {
        for (auto& it : mGroupMap) {
            if ((it.first & (1ULL << msg->msg_id)) != 0) {
                LOGD_ANALYZER_SUBM(
                    ANALYZER_SUBM, "Handle message(%s) id[%d] on group(%s), flags %" PRIx64 "",
                    MessageType2Str[msg->msg_id], msg->frame_id,
                    AnalyzerGroupType2Str[it.second->getType()], it.second->getDepsFlag());

                it.second->pushMsg(msg);
            }
        }
    }
    return XCAM_RETURN_NO_ERROR;
}

};  // namespace RkCam