#include <iostream>
#include <sstream>
#include <fstream>
#include "vpt.h"
#include "opencv2/opencv.hpp"
#include "opencv2/imgcodecs/legacy/constants_c.h"
#include "opencv2/imgproc/types_c.h"
#include "time.h"
#include "sys/time.h"
#include "sy_errorinfo.h"
#include "utils.h"

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

#include "muxer.h"

#include <chrono>
#include <dirent.h>

using namespace std;
using namespace cv;


sy_img data_cv2dvpp(Mat image) {
    int data_size = image.cols * image.rows * 3;

    sy_img device_data;

    unsigned char * pHwRgb{nullptr};
    int ret = acldvppMalloc((void **)&pHwRgb, data_size);
    if(ret != ACL_ERROR_NONE){
        cout << "acldvppMalloc failed" << endl;
        return device_data;
    }

    ret = aclrtMemcpy(pHwRgb, data_size, image.data, data_size, ACL_MEMCPY_HOST_TO_DEVICE);
    if(ret != ACL_ERROR_NONE){
        acldvppFree(pHwRgb);
        cout << "aclrtMemcpy failed" << endl;
        return device_data;
    }

    // device_data.c_ = image.dims;
    device_data.c_ = 3;
    device_data.w_ = image.cols;
    device_data.h_ = image.rows;
    device_data.data_ = pHwRgb;

    return device_data;
}

int main() {
    vpt_param param;
    param.modelNames_b = "./models/vpt/vpt230323_b16_bgr_310p.om";
    param.threshold = 0.35;
    param.devId = 0;
    param.max_batch = 16;
    param.isTrk = false;


    void* handle = nullptr;
    cout << "init start " << endl;
    ACL_CALL(aclInit(nullptr), ACL_SUCCESS, SY_FAILED);
    ACL_CALL(aclrtSetDevice(param.devId), ACL_SUCCESS, SY_FAILED);
    aclrtContext ctx;
    ACL_CALL(aclrtCreateContext(&ctx, param.devId), ACL_SUCCESS, SY_FAILED);

    int ret = vpt_init(&handle, param);
    if (ret == 0) {
        cout << "init success " << endl;

        cv::VideoCapture capture;
        capture.open("/home/cmhu/data/task33.avi");
        if(!capture.isOpened())
        {
            std::cerr << "Couldn't open capture."<< std::endl;
            return-1;
        }

        double fps = capture.get( cv::CAP_PROP_FPS );

        int b = 0;
        int batchsize = 8;
        vector<sy_img> vec_img;
        vector<cv::Mat> vec_mat;

        cv::Mat bgrImg;
        capture >> bgrImg;

        muxer encoder;
        encoder.init(bgrImg.cols, bgrImg.rows, fps, 4992000, "./vpt.mp4");
        
        for(;;){
            if(b < batchsize) {
                
                capture >> bgrImg;
                if(bgrImg.empty()) break;

                vec_mat.push_back(bgrImg);

                sy_img img = data_cv2dvpp(bgrImg);
                vec_img.push_back(img);

                b ++;  
            }

            if(b == batchsize) {
                b = 0;
                vpt_result results_b[batchsize];
                for (int b = 0; b < batchsize; b++) {
                    results_b[b].obj_results_ = new vpt_obj_result[MAX_DET_COUNT];
                }

                ret = vpt_batchV2(handle, vec_img.data(), batchsize, results_b);

                //draw 
                for(int batchIdx = 0; batchIdx < batchsize; batchIdx ++) {

                    printf("debug det_b num:%d\n",results_b[batchIdx].obj_count_);
                    Mat cvImg = vec_mat[batchIdx];
                    for (int i = 0; i < results_b[batchIdx].obj_count_; i++) {
                        Point lt(results_b[batchIdx].obj_results_[i].obj_rect.left_, results_b[batchIdx].obj_results_[i].obj_rect.top_);
                        Point rb((results_b[batchIdx].obj_results_[i].obj_rect.left_ + 
                        results_b[batchIdx].obj_results_[i].obj_rect.width_), (results_b[batchIdx].obj_results_[i].obj_rect.top_ + 
                        results_b[batchIdx].obj_results_[i].obj_rect.height_));
                        rectangle(cvImg, lt, rb, cv::Scalar(0, 0, 255), 4);

                        char buffer[50];
                        int fontface = cv::FONT_HERSHEY_SIMPLEX;
                        double scale = 0.8;
                        int thickness = 2;
                        int baseline = 0;
                        snprintf(buffer, sizeof(buffer), "%d:%.2f", results_b[batchIdx].obj_results_[i].obj_index,results_b[batchIdx].obj_results_[i].obj_score);
                        cv::Size text = cv::getTextSize(buffer, fontface, scale, thickness, &baseline);
                        cv::putText(cvImg, buffer, lt - cv::Point(0, baseline), fontface,
                                scale, cv::Scalar(0, 0, 255), thickness, 4);

                    }
                    encoder.write_image(cvImg.data);

                }

                for (int i = 0; i < batchsize; i++) {
                    delete [] results_b[i].obj_results_;
                    acldvppFree(vec_img[i].data_);
                }
                vec_img.clear();
            }
        }

        encoder.close();

    }
}

int main0() {
    cout << vpt_get_version() << endl;
    
    vpt_param param;
    param.modelNames_b = "./models/vpt/vpt230323_b16_bgr_310p.om";
    param.threshold = 0.35;
    param.devId = 0;
    param.max_batch = 16;
    param.isTrk = false;


    void* handle = nullptr;
    cout << "init start " << endl;
    ACL_CALL(aclInit(nullptr), ACL_SUCCESS, SY_FAILED);
    ACL_CALL(aclrtSetDevice(param.devId), ACL_SUCCESS, SY_FAILED);
    aclrtContext ctx;
    ACL_CALL(aclrtCreateContext(&ctx, param.devId), ACL_SUCCESS, SY_FAILED);
    // aclrtStream stream = nullptr;
	// ACL_CALL(aclrtCreateStream(&stream), ACL_SUCCESS, SY_FAILED);
    // DvppProcess* dvpp = new DvppProcess();
	// dvpp->InitResource(stream);
    int ret = vpt_init(&handle, param);
    if (ret == 0) {
        cout << "init success " << endl;
        
        const int batchsize = 2;
        sy_img imgs[batchsize];
        vector<sy_img> vec_img;

        int b = 0, repeat_num = 0;
        const char*  img_file_path="imgs/";

        std::vector<std::string> fileList;

        getAllNm(img_file_path,fileList);
        if (fileList.empty()) throw std::logic_error("No suitable images were found");
        for (auto & file : fileList) {
            string filename = img_file_path + file;
            cout << "img path: " << filename << endl;
            
            //debug====================================================================        
            if(b < batchsize) {
                Mat cvImg = imread(filename.c_str());

                uint32_t alignWidth = (cvImg.cols + 15) / 16 * 16 * 3;
                uint32_t alignHeight = (cvImg.rows + 1) / 2 * 2;
                uint32_t size = alignWidth * alignHeight;
                // cout << cvImg.cols << " " << cvImg.rows << " " << alignWidth << " " << alignHeight << " " << size << endl;
                resize(cvImg, cvImg, cv::Size((cvImg.cols + 15) / 16 * 16, alignHeight));
                sy_img img = data_cv2dvpp(cvImg);
                vec_img.push_back(img);

                b ++;  
            }
            if(b == batchsize) {
                b = 0;
                // vpt_result results_b[batchsize];
                vpt_result * results_b = new vpt_result[batchsize];
                for (int b = 0; b < batchsize; b++) {
                    results_b[b].obj_results_ = new vpt_obj_result[MAX_DET_COUNT];
                }

                double t1,t2;

                t1 = msecond();
                ret = vpt_batchV2(handle, vec_img.data(), batchsize, results_b);
                t2 = msecond();
                printf("debug mean batch process time: %.2f\n", (t2 - t1)/batchsize);
                //debug end======================================================

                //draw 
                for(int batchIdx = 0; batchIdx < batchsize; batchIdx ++) {

                    printf("debug det_b num:%d\n",results_b[batchIdx].obj_count_);
                    string filename = img_file_path + fileList[batchIdx + batchsize*repeat_num];
                    Mat cvImg = imread(filename.c_str());
                    for (int i = 0; i < results_b[batchIdx].obj_count_; i++) {
                        Point lt(results_b[batchIdx].obj_results_[i].obj_rect.left_, results_b[batchIdx].obj_results_[i].obj_rect.top_);
                        Point rb((results_b[batchIdx].obj_results_[i].obj_rect.left_ + 
                        results_b[batchIdx].obj_results_[i].obj_rect.width_), (results_b[batchIdx].obj_results_[i].obj_rect.top_ + 
                        results_b[batchIdx].obj_results_[i].obj_rect.height_));
                        rectangle(cvImg, lt, rb, cv::Scalar(0, 0, 255), 4);

                        char buffer[50];
                        int fontface = cv::FONT_HERSHEY_SIMPLEX;
                        double scale = 0.8;
                        int thickness = 2;
                        int baseline = 0;
                        snprintf(buffer, sizeof(buffer), "%d:%.2f", results_b[batchIdx].obj_results_[i].obj_index,results_b[batchIdx].obj_results_[i].obj_score);
                        cv::Size text = cv::getTextSize(buffer, fontface, scale, thickness, &baseline);
                        cv::putText(cvImg, buffer, lt - cv::Point(0, baseline), fontface,
                                scale, cv::Scalar(0, 0, 255), thickness, 4);
                    }

                    string jpgSaveName = "result/" + fileList[batchIdx + batchsize*repeat_num];
                    cv::imwrite(jpgSaveName, cvImg);
                }

                for (int i = 0; i < batchsize; i++) {
                    delete [] results_b[i].obj_results_;
                    acldvppFree(vec_img[i].data_);
                }
                vec_img.clear();
                delete [] results_b;
                repeat_num += 1;
            }
        }  
    }

    vpt_release(&handle);
    aclrtDestroyContext(ctx);
    aclrtResetDevice(param.devId);
    aclFinalize();
    

    return 0;
}