/*
 * Copyright 2021 Rockchip Electronics 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.
 */

#define MODULE_TAG "mpp_server"

#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#include "mpp_env.h"
#include "mpp_list.h"
#include "mpp_time.h"
#include "osal_2str.h"
#include "mpp_common.h"
#include "mpp_mem_pool.h"

#include "mpp_device_debug.h"
#include "mpp_service_impl.h"
#include "mpp_server.h"

#define MAX_BATCH_TASK      8
#define MAX_SESSION_TASK    4
#define MAX_REQ_SEND_CNT    MAX_REQ_NUM
#define MAX_REQ_WAIT_CNT    2

#define MPP_SERVER_DBG_FLOW             (0x00000001)

#define mpp_serv_dbg(flag, fmt, ...)    _mpp_dbg(mpp_server_debug, flag, fmt, ## __VA_ARGS__)
#define mpp_serv_dbg_f(flag, fmt, ...)  _mpp_dbg_f(mpp_server_debug, flag, fmt, ## __VA_ARGS__)

#define mpp_serv_dbg_flow(fmt, ...)     mpp_serv_dbg(MPP_SERVER_DBG_FLOW, fmt, ## __VA_ARGS__)

#define FIFO_WRITE(size, count, wr, rd) \
    do { \
        wr++; \
        if (wr >= size) wr = 0; \
        count++; \
        mpp_assert(count <= size); \
    } while (0)

#define FIFO_READ(size, count, wr, rd) \
    do { \
        rd++; \
        if (rd >= size) rd = 0; \
        count--; \
        mpp_assert(count >= 0); \
    } while (0)

typedef struct MppDevTask_t     MppDevTask;
typedef struct MppDevBatTask_t  MppDevBatTask;
typedef struct MppDevSession_t  MppDevSession;
typedef struct MppDevBatServ_t  MppDevBatServ;

struct MppDevTask_t {
    /* link to server */
    struct list_head    link_server;
    /* link to session tasks */
    struct list_head    link_session;
    /* link to batch tasks */
    struct list_head    link_batch;

    MppDevSession       *session;
    MppDevBatTask       *batch;

    RK_S32              slot_idx;

    /* lock by server */
    RK_S32              task_id;
    /* lock by batch */
    RK_S32              batch_slot_id;

    MppReqV1            *req;
    RK_S32              req_cnt;
};

struct MppDevBatTask_t {
    MppMutexCond        *cond;

    /* link to server */
    struct list_head    link_server;
    /* link to session tasks */
    struct list_head    link_tasks;

    RK_U32              batch_id;

    MppDevBatCmd        *bat_cmd;
    MppReqV1            *send_reqs;
    MppReqV1            *wait_reqs;

    /* lock and clean by server */
    RK_S32              send_req_cnt;
    RK_S32              wait_req_cnt;

    /* lock by server */
    RK_S32              fill_cnt;
    RK_S32              fill_full;
    RK_S32              fill_timeout;
    RK_S32              poll_cnt;
};

struct MppDevSession_t {
    MppMutexCond        *cond;

    /* hash table to server */
    struct list_head    list_server;
    /* link to session waiting tasks */
    struct list_head    list_wait;
    /* link to session free tasks */
    struct list_head    list_done;

    MppDevMppService    *ctx;
    MppDevBatServ       *server;

    RK_S32              client;

    RK_S32              task_wait;
    RK_S32              task_done;

    MppDevTask          tasks[MAX_SESSION_TASK];
};

struct MppDevBatServ_t {
    Mutex               *lock;

    RK_S32              server_fd;
    RK_U32              batch_id;
    RK_U32              task_id;

    /* timer for serializing process */
    MppTimer            timer;

    /* session register */
    struct list_head    session_list;
    RK_S32              session_count;

    /* batch task queue */
    struct list_head    list_batch;
    struct list_head    list_batch_free;
    MppMemPool          batch_pool;
    RK_S32              batch_max_count;
    RK_S32              batch_task_size;
    RK_S32              batch_run;
    RK_S32              batch_free;
    RK_S32              max_task_in_batch;

