/*
 * 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 "IntelAlgoClient"

#include "modules/sandboxing/client/IntelAlgoClient.h"

#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <memory>
#include <string>
#include <vector>

#include "Parameters.h"
#include "PlatformData.h"
#include "iutils/Errors.h"
#include "iutils/Utils.h"

namespace icamera {

IntelAlgoClient* IntelAlgoClient::sInstance = nullptr;
Mutex IntelAlgoClient::sLock;

IntelAlgoClient* IntelAlgoClient::getInstance() {
    AutoMutex lock(sLock);

    if (!sInstance) {
        sInstance = new IntelAlgoClient;
    }

    return sInstance;
}

void IntelAlgoClient::releaseInstance() {
    AutoMutex lock(sLock);

    if (sInstance) {
        delete sInstance;
        sInstance = nullptr;
    }
}

IntelAlgoClient::IntelAlgoClient()
        : mErrCb(nullptr),
          mGpuBridge(nullptr),
          mIPCStatus(true),
          mMojoManager(nullptr),
          mInitialized(false) {
    LOGIPC("@%s", __func__);
}

IntelAlgoClient::~IntelAlgoClient() {
    LOGIPC("@%s", __func__);
}

int IntelAlgoClient::initialize() {
    LOGIPC("@%s, mMojoManager: %p", __func__, mMojoManager);
    CheckError(!mMojoManager, UNKNOWN_ERROR, "@%s, mMojoManager is nullptr", __func__);

    mCallback = base::Bind(&IntelAlgoClient::callbackHandler, base::Unretained(this));
    IntelAlgoClient::return_callback = returnCallback;

    mNotifyCallback = base::Bind(&IntelAlgoClient::notifyHandler, base::Unretained(this));
    IntelAlgoClient::notify = notifyCallback;

    mBridge = cros::CameraAlgorithmBridge::CreateInstance(cros::CameraAlgorithmBackend::kVendorCpu,
                                                          mMojoManager);
    CheckError(!mBridge, UNKNOWN_ERROR, "@%s, mBridge is nullptr", __func__);
    CheckError(mBridge->Initialize(this) != 0, UNKNOWN_ERROR, "@%s, mBridge init fails", __func__);

    if (PlatformData::isUsingGpuAlgo()) {
        LOGIPC("@%s GPU algo enabled", __func__);
        mGpuBridge = cros::CameraAlgorithmBridge::CreateInstance(
            cros::CameraAlgorithmBackend::kVendorGpu, mMojoManager);
        CheckError(!mGpuBridge, UNKNOWN_ERROR, "@%s, mGpuBridge is nullptr", __func__);
        CheckError(mGpuBridge->Initialize(this) != 0, UNKNOWN_ERROR, "@%s, mGpuBridge init fails",
                   __func__);
    }

    for (int i = 0; i < IPC_GROUP_NUM; i++) {
        if (static_cast<IPC_GROUP>(i) != IPC_GROUP_GPU) {
            mRunner[i] =
                std::unique_ptr<Runner>(new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));
        } else if (mGpuBridge) {
            mRunner[i] = std::unique_ptr<Runner>(new Runner(IPC_GROUP_GPU, mGpuBridge.get()));
        }
    }

    mIPCStatus = true;
    mInitialized = true;

    return OK;
}

bool IntelAlgoClient::isIPCFine() {
    std::lock_guard<std::mutex> l(mIPCStatusMutex);
    LOGIPC("@%s, mIPCStatus:%d", __func__, mIPCStatus);

    return mIPCStatus;
}

void IntelAlgoClient::registerErrorCallback(const camera_callback_ops_t* errCb) {
    LOGIPC("@%s, errCb:%p", __func__, errCb);

    std::lock_guard<std::mutex> l(mIPCStatusMutex);
    mErrCb = errCb;

    if (!mIPCStatus && mErrCb) {
        camera_msg_data_t data = {CAMERA_IPC_ERROR, {0}};
        mErrCb->notify(mErrCb, data);
    }
}

int IntelAlgoClient::allocateShmMem(const std::string& name, int size, int* fd, void** addr) {
    LOGIPC("@%s, name:%s, size:%d", __func__, name.c_str(), size);

    *fd = -1;
    *addr = nullptr;
    int shmFd = -1;
    void* shmAddr = nullptr;

    shmFd = shm_open(name.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
    CheckError((shmFd == -1), UNKNOWN_ERROR, "@%s, call shm_open fail", __func__);

    do {
        int ret = fcntl(shmFd, F_GETFD);
        if (ret == -1) {
            LOGE("@%s, call fcntl fail, error %s", __func__, strerror(errno));
            break;
        }

        ret = ftruncate(shmFd, size);
        if (ret == -1) {
            LOGE("@%s, call ftruncate fail, error %s", __func__, strerror(errno));
            break;
        }

        struct stat sb;
        ret = fstat(shmFd, &sb);
        if (ret == -1) {
            LOGE("@%s, call fstat fail, error %s", __func__, strerror(errno));
            break;
        }

        shmAddr = mmap(0, sb.st_size, PROT_WRITE, MAP_SHARED, shmFd, 0);
        if (!shmAddr) {
            LOGE("@%s, call mmap fail, error %s", __func__, strerror(errno));
            break;
        }

        *fd = shmFd;
        *addr = shmAddr;

        return OK;
    } while (0);

    close(shmFd);
    return UNKNOWN_ERROR;
}

void IntelAlgoClient::releaseShmMem(const std::string& name, int size, int fd, void* addr) {
    LOGIPC("@%s, name:%s, size:%d, fd:%d, addr:%p", __func__, name.c_str(), size, fd, addr);

    munmap(addr, size);
    close(fd);
    shm_unlink(name.c_str());
}

int IntelAlgoClient::requestSync(IPC_CMD cmd, int32_t bufferHandle) {
    LOGIPC("@%s, cmd:%d:%s, bufferHandle:%d, mInitialized:%d", __func__, cmd,
           IntelAlgoIpcCmdToString(cmd), bufferHandle, mInitialized);
    CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false", __func__);
    CheckError(!isIPCFine(), UNKNOWN_ERROR, "@%s, IPC error happens", __func__);

    IPC_GROUP group = IntelAlgoIpcCmdToGroup(cmd);

    return mRunner[group]->requestSync(cmd, bufferHandle);
}

int IntelAlgoClient::requestSync(IPC_CMD cmd) {
    return requestSync(cmd, -1);
}

int32_t IntelAlgoClient::registerBuffer(int bufferFd, void* addr, ShmMemUsage usage) {
    LOGIPC("@%s, bufferFd: %d, mInitialized: %d, addr: %p, usage: %d", __func__, bufferFd,
           mInitialized, addr, usage);
    CheckError(!mInitialized, -1, "@%s, mInitialized is false", __func__);
    CheckError(usage >= MAX_ALGO_SHM, -1, "@%s, usage: %d isn't supported", __func__, usage);
    CheckError(!isIPCFine(), -1, "@%s, IPC error happens", __func__);

    int32_t handle = -1;
    if (usage == CPU_ALGO_SHM) {
        handle = mBridge->RegisterBuffer(bufferFd);
    } else if (mGpuBridge) {
        handle = mGpuBridge->RegisterBuffer(bufferFd);
    }
    if (handle >= 0) {
        std::lock_guard<std::mutex> l(mShmMapMutex);
        mShmMap[usage][addr] = handle;
    }

    return handle;
}

void IntelAlgoClient::deregisterBuffer(int32_t bufferHandle, ShmMemUsage usage) {
    LOGIPC("@%s, bufferHandle: %d, mInitialized: %d, usage: %d", __func__, bufferHandle,
           mInitialized, usage);
    CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false", __func__);
    CheckError(usage >= MAX_ALGO_SHM, VOID_VALUE, "@%s, usage: %d isn't supported", __func__,
               usage);
    CheckError(!isIPCFine(), VOID_VALUE, "@%s, IPC error happens", __func__);

    {
        std::lock_guard<std::mutex> l(mShmMapMutex);
        for (auto& item : mShmMap[usage]) {
            if (item.second == bufferHandle) {
                mShmMap[usage].erase(item.first);
                break;
            }
        }
    }

    std::vector<int32_t> handles({bufferHandle});
    if (usage == CPU_ALGO_SHM) {
        mBridge->DeregisterBuffers(handles);
    } else if (mGpuBridge) {
        mGpuBridge->DeregisterBuffers(handles);
    }
}

int32_t IntelAlgoClient::registerGbmBuffer(int bufferFd, ShmMemUsage usage) {
    LOGIPC("@%s, bufferFd:%d, mInitialized:%d", __func__, bufferFd, mInitialized);
    CheckError(!mInitialized, -1, "@%s, mInitialized is false", __func__);
    CheckError(!isIPCFine(), -1, "@%s, IPC error happens", __func__);

    if (usage == CPU_ALGO_SHM) {
        return mBridge->RegisterBuffer(bufferFd);
    } else if (mGpuBridge) {
        return mGpuBridge->RegisterBuffer(bufferFd);
    }
    return OK;
}

void IntelAlgoClient::deregisterGbmBuffer(int32_t bufferHandle, ShmMemUsage usage) {
    LOGIPC("@%s, bufferHandle:%d, mInitialized:%d", __func__, bufferHandle, mInitialized);
    CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false", __func__);
    CheckError(!isIPCFine(), VOID_VALUE, "@%s, IPC error happens", __func__);

    std::vector<int32_t> handles({bufferHandle});
    if (usage == CPU_ALGO_SHM) {
        mBridge->DeregisterBuffers(handles);
    } else if (mGpuBridge) {
        mGpuBridge->DeregisterBuffers(handles);
    }
}

int32_t IntelAlgoClient::getBufferHandle(void* addr, ShmMemUsage usage) {
    CheckError(!mInitialized, -1, "@%s, mInitialized is false", __func__);
    CheckError(usage >= MAX_ALGO_SHM, -1, "@%s, usage: %d isn't supported", __func__, usage);
    if (!addr) return -1;

    LOGIPC("%s, the buffer addr: %p, usage: %d", __func__, addr, usage);
    std::lock_guard<std::mutex> l(mShmMapMutex);
    CheckError(mShmMap[usage].find(addr) == mShmMap[usage].end(), -1,
               "%s, Invalid client addr: %p, usage: %d", __func__, addr, usage);

    return mShmMap[usage][addr];
}

void IntelAlgoClient::callbackHandler(uint32_t req_id, uint32_t status, int32_t buffer_handle) {
    LOGIPC("@%s, req_id:%d, status:%d, buffer_handle:%d", __func__, req_id, status, buffer_handle);

    IPC_GROUP group = IntelAlgoIpcCmdToGroup(static_cast<IPC_CMD>(req_id));
    mRunner[group]->callbackHandler(status, buffer_handle);
}

void IntelAlgoClient::notifyHandler(uint32_t msg) {
    LOGIPC("@%s, msg:%d", __func__, msg);

    if (msg != CAMERA_ALGORITHM_MSG_IPC_ERROR) {
        LOGE("@%s, receive msg:%d, not CAMERA_ALGORITHM_MSG_IPC_ERROR", __func__, msg);
        return;
    }

    std::lock_guard<std::mutex> l(mIPCStatusMutex);
    mIPCStatus = false;

    if (mErrCb) {
        camera_msg_data_t data = {CAMERA_IPC_ERROR, {0}};
        mErrCb->notify(mErrCb, data);
    } else {
        LOGE("@%s, mErrCb is nullptr, no device error is sent out", __func__);
    }
    LOGE("@%s, receive CAMERA_ALGORITHM_MSG_IPC_ERROR", __func__);
}

void IntelAlgoClient::returnCallback(const camera_algorithm_callback_ops_t* callback_ops,
                                     uint32_t req_id, uint32_t status, int32_t buffer_handle) {
    LOGIPC("@%s", __func__);
    CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr", __func__);

    auto s = const_cast<IntelAlgoClient*>(static_cast<const IntelAlgoClient*>(callback_ops));
    s->callbackHandler(req_id, status, buffer_handle);
}

void IntelAlgoClient::notifyCallback(const struct camera_algorithm_callback_ops* callback_ops,
                                     camera_algorithm_error_msg_code_t msg) {
    LOGIPC("@%s", __func__);
    CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr", __func__);

    auto s = const_cast<IntelAlgoClient*>(static_cast<const IntelAlgoClient*>(callback_ops));
    s->notifyHandler((uint32_t)msg);
}

IntelAlgoClient::Runner::Runner(IPC_GROUP group, cros::CameraAlgorithmBridge* bridge)
        : mGroup(group),
          mBridge(bridge),
          mIsCallbacked(false),
          mCbResult(true),
          mInitialized(false) {
    LOGIPC("@%s, group:%d", __func__, mGroup);

    pthread_condattr_t attr;
    int ret = pthread_condattr_init(&attr);
    if (ret != 0) {
        LOGE("@%s, call pthread_condattr_init fails, ret:%d", __func__, ret);
        pthread_condattr_destroy(&attr);
        return;
    }

    ret = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
    if (ret != 0) {
        LOGE("@%s, call pthread_condattr_setclock fails, ret:%d", __func__, ret);
        pthread_condattr_destroy(&attr);
        return;
    }

    ret = pthread_cond_init(&mCbCond, &attr);
    if (ret != 0) {
        LOGE("@%s, call pthread_cond_init fails, ret:%d", __func__, ret);
        pthread_condattr_destroy(&attr);
        return;
    }

    pthread_condattr_destroy(&attr);

    ret = pthread_mutex_init(&mCbLock, nullptr);
    CheckError(ret != 0, VOID_VALUE, "@%s, call pthread_mutex_init fails, ret:%d", __func__, ret);

    mInitialized = true;
}

IntelAlgoClient::Runner::~Runner() {
    LOGIPC("@%s, group:%d", __func__, mGroup);

    int ret = pthread_cond_destroy(&mCbCond);
    if (ret != 0) {
        LOGE("@%s, call pthread_cond_destroy fails, ret:%d", __func__, ret);
    }

    ret = pthread_mutex_destroy(&mCbLock);
    if (ret != 0) {
        LOGE("@%s, call pthread_mutex_destroy fails, ret:%d", __func__, ret);
    }
}

int IntelAlgoClient::Runner::requestSync(IPC_CMD cmd, int32_t bufferHandle) {
    LOGIPC("@%s, cmd:%d:%s, group:%d, bufferHandle:%d, mInitialized:%d", __func__, cmd,
           IntelAlgoIpcCmdToString(cmd), mGroup, bufferHandle, mInitialized);
    CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false, cmd:%d:%s", __func__, cmd,
               IntelAlgoIpcCmdToString(cmd));

    std::lock_guard<std::mutex> lck(mMutex);

    std::vector<uint8_t> reqHeader(IPC_REQUEST_HEADER_USED_NUM);
    reqHeader[0] = IPC_MATCHING_KEY;

    // cmd is for request id, no duplicate command will be issued at any given time.
    mBridge->Request(cmd, reqHeader, bufferHandle);
    int ret = waitCallback();
    CheckError((ret != OK), UNKNOWN_ERROR, "@%s, waitCallback fails, cmd:%d:%s", __func__, cmd,
               IntelAlgoIpcCmdToString(cmd));

    LOGIPC("@%s, cmd:%d:%s, group:%d, mCbResult:%d, done!", __func__, cmd,
           IntelAlgoIpcCmdToString(cmd), mGroup, mCbResult);

    // check callback result
    CheckError((mCbResult != true), UNKNOWN_ERROR, "@%s, callback fails, cmd:%d:%s", __func__, cmd,
               IntelAlgoIpcCmdToString(cmd));

    return OK;
}

void IntelAlgoClient::Runner::callbackHandler(uint32_t status, int32_t buffer_handle) {
    LOGIPC("@%s, group:%d, status:%d, buffer_handle:%d", __func__, mGroup, status, buffer_handle);
    if (status != 0) {
        LOGE("@%s, group:%d, status:%d, buffer_handle:%d", __func__, mGroup, status, buffer_handle);
    }
    mCbResult = status != 0 ? false : true;

    pthread_mutex_lock(&mCbLock);
    mIsCallbacked = true;
    int ret = pthread_cond_signal(&mCbCond);
    pthread_mutex_unlock(&mCbLock);

    CheckError(ret != 0, VOID_VALUE, "@%s, group:%d, call pthread_cond_signal fails, ret:%d",
               __func__, mGroup, ret);
}

int IntelAlgoClient::Runner::waitCallback() {
    LOGIPC("@%s, group:%d", __func__, mGroup);

    nsecs_t startTime = CameraUtils::systemTime();

    pthread_mutex_lock(&mCbLock);
    if (!mIsCallbacked) {
        int ret = 0;
        struct timespec ts = {0, 0};
        clock_gettime(CLOCK_MONOTONIC, &ts);
        ts.tv_sec += 5;  // 5s timeout

        while (!mIsCallbacked && !ret) {
            ret = pthread_cond_timedwait(&mCbCond, &mCbLock, &ts);
        }
        if (ret != 0) {
            LOGE("@%s, group:%d, call pthread_cond_timedwait fail, ret:%d, it takes %" PRId64 "ms",
                 __func__, mGroup, ret, (CameraUtils::systemTime() - startTime) / 1000000);
            pthread_mutex_unlock(&mCbLock);
            return UNKNOWN_ERROR;
        }
    }
    mIsCallbacked = false;
    pthread_mutex_unlock(&mCbLock);

    LOGIPC("@%s: group:%d, it takes %" PRId64 "ms", __func__, mGroup,
           (CameraUtils::systemTime() - startTime) / 1000000);

    return OK;
}

} /* namespace icamera */