#include "./interface/DecoderManager.h"
#include <mutex>
#include <thread>
#include <chrono>
#include "./interface/logger.hpp"

#include "./dvpp/VpcUtils.h"

#include <opencv2/opencv.hpp>

using namespace std;

struct decode_cbk_userdata{
  string task_id;
  void* opaque;
  void* opaque1;
};

deque<DeviceMemory*> m_RgbDataList;
mutex m_DataListMtx; 


bool m_bfinish{false};
int m_devId = 0;
const char* task_id = "test0";
int skip_frame_ = 5;
int m_batch_size = 20;

int reindex = 0;

void post_decod_cbk(const void * userPtr, DeviceMemory* devFrame){
    VpcUtils* pUtils = VpcUtils::getInstance(0);
    DeviceMemory* mem = pUtils->resize(dynamic_cast<DvppDataMemory*>(devFrame.get()), 640, 640);

    HostData* tmp_img = mem->memCpy2Host();
	cv::Mat cur_image(tmp_img->height, tmp_img->width, CV_8UC3, tmp_img->pData);
	string path = "./re/" +std::to_string(reindex) + ".jpg";
	cv::imwrite(path, cur_image);
	cur_image.release();
    delete tmp_img;
	tmp_img = nullptr;
    reindex++;
}

void decode_finished_cbk(const void * userPtr){
    decode_cbk_userdata* ptr = (decode_cbk_userdata*)userPtr;
    if (ptr!= nullptr){
        printf("task finished: %s \n", ptr->task_id.c_str());
        delete ptr;
        ptr = nullptr;
    }
}

bool create_task(string task_id) {
    
    // 创建解码任务
    DecoderManager* pDecManager = DecoderManager::getInstance();

    MgrDecConfig config;
    config.name = task_id;
    config.cfg.uri = "/data/share/data/Street.uvf";
    config.cfg.post_decoded_cbk = post_decod_cbk;
    config.cfg.decode_finished_cbk = decode_finished_cbk;
    config.cfg.force_tcp = true;  // rtsp用tcp
    config.cfg.gpuid = to_string(m_devId);
    config.cfg.skip_frame = skip_frame_;

    config.dec_type = DECODER_TYPE_DVPP;
    
    AbstractDecoder* dec = pDecManager->createDecoder(config);
    if (!dec){
        printf("创建解码器失败 \n");
        return false;
    }

    // decode_cbk_userdata* userPtr = new decode_cbk_userdata;
    // userPtr->task_id = string(task_id);
    // pDecManager->setPostDecArg(config.name, userPtr);
    // pDecManager->setFinishedDecArg(config.name, userPtr);

    dec->setSnapTimeInterval(1000);


    int input_image_width = 0;
    int input_image_height = 0;
    pDecManager->getResolution(config.name, input_image_width, input_image_height);

    pDecManager->startDecodeByName(config.name);
    // pDecManager->closeAllDecoder();

    return true;
}

int main(){

    set_default_logger(LogLevel(0), "test_decode","logs/main.log", 64 * 1024 * 1024, 64 * 1024 * 1024);
    LOG_INFO("编译时间：{} {}", __DATE__, __TIME__);

    printf("start... \n");

    DecoderManager* pDecManager = DecoderManager::getInstance();

    char ch = 'a';
    int task_id = 1;

    create_task(to_string(task_id));  
    task_id++;

    while (ch != 'q') {
        ch = getchar();
        switch (ch)
        {
        case '4':
            for (size_t i = 0; i < 4; i++) 
            {
                create_task(to_string(task_id));  
                task_id++;
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            break;
        case 'a':
                create_task(to_string(task_id));  
                task_id++;
                std::this_thread::sleep_for(std::chrono::seconds(1));
            break;
        case 'c':
            pDecManager->closeAllDecoder();
            break;
        default:
            break;
        }
    }
}