//
// Created by ps on 19-4-9.
//

#include <basic/debug/Debug.h>
#include "VptDetectWrapper.h"

VptDetectWrapper::VptDetectWrapper() {
    init();
}

VptDetectWrapper::VptDetectWrapper(int _gpuIdx, string _dbFilePath) : m_gpuIdx(_gpuIdx),
                                                                      m_dbFilePath(_dbFilePath) {
    init();
}

VptDetectWrapper::~VptDetectWrapper() {
    vpt_pic_release(&m_handle);
}

void VptDetectWrapper::init() {
    m_param.mode = DEVICE_GPU;
    m_param.gpuid = m_gpuIdx;
    m_param.hp_recg_config = SY_CONFIG_OPEN;
    m_param.hcp_recg_config = SY_CONFIG_OPEN;
    m_param.vehicle_color_config = SY_CONFIG_OPEN;
    m_param.vehicle_recg_config = SY_CONFIG_OPEN;
    m_param.vehicle_pendant_det_recg_config = SY_CONFIG_OPEN;
    m_param.dbPath = const_cast<char *>(m_dbFilePath.data());
    m_param.log = SY_CONFIG_OPEN;
    vpt_pic_init(&m_handle, m_param);
}

list<VptDetectResults> VptDetectWrapper::process_image(cv::Mat &_img) {
    m_results.clear();

    sy_img img;
    img.set_data(_img.cols, _img.rows, _img.channels(), _img.data);

    vptpic_result result;
    result.info = new vptobj_info[MAX_DET_COUNT];

    int ret = vpt_pic_process(m_handle, img, &result);


    int size = result.count;
    for (int i = 0; i < size; i++) {

        char str_i[100];
        int colorIndex = result.info[i].obj_index;

        if (colorIndex < 0 || colorIndex >= 9)continue;
//        sprintf(str_i, "%s:%.2f", type[colorIndex].c_str(), result.info[i].obj_score);

//        rectangle(process_image,
//                  cvPoint(result.info[i].obj_rect.left_ - 5, result.info[i].obj_rect.top_ - 15),
//                  cvPoint(result.info[i].obj_rect.left_ + result.info[i].obj_rect.width_ + 5,
//                          result.info[i].obj_rect.top_ + result.info[i].obj_rect.height_ + 10),
//                  cv::Scalar(color[colorIndex][0], color[colorIndex][1], color[colorIndex][2]), 3, 1);
//
//        cv::putText(process_image, str_i,
//                    cv::Point(result.info[i].obj_rect.left_, result.info[i].obj_rect.top_),
//                    fontFace, fontScale,
//                    cv::Scalar(color[colorIndex][0], color[colorIndex][1], color[colorIndex][2]), thickness, 8);

        //输出二次属性分析结果
        if (result.info[i].analysis_res != NULL) {
            m_results.emplace_back(std::move(changeAnalysisRes(colorIndex, result.info[i].analysis_res)));
            m_results.back().bskRect.setRect(result.info[i].obj_rect.left_, result.info[i].obj_rect.top_,
                                             result.info[i].obj_rect.width_, result.info[i].obj_rect.height_);
        } else {}
    }
    //release source
    if (result.info != NULL) {
        for (int i = 0; i < MAX_DET_COUNT; i++) {
            if (result.info[i].analysis_res != NULL) {
                delete result.info[i].analysis_res;
                result.info[i].analysis_res = NULL;
            }
        }
        delete[] result.info;
        result.info = NULL;
    }
    DBG(m_results.size());
    return m_results;
}

