#include <iostream>
#include <string>
#include <queue>
#include <mutex>
#include <chrono>
#include <thread>

#include "vpt.h"

#include "acl/acl.h"
#include "acl/ops/acl_dvpp.h"

#include "../decoder/interface/DecoderManager.h"
#include "../decoder/interface/utiltools.hpp"

using namespace std;

#define ACL_CALL(ret, expect, errCode)\
    do {\
        if (ret != expect) {\
            if (errCode == 0)\
                return ret;\
            else\
                return errCode;\
        }\
    } while(0)


string test_uri = "/home/huchunming/data/caishenkezhan.mp4";

queue<DeviceMemory*> memQueue;
mutex mem_mutex;

static void postDecoded(const void * userPtr, DeviceMemory* devFrame){
    AbstractDecoder* decoder = (AbstractDecoder*)userPtr;
    if (decoder!= nullptr)
    {
    }

    std::lock_guard<std::mutex> l(mem_mutex);
    memQueue.push(devFrame);

    // if(devFrame){
    //     delete devFrame;
    //     devFrame = nullptr;
    // }
}

static void decode_finished_cbk(const void* userPtr){
    cout << "当前时间戳: " << UtilTools::get_cur_time_ms() << endl;
}

static void createDvppDecoder(int index, char* devId){
    DecoderManager* pDecManager = DecoderManager::getInstance();
    MgrDecConfig config;
    config.name = "dec" + to_string(index);
    config.cfg.uri = test_uri;
    config.cfg.post_decoded_cbk = postDecoded;
    config.cfg.decode_finished_cbk = decode_finished_cbk;
    config.cfg.force_tcp = true;
    config.dec_type = DECODER_TYPE_DVPP;

    config.cfg.gpuid = devId;
    
    AbstractDecoder* decoder = pDecManager->createDecoder(config);
    if (!decoder)
    {
        cout << "创建解码器失败" << endl;
        return ;
    }
    pDecManager->setPostDecArg(config.name, decoder);
    pDecManager->setFinishedDecArg(config.name, decoder);
    pDecManager->startDecodeByName(config.name);
}


int main(){
    cout << vpt_get_version() << endl;
    
    vpt_param param;

    // param.modelNames = "vtp0716x.om";
    param.modelNames = "../models/vpt0715_310p.om";
    param.threshold = 0.4;
    param.devId = 0;
    param.isTrk = false;

    ACL_CALL(aclInit(nullptr), ACL_ERROR_NONE, 1);
    ACL_CALL(aclrtSetDevice(param.devId), ACL_ERROR_NONE, 1);
    aclrtContext ctx;
    ACL_CALL(aclrtCreateContext(&ctx, param.devId), ACL_ERROR_NONE, 1);

    void* handle = nullptr;
    int ret = vpt_init(&handle, param);
    if(ret != 0){
        printf("init error \n");
        return -1;
    }

    createDvppDecoder(0,"0");

    DecoderManager* pDecManager = DecoderManager::getInstance();
    const int batchsize = 1;
    int index = 0;
    while (pDecManager->isRunning("dec0"))
    {
        if(index > 30){
            break;
        }
        if(memQueue.size() <= 0){
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            continue;
        }
        
        vector<DeviceMemory*> vec_mem;

        vector<sy_img> imgs;

        std::lock_guard<std::mutex> l(mem_mutex);
        for (int b = 0; b < batchsize; b++) {
            DeviceMemory* mem = memQueue.front();
            sy_img img;
            img.w_ = mem->getWidth();
            img.h_ = mem->getHeight();
            img.data_ = mem->getMem();
            imgs.push_back(img);
            vec_mem.push_back(mem);
            memQueue.pop();
        }

        if(vec_mem.size() <= 0){
            std::this_thread::sleep_for(std::chrono::milliseconds(3));
            continue;
        }

        ACL_CALL(aclrtSetCurrentContext(ctx), ACL_ERROR_NONE, 1);
        vpt_result* results; 
        int ret = vpt_batch(handle, imgs.data(), imgs.size(), &results);

        for(int batchIdx = 0; batchIdx < batchsize; batchIdx ++){
            printf("debug det num:%d\n",results[batchIdx].obj_count_); 
        }

        for(int i=0;i < vec_mem.size(); i++){
            DeviceMemory* mem = vec_mem[i];
            delete mem;
            mem = nullptr;
        }
        vec_mem.clear();

        index ++;
    }

    pDecManager->closeDecoderByName("dec0");

    pDecManager->closeAllDecoder();

    ret = aclrtDestroyContext(ctx);
    if(ret != ACL_ERROR_NONE){
        printf("aclrtDestroyContext failed ! \n");
    }

    
    
    aclFinalize();
}