/*
 * Copyright (C) 2019-2020 Intel 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.
 */

#define LOG_TAG "IA_FACE_ENGINE_IPC"

#include "LogHelper.h"
#include "IntelFaceEngine.h"
#include <utils/Errors.h>
#include "UtilityMacros.h"

namespace cros {
namespace intel {
IntelFaceEngine::IntelFaceEngine():
    mInitialized(false)
{
    LOG1("@%s", __FUNCTION__);

    mMems = {{"/faceEngineInitShm", sizeof(face_engine_init_params), &mMemInit, false}};
    for (uint32_t i= 0; i < MAX_STORE_FACE_DATA_BUF_NUM; i++) {
        mMems.push_back({("/faceEngineRunShm" + std::to_string(i)), sizeof(face_engine_run_params), &mMemRunBufs[i], false});
        mMemRunPool.push(&mMemRunBufs[i]);
    }

    bool success = mCommon.allocateAllShmMems(mMems);
    if (!success) {
        mCommon.releaseAllShmMems(mMems);
        return;
    }

    LOG1("@%s, done", __FUNCTION__);
    mInitialized = true;
}

IntelFaceEngine::~IntelFaceEngine()
{
    LOG1("@%s", __FUNCTION__);
    mCommon.releaseAllShmMems(mMems);
}

bool IntelFaceEngine::init(unsigned int max_face_num, int maxWidth, int maxHeight, face_detection_mode fd_mode)
{
    LOG1("@%s, max_face_num:%d, fd_mode:%d", __FUNCTION__, max_face_num, fd_mode);
    CheckError(!mInitialized, false, "@%s, mInitialized is false", __FUNCTION__);

    CheckError((maxWidth * maxHeight > MAX_FACE_FRAME_SIZE), false,
                "@%s, maxWidth:%d, maxHeight:%d > MAX_FACE_FRAME_SIZE", __FUNCTION__, maxWidth, maxHeight);

    face_engine_init_params* params = static_cast<face_engine_init_params*>(mMemInit.mAddr);

    bool ret = mIpc.clientFlattenInit(max_face_num, fd_mode, params);
    CheckError(!ret, false, "@%s, clientFlattenInit fails", __FUNCTION__);

    ret = mCommon.requestSync(IPC_FACE_INIT, mMemInit.mHandle);
    CheckError(!ret, false, "@%s, requestSync fails", __FUNCTION__);

    return true;
}

void IntelFaceEngine::uninit()
{
    LOG1("@%s", __FUNCTION__);
    CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false", __FUNCTION__);

    bool ret = mCommon.requestSync(IPC_FACE_UNINIT);
    CheckError(!ret, VOID_VALUE, "@%s, requestSync fails", __FUNCTION__);
}

bool IntelFaceEngine::prepareRun(const pvl_image &frame)
{
    LOG1("@%s, size:%d, w:%d, h:%d, f:%d, s:%d, r:%d", __FUNCTION__,
         frame.size, frame.width, frame.height, frame.format, frame.stride, frame.rotation);
    CheckError(!mInitialized, false, "@%s, mInitialized is false", __FUNCTION__);

    ShmMemInfo *memRunBufTmp = acquireRunBuf();
    CheckError((!memRunBufTmp), false, "Failed to acquire buffer");

    face_engine_run_params* params = static_cast<face_engine_run_params*>(memRunBufTmp->mAddr);
    bool ret = mIpc.clientFlattenRun(frame, params);
    if (!ret) {
        LOGE("@%s, clientFlattenInit fails", __FUNCTION__);
        returnRunBuf(memRunBufTmp);
        return false;
    }

    std::lock_guard<std::mutex> l(mMemRunningPoolLock);
    mMemRunningPool.push(memRunBufTmp);
    return true;
}

bool IntelFaceEngine::run(FaceEngineResult *results)
{
    LOG1("@%s", __FUNCTION__);
    CheckError(!mInitialized, false, "@%s, mInitialized is false", __FUNCTION__);
    CheckError(!results, false, "input parameters are invalid");
    CLEAR(*results);

    ShmMemInfo *memRunBuf = nullptr;
    {
        std::lock_guard<std::mutex> l(mMemRunningPoolLock);
        CheckError(mMemRunningPool.empty(), false, "mMemRunningPool is empty");
        memRunBuf = mMemRunningPool.front();
        mMemRunningPool.pop();
    }

    face_engine_run_params* params = static_cast<face_engine_run_params*>(memRunBuf->mAddr);
    bool ret = mCommon.requestSync(IPC_FACE_RUN, memRunBuf->mHandle);
    if (ret) {
        *results = params->results;
    } else {
        LOGE("@%s, requestSync fails", __FUNCTION__);
    }
    returnRunBuf(memRunBuf);

    return ret;
}

ShmMemInfo *IntelFaceEngine::acquireRunBuf()
{
    std::lock_guard<std::mutex> l(mMemRunPoolLock);
    LOG2("%s size is %zu", __FUNCTION__, mMemRunPool.size());

    ShmMemInfo *memRunBuf = nullptr;
    if (!mMemRunPool.empty()) {
        memRunBuf = mMemRunPool.front();
        mMemRunPool.pop();
    }
    return memRunBuf;
}

void IntelFaceEngine::returnRunBuf(ShmMemInfo *memRunBuf)
{
    LOG2("Push back run buffer");
    std::lock_guard<std::mutex> l(mMemRunPoolLock);
    mMemRunPool.push(memRunBuf);
}

} /* namespace intel */
} /* namespace cros */