    /* link to all pending tasks */
    struct list_head    pending_task;
    RK_S32              pending_count;
};

RK_U32 mpp_server_debug = 0;

static void batch_reset(MppDevBatTask *batch)
{
    mpp_assert(list_empty(&batch->link_tasks));

    batch->fill_cnt = 0;
    batch->fill_full = 0;
    batch->fill_timeout = 0;
    batch->poll_cnt = 0;
    batch->send_req_cnt = 0;
    batch->wait_req_cnt = 0;
}

MppDevBatTask *batch_add(MppDevBatServ *server)
{
    MppDevBatTask *batch = (MppDevBatTask *)mpp_mem_pool_get(server->batch_pool);

    mpp_assert(batch);
    if (NULL == batch)
        return batch;

    INIT_LIST_HEAD(&batch->link_server);
    INIT_LIST_HEAD(&batch->link_tasks);

    batch->send_reqs = (MppReqV1 *)(batch + 1);
    batch->wait_reqs = batch->send_reqs +
                       (server->max_task_in_batch * MAX_REQ_SEND_CNT);
    batch->bat_cmd = (MppDevBatCmd *)(batch->wait_reqs +
                                      (server->max_task_in_batch * MAX_REQ_WAIT_CNT));

    batch_reset(batch);
    list_add_tail(&batch->link_server, &server->list_batch_free);
    server->batch_free++;

    mpp_serv_dbg_flow("batch add free count %d:%d\n", server->batch_run, server->batch_free);
    return batch;
}

void batch_del(MppDevBatServ *server, MppDevBatTask *batch)
{
    mpp_assert(batch);
    mpp_assert(batch->fill_cnt == 0);
    mpp_assert(list_empty(&batch->link_tasks));

    list_del_init(&batch->link_server);

    mpp_mem_pool_put(server->batch_pool, batch);
    server->batch_free--;
    mpp_serv_dbg_flow("batch del free count %d:%d\n", server->batch_run, server->batch_free);
}

void batch_send(MppDevBatServ *server, MppDevBatTask *batch)
{
    RK_S32 ret = 0;

    mpp_assert(batch->send_req_cnt);

    ret = mpp_service_ioctl_request(server->server_fd, batch->send_reqs);
    if (ret) {
        mpp_err_f("ioctl batch cmd failed ret %d errno %d %s\n",
                  ret, errno, strerror(errno));
        ret = errno;
        mpp_serv_dbg_flow("batch %d -> send failed\n", batch->batch_id);
    }

    list_del_init(&batch->link_server);
    list_add_tail(&batch->link_server, &server->list_batch);
    server->batch_free--;
    server->batch_run++;
    mpp_serv_dbg_flow("batch %d -> send %d for %s\n", batch->batch_id,
                      batch->fill_cnt, batch->fill_timeout ? "timeout" : "ready");
}