VptDetectResults VptDetectWrapper::changeAnalysisRes(int index, void *result) {

    VptDetectResults vptDetectResults(index);
    vptDetectResults.sdkDetectType = static_cast<SDKDetectType>(index);
//    vptDetectResults.vptDetectRes.carDetectRes;
    switch (vptDetectResults.sdkDetectType) {
        case SDKDetectType::person : {
            hp_res *cur_res = (hp_res *) result;
            memcpy(vptDetectResults.vptDetectRes.personDetectRes.res_objs, cur_res->res_objs,
                   sizeof(classfy_boj_res) * HP_FIR_INDEX_SIZE);
            //test code
            for (int i = 0; i < HP_FIR_INDEX_SIZE; i++) {
                int resIndex = vptDetectResults.vptDetectRes.personDetectRes.res_objs[i].res_index;
                cout << vptDetectResults.vptDetectRes.personDetectRes.res_objs[i].res_prob << "  ";
                cout << HpResStr[i][resIndex] << " ";
            }
            //test code end
        };
            break;
        case SDKDetectType::bike:
        case SDKDetectType::motor : {
            hcp_res *cur_res = (hcp_res *) result;
            memcpy(vptDetectResults.vptDetectRes.perRideCarDetectRes.res_objs, cur_res->res_objs,
                   sizeof(classfy_boj_res) * HCP_FIR_INDEX_SIZE);
            //test code
            for (int i = 0; i < HCP_FIR_INDEX_SIZE; i++) {
                int resIndex = vptDetectResults.vptDetectRes.perRideCarDetectRes.res_objs[i].res_index;
                cout << vptDetectResults.vptDetectRes.perRideCarDetectRes.res_objs[i].res_prob << "  ";
                cout << HpResStr[i][resIndex] << " ";
            }
            cout << endl << endl;
            //test code
        };
            break;
        case SDKDetectType::car :
        case SDKDetectType::bigbus :
        case SDKDetectType::lorry :
        case SDKDetectType::midibus : {
            vehicle_res *cur_res = (vehicle_res *) result;
            auto &carRes = vptDetectResults.vptDetectRes.carDetectRes;

            // 车颜色
            carRes.colorLabel = static_cast<ColorLabel>(cur_res->vc_res.res_index);
            carRes.colorLabelProb = cur_res->vc_res.res_prob;

            // 车型识别
            if (cur_res->vr_res.vehicle_brand != NULL) {
                cout << "  车辆品牌 - " << cur_res->vr_res.vehicle_brand << endl;
                carRes.vehicle_brand = cur_res->vr_res.vehicle_brand;
//                carRes.vehicle_brand = string(cur_res->vr_res.vehicle_brand);
//                carRes.vehicle_brand = "发";
                delete[] cur_res->vr_res.vehicle_brand;
                cur_res->vr_res.vehicle_brand = NULL;
            }
            if (cur_res->vr_res.vehicle_subbrand != NULL) {
                cout << "  车辆子品牌 - " << cur_res->vr_res.vehicle_subbrand << endl;
                carRes.vehicle_subbrand = cur_res->vr_res.vehicle_subbrand;
//                carRes.vehicle_subbrand = cur_res->vr_res.vehicle_subbrand;
                delete[] cur_res->vr_res.vehicle_subbrand;
                cur_res->vr_res.vehicle_subbrand = NULL;
            }
            if (cur_res->vr_res.vehicle_issue_year != NULL) {
                cout << "  车辆年款 - " << cur_res->vr_res.vehicle_issue_year << endl;
                carRes.vehicle_issue_year = cur_res->vr_res.vehicle_issue_year;
                delete[] cur_res->vr_res.vehicle_issue_year;
                cur_res->vr_res.vehicle_issue_year = NULL;
            }
            if (cur_res->vr_res.vehicle_type != NULL) {
                cout << "  车辆类型 - " << cur_res->vr_res.vehicle_type << endl;
                carRes.vehicle_type = cur_res->vr_res.vehicle_type;
                delete[] cur_res->vr_res.vehicle_type;
                cur_res->vr_res.vehicle_type = NULL;
            }
            if (cur_res->vr_res.freight_ton != NULL) {
                cout << "  货车吨级 - " << cur_res->vr_res.freight_ton << endl;
                carRes.freight_ton = cur_res->vr_res.freight_ton;
                delete[] cur_res->vr_res.freight_ton;
                cur_res->vr_res.freight_ton = NULL;
            }
//            cout << " " << cur_res->vr_res.name_score << endl;
            carRes.vehicle_score = cur_res->vr_res.name_score;

            // 车牌
            if (cur_res->vp_res.rect.height_ != 0 && cur_res->vp_res.rect.width_ != 0) {
                cout << "车牌位置: " << cur_res->vp_res.rect.left_ << " " << cur_res->vp_res.rect.top_ << " "
                     << cur_res->vp_res.rect.width_ << " " << cur_res->vp_res.rect.height_ << endl;
                carRes.carPlateRect.setRect(cur_res->vp_res.rect.left_, cur_res->vp_res.rect.top_,
                                            cur_res->vp_res.rect.width_, cur_res->vp_res.rect.height_);
                carRes.carPlateRectScore = cur_res->vp_res.detectScore;
                std::string _carPlate;
                for (int m = 0; m < 7; m++) {
                    printf("%s", cur_res->vp_res.recg[m].character);
                    _carPlate.append(cur_res->vp_res.recg[m].character);
                }
                carRes.carPlate = const_cast<char *>(_carPlate.c_str());
                carRes.carPlateRectScore = cur_res->vp_res.numScore;
                carRes.carPlatetype = cur_res->vp_res.type;
//                printf(" numScore = %.2f, detectScore = %.2f\n", cur_res->vp_res.numScore, cur_res->vp_res.detectScore);
            }
        };
            break;
    }
    return vptDetectResults;
}