void process_task(void *p)
{
    MppDevBatServ *server = (MppDevBatServ *)p;
    Mutex *lock = server->lock;
    RK_S32 ret = MPP_OK;
    MppDevTask *task;
    MppDevBatTask *batch;
    MppDevSession *session = NULL;
    MppDevBatCmd *bat_cmd;
    MppReqV1 *req = NULL;
    RK_S32 pending = 0;

    mpp_serv_dbg_flow("process task start\n");

    /* 1. try poll and get finished task */
    do {
        batch = list_first_entry_or_null(&server->list_batch, MppDevBatTask, link_server);
        if (NULL == batch)
            break;

        mpp_assert(batch->wait_req_cnt);
        ret = mpp_service_ioctl_request(server->server_fd, batch->wait_reqs);
        if (!ret) {
            MppDevTask *n;

            list_for_each_entry_safe(task, n, &batch->link_tasks, MppDevTask, link_batch) {
                RK_S32 batch_slot_id = task->batch_slot_id;
                MppDevBatCmd *cmd = batch->bat_cmd + batch_slot_id;

                mpp_assert(batch_slot_id < server->max_task_in_batch);
                session = task->session;

                ret = cmd->ret;
                if (ret == EAGAIN)
                    continue;

                if (ret == -EIO) {
                    mpp_err_f("batch %d:%d task %d poll error found\n",
                              batch->batch_id, task->batch_slot_id, task->task_id);
                    cmd->flag |= 1;
                    continue;
                }
                if (ret == 0) {
                    list_del_init(&task->link_batch);
                    task->batch = NULL;

                    mpp_serv_dbg_flow("batch %d:%d session %d ready and remove\n",
                                      batch->batch_id, task->batch_slot_id, session->client);
                    session->cond->lock();
                    session->task_done++;
                    session->cond->signal();
                    session->cond->unlock();
                    if (session->ctx && session->ctx->dev_cb)
                        mpp_callback(session->ctx->dev_cb, NULL);

                    batch->poll_cnt++;
                    cmd->flag |= 1;
                }
            }

            mpp_serv_dbg_flow("batch %d fill %d poll %d\n", batch->batch_id,
                              batch->fill_cnt, batch->poll_cnt);

            if (batch->poll_cnt == batch->fill_cnt) {
                mpp_serv_dbg_flow("batch %d poll done\n", batch->batch_id);
                list_del_init(&batch->link_server);
                list_add_tail(&batch->link_server, &server->list_batch_free);
                server->batch_run--;
                server->batch_free++;

                batch_reset(batch);
                batch = NULL;
                continue;
            }
        } else {
            mpp_log_f("batch %d poll ret %d errno %d %s", batch->batch_id,
                      ret, errno, strerror(errno));
            mpp_log_f("stop timer\n");
            mpp_timer_set_enable(server->timer, 0);
        }
        break;
    } while (1);

    /* 2. get prending task to fill */
    lock->lock();
    pending = server->pending_count;
    if (!pending && !server->batch_run && !server->session_count) {
        mpp_timer_set_enable(server->timer, 0);
        mpp_serv_dbg_flow("stop timer\n");
    }
    lock->unlock();

    mpp_serv_dbg_flow("pending %d running %d free %d max %d process start\n",
                      pending, server->batch_run, server->batch_free, server->batch_max_count);

try_proc_pending_task:
    /* 3. try get batch task*/
    if (!server->batch_free) {
        /* if not enough and max count does not reached create new batch */
        if (server->batch_free + server->batch_run >= server->batch_max_count) {
            mpp_serv_dbg_flow("finish for not batch slot\n");
            return ;
        }

        batch_add(server);
    }
    mpp_assert(server->batch_free);

    /* 4. if no pending task to send check timeout batch and send it */
    if (!pending) {
        if (!server->batch_free) {
            /* no pending and no free batch just done */
            return;
        }

        batch = list_first_entry_or_null(&server->list_batch_free, MppDevBatTask, link_server);
        mpp_assert(batch);
        if (NULL == batch) {
            mpp_log_f("batch run %d free %d\n", server->batch_run, server->batch_free);
            return;
        }

        /* send one timeout task */
        if (batch->fill_cnt)
            batch_send(server, batch);

        mpp_serv_dbg_flow("finish for no pending task\n");
        return;
    }

    mpp_serv_dbg_flow("pending task %d left to process\n", pending);

    /* 5. add task to add batch and try send batch */
    if (!server->batch_free) {
        /* no pending and no free batch just done */
        return;
    }

    batch = list_first_entry_or_null(&server->list_batch_free, MppDevBatTask, link_server);
    mpp_assert(batch);
    mpp_assert(pending);

    task = NULL;
    lock->lock();
    task = list_first_entry_or_null(&server->pending_task, MppDevTask, link_server);
    list_del_init(&task->link_server);
    server->pending_count--;
    lock->unlock();
    pending--;

    /* first task and setup new batch id */
    if (!batch->fill_cnt)
        batch->batch_id = server->batch_id++;

    task->batch = batch;
    task->batch_slot_id = batch->fill_cnt++;
    mpp_assert(task->batch_slot_id < server->max_task_in_batch);
    list_add_tail(&task->link_batch, &batch->link_tasks);
    if (batch->fill_cnt >= server->max_task_in_batch)
        batch->fill_full = 1;

    session = task->session;
    mpp_assert(session);
    mpp_assert(session->ctx);

    bat_cmd = batch->bat_cmd + task->batch_slot_id;
    bat_cmd->flag = 0;
    bat_cmd->client = session->client;
    bat_cmd->ret = 0;

    /* fill task to batch */
    /* add session info before each session task and then copy session request */
    req = &batch->send_reqs[batch->send_req_cnt++];
    req->cmd = MPP_CMD_SET_SESSION_FD;
    req->flag = MPP_FLAGS_MULTI_MSG;
    req->offset = 0;
    req->size = sizeof(*bat_cmd);
    req->data_ptr = REQ_DATA_PTR(bat_cmd);

    {
        RK_S32 i;

        for (i = 0; i < task->req_cnt; i++)
            batch->send_reqs[batch->send_req_cnt++] = task->req[i];
    }

    mpp_assert(batch->send_req_cnt <= server->max_task_in_batch * MAX_REQ_NUM);

    /* setup poll request */
    req = &batch->wait_reqs[batch->wait_req_cnt++];
    req->cmd = MPP_CMD_SET_SESSION_FD;
    req->flag = MPP_FLAGS_MULTI_MSG;
    req->offset = 0;
    req->size = sizeof(*bat_cmd);
    req->data_ptr = REQ_DATA_PTR(bat_cmd);

    req = &batch->wait_reqs[batch->wait_req_cnt++];
    req->cmd = MPP_CMD_POLL_HW_FINISH;
    req->flag = MPP_FLAGS_POLL_NON_BLOCK | MPP_FLAGS_MULTI_MSG | MPP_FLAGS_LAST_MSG;
    req->offset = 0;
    req->size = 0;
    req->data_ptr = 0;

    mpp_serv_dbg_flow("batch %d:%d add task %d:%d:%d\n",
                      batch->batch_id, task->batch_slot_id, session->client,
                      task->slot_idx, task->task_id);

    if (batch->fill_full) {
        list_del_init(&batch->link_server);
        list_add_tail(&batch->link_server, &server->list_batch);
        mpp_serv_dbg_flow("batch %d -> fill_nb %d fill ready\n",
                          batch->batch_id, batch->fill_cnt);
        batch_send(server, batch);
        batch = NULL;
    }
    goto try_proc_pending_task;
}

static void *mpp_server_thread(void *ctx)
{
    process_task((MppDevBatServ *)ctx);
    return NULL;
}

MPP_RET send_task(MppDevMppService *ctx)
{
    MppDevTask *task = NULL;
    MppDevSession *session = (MppDevSession *)ctx->serv_ctx;

    if (NULL == session || NULL == session->server) {
        mpp_err_f("invalid ctx %p session %p send task\n", ctx, session);
        return MPP_NOK;
    }

    MppDevBatServ *server = session->server;

    /* get free task from session and add to run list */
    session->cond->lock();
    /* get a free task and setup */
    task = list_first_entry_or_null(&session->list_done, MppDevTask, link_session);
    mpp_assert(task);

    task->req = ctx->reqs;
    task->req_cnt = ctx->req_cnt;

    list_del_init(&task->link_session);
    list_add_tail(&task->link_session, &session->list_wait);

    session->task_wait++;
    session->cond->unlock();

    server->lock->lock();
    task->task_id = server->task_id++;
    list_del_init(&task->link_server);
    list_add_tail(&task->link_server, &server->pending_task);
    server->pending_count++;
    mpp_serv_dbg_flow("session %d:%d add pending %d\n",
                      session->client, task->slot_idx, server->pending_count);

    mpp_timer_set_enable(server->timer, 1);
    server->lock->unlock();

    return MPP_OK;
}

MPP_RET wait_task(MppDevMppService *ctx, RK_S64 timeout)
{
    RK_S32 ret = MPP_OK;
    MppDevTask *task = NULL;
    MppDevSession *session = (MppDevSession *)ctx->serv_ctx;
    (void) timeout;

    if (NULL == session) {
        mpp_err_f("invalid ctx %p send task\n", ctx);
        return MPP_NOK;
    }

    task = list_first_entry_or_null(&session->list_wait, MppDevTask, link_session);
    mpp_assert(task);

    session->cond->lock();
    if (session->task_wait != session->task_done) {
        mpp_serv_dbg_flow("session %d wait %d start %d:%d\n", session->client,
                          task->task_id, session->task_wait, session->task_done);
        session->cond->wait();
    }
    mpp_serv_dbg_flow("session %d wait %d done %d:%d\n", session->client,
                      task->task_id, session->task_wait, session->task_done);
    session->cond->unlock();

    list_del_init(&task->link_session);
    list_add_tail(&task->link_session, &session->list_done);

    mpp_assert(session->task_wait == session->task_done);

    return (MPP_RET)ret;
}

class MppDevServer : Mutex
{
private:
    // avoid any unwanted function
    MppDevServer();
    ~MppDevServer();
    MppDevServer(const MppDevServer &);
    MppDevServer &operator=(const MppDevServer &);

    void clear();

    const char          *mServerError;
    const char          *mServerName;
    RK_S32              mInited;
    RK_U32              mEnable;

    MppDevBatServ       *mBatServer[VPU_CLIENT_BUTT];

    MppMemPool          mSessionPool;
    MppMemPool          mBatchPool;

    RK_S32              mMaxTaskInBatch;

    const MppServiceCmdCap *mCmdCap;

public:
    static MppDevServer *get_inst() {
        static MppDevServer inst;
        return &inst;
    }

    MppDevBatServ  *bat_server_get(MppClientType client_type);
    MPP_RET         bat_server_put(MppClientType client_type);

    MPP_RET attach(MppDevMppService *ctx);
    MPP_RET detach(MppDevMppService *ctx);

    MPP_RET check_status(void);
};

MppDevServer::MppDevServer() :
    mServerError(NULL),
    mServerName(NULL),
    mInited(0),
    mEnable(1),
    mSessionPool(NULL),
    mBatchPool(NULL),
    mMaxTaskInBatch(0),
    mCmdCap(NULL)
{
    RK_S32 batch_task_size = 0;

    mpp_env_get_u32("mpp_server_debug", &mpp_server_debug, 0);
    mpp_env_get_u32("mpp_server_enable", &mEnable, 1);
    mpp_env_get_u32("mpp_server_batch_task", (RK_U32 *)&mMaxTaskInBatch,
                    MAX_BATCH_TASK);

    mpp_assert(mMaxTaskInBatch >= 1 && mMaxTaskInBatch <= 32);
    batch_task_size = sizeof(MppDevBatTask) + mMaxTaskInBatch *
                      (sizeof(MppReqV1) * (MAX_REQ_SEND_CNT + MAX_REQ_WAIT_CNT) +
                       sizeof(MppDevBatCmd));

    mCmdCap = mpp_get_mpp_service_cmd_cap();
    if (MPP_OK != mpp_service_check_cmd_valid(MPP_CMD_SET_SESSION_FD, mCmdCap)) {
        mServerError = "mpp_service cmd not support";
        return;
    }

    do {
        mServerName = mpp_get_mpp_service_name();
        if (NULL == mServerName) {
            mServerError = "get service device failed";
            break;
        }

        mSessionPool = mpp_mem_pool_init(sizeof(MppDevSession));
        if (NULL == mSessionPool) {
            mServerError = "create session pool failed";
            break;
        }

        mBatchPool = mpp_mem_pool_init(batch_task_size);
        if (NULL == mBatchPool) {
            mServerError = "create batch tack pool failed";
            break;
        }

        mInited = 1;
    } while (0);

    if (!mInited) {
        clear();
        return;
    }

    memset(mBatServer, 0, sizeof(mBatServer));
}

MppDevServer::~MppDevServer()
{
    RK_S32 i;

    for (i = 0; i < VPU_CLIENT_BUTT; i++)
        bat_server_put((MppClientType)i);

    clear();
}

void MppDevServer::clear()
{
    if (mSessionPool) {
        mpp_mem_pool_deinit(mSessionPool);
        mSessionPool = NULL;
    }

    if (mBatchPool) {
        mpp_mem_pool_deinit(mBatchPool);
        mBatchPool = NULL;
    }
    mInited = 0;
    mEnable = 0;
}

MppDevBatServ *MppDevServer::bat_server_get(MppClientType client_type)
{
    MppDevBatServ *server = NULL;

    AutoMutex auto_lock(this);

    server = mBatServer[client_type];
    if (server)
        return server;

    server = mpp_calloc(MppDevBatServ, 1);
    if (NULL == server) {
        mpp_err("mpp server failed to get bat server\n");
        return NULL;
    }

    server->server_fd = open(mServerName, O_RDWR | O_CLOEXEC);
    if (server->server_fd < 0) {
        mpp_err("mpp server get bat server failed to open device\n");
        goto failed;
    }

    char timer_name[32];

    snprintf(timer_name, sizeof(timer_name) - 1, "%s_bat",
             strof_client_type(client_type));

    server->timer = mpp_timer_get(timer_name);
    if (NULL == server->timer) {
        mpp_err("mpp server get bat server failed to create timer\n");
        goto failed;
    }

    server->lock = new Mutex();
    if (NULL == server->lock) {
        mpp_err("mpp server get bat server failed to create mutex\n");
        goto failed;
    }

    mpp_timer_set_callback(server->timer, mpp_server_thread, server);
    /* 10ms */
    mpp_timer_set_timing(server->timer, 10, 10);

    INIT_LIST_HEAD(&server->session_list);
    INIT_LIST_HEAD(&server->list_batch);
    INIT_LIST_HEAD(&server->list_batch_free);
    INIT_LIST_HEAD(&server->pending_task);

    server->batch_pool = mBatchPool;
    server->max_task_in_batch = mMaxTaskInBatch;

    mBatServer[client_type] = server;
    return server;

failed:
    if (server) {
        if (server->timer) {
            mpp_timer_put(server->timer);
            server->timer = NULL;
        }

        if (server->server_fd >= 0) {
            close(server->server_fd);
            server->server_fd = -1;
        }
        if (server->lock) {
            delete server->lock;
            server->lock = NULL;
        }
    }
    MPP_FREE(server);
    return server;
}

MPP_RET MppDevServer::bat_server_put(MppClientType client_type)
{
    MppDevBatTask *batch, *n;
    MppDevBatServ *server = NULL;
    AutoMutex auto_lock(this);

    if (NULL == mBatServer[client_type])
        return MPP_OK;

    server = mBatServer[client_type];
    mBatServer[client_type] = NULL;

    mpp_assert(server->batch_run == 0);
    mpp_assert(list_empty(&server->list_batch));
    mpp_assert(server->pending_count == 0);

    /* stop thread first */
    if (server->timer) {
        mpp_timer_put(server->timer);
        server->timer = NULL;
    }

    if (server->batch_free) {
        list_for_each_entry_safe(batch, n, &server->list_batch_free, MppDevBatTask, link_server) {
            batch_del(server, batch);
        }
    } else {
        mpp_assert(list_empty(&server->list_batch_free));
    }

    if (server->server_fd >= 0) {
        close(server->server_fd);
        server->server_fd = -1;
    }
    if (server->lock) {
        delete server->lock;
        server->lock = NULL;
    }
    MPP_FREE(server);
    return MPP_OK;
}

MPP_RET MppDevServer::attach(MppDevMppService *ctx)
{
    RK_U32 i;

    if (!mInited) {
        mpp_err("mpp server failed for %s\n", mServerError);
        return MPP_NOK;
    }

    MppClientType client_type = (MppClientType)ctx->client_type;

    if (client_type < 0 || client_type >= VPU_CLIENT_BUTT) {
        mpp_err("mpp server attach failed with invalid client type %d\n", client_type);
        return MPP_NOK;
    }

    /* if client type server is not created create it first */
    MppDevBatServ *server = bat_server_get(client_type);
    if (NULL == server) {
        mpp_err("mpp server get bat server with client type %d failed\n", client_type);
        return MPP_NOK;
    }

    AutoMutex auto_lock(server->lock);
    if (ctx->serv_ctx)
        return MPP_OK;

    MppDevSession *session = (MppDevSession *)mpp_mem_pool_get(mSessionPool);
    INIT_LIST_HEAD(&session->list_server);
    INIT_LIST_HEAD(&session->list_wait);
    INIT_LIST_HEAD(&session->list_done);

    session->ctx = ctx;
    session->server = server;
    session->client = ctx->client;
    session->cond = new MppMutexCond();
    session->task_wait = 0;
    session->task_done = 0;

    for (i = 0; i < MPP_ARRAY_ELEMS(session->tasks); i++) {
        MppDevTask *task = &session->tasks[i];

        INIT_LIST_HEAD(&task->link_server);
        INIT_LIST_HEAD(&task->link_session);
        INIT_LIST_HEAD(&task->link_batch);
        task->session = session;
        task->batch = NULL;
        task->task_id = -1;
        task->slot_idx = i;

        list_add_tail(&task->link_session, &session->list_done);
    }

    list_add_tail(&session->list_server, &server->session_list);
    ctx->serv_ctx = session;

    if (mEnable) {
        ctx->batch_io = 1;
        ctx->server = server->server_fd;
    } else {
        ctx->batch_io = 0;
        ctx->server = ctx->client;
    }

    server->batch_max_count++;
    server->session_count++;

    return MPP_OK;
}

MPP_RET MppDevServer::detach(MppDevMppService *ctx)
{
    if (!mInited) {
        mpp_err("mpp server failed for %s\n", mServerError);
        return MPP_NOK;
    }

    MppClientType client_type = (MppClientType)ctx->client_type;

    MppDevBatServ *server = bat_server_get(client_type);
    MppDevSession *session = (MppDevSession *)ctx->serv_ctx;

    mpp_assert(server);

    AutoMutex auto_lock(server->lock);
    if (NULL == ctx->serv_ctx)
        return MPP_OK;

    ctx->server = ctx->client;
    ctx->serv_ctx = NULL;
    ctx->batch_io = 0;

    mpp_assert(server);
    mpp_assert(session);
    mpp_assert(session->client == ctx->client);
    mpp_assert(session->task_wait == session->task_done);
    mpp_assert(list_empty(&session->list_wait));

    list_del_init(&session->list_server);

    if (session->cond) {
        delete session->cond;
        session->cond = NULL;
    }

    mpp_mem_pool_put(mSessionPool, session);
    server->batch_max_count++;
    server->session_count++;

    return MPP_OK;
}

MPP_RET MppDevServer::check_status(void)
{
    if (!mInited) {
        mpp_err("mpp server failed for %s\n", mServerError);
        return MPP_NOK;
    }

    return MPP_OK;
}

MPP_RET mpp_server_attach(MppDev ctx)
{
    MppDevMppService *dev = (MppDevMppService *)ctx;

    return MppDevServer::get_inst()->attach(dev);
}

MPP_RET mpp_server_detach(MppDev ctx)
{
    MppDevMppService *dev = (MppDevMppService *)ctx;

    return MppDevServer::get_inst()->detach(dev);
}

MPP_RET mpp_server_send_task(MppDev ctx)
{
    MPP_RET ret = MppDevServer::get_inst()->check_status();
    if (!ret)
        ret = send_task((MppDevMppService *)ctx);

    return ret;
}

MPP_RET mpp_server_wait_task(MppDev ctx, RK_S64 timeout)
{
    MPP_RET ret = MppDevServer::get_inst()->check_status();
    if (!ret)
        ret = wait_task((MppDevMppService *)ctx, timeout);

    return ret;
}