#pragma once
#include <deque>
#include <map>
#include <vector>
#include <memory>
#include "../util/vpc_util.h"
#include "../ai_platform/task_param_manager.h"
#include "../ai_platform/macro_definition.h"
#include "ai_engine_header.h"
// #include "human_car_parsing.h"
#include "motor_rainshed_cls.h"
#include "acl/acl.h"
#include "acl/ops/acl_dvpp.h"

#define MAX_BATCH 16
#define IMAGE_CROP_EXPAND_RATIO 0
#define MAX_OBJ_BOX_COUNT 100

namespace ai_engine_module
{
    namespace motocycle_refit_process
    {
        // typedef long id_t;
        using id_t = obj_key_t;
        using task_id_t = std::string;
        using algor_param_type = algor_config_param_manned_incident*;

        enum class label_t {
            PLACEHOLDER = -1,
            norefit = 1, //无雨棚
            refit = 0,   //有雨棚
        };

        typedef struct input_data_wrap_t
        {
            id_t id;
            long objId;
            std::string taskId;
            box_t box;
        } input_data_wrap_t;


        typedef struct mn_frame_t
        {
            uint m_frame;
            uint n_frame;

            // explicit
            mn_frame_t(uint m = 0, uint n = 0)
                : m_frame(m)
                , n_frame(n)
            {}

            void reset()
            {
                m_frame = 0;
                n_frame = 0;
            }

        } mn_frame_t;


        typedef struct results_data_t 
        {
            box_t box;
            acldvppPicDesc* origin_img_desc{nullptr};
            acldvppPicDesc* roi_img_desc{nullptr};
            id_t id;
            long objId;
            std::string taskId;
            algorithm_type_t algor_type;
        } results_data_t;

        class MotorRefitProcess
        {
            /**
             * @brief
             *  1. move able
             */
        public:
            MotorRefitProcess();

            ~MotorRefitProcess();

            bool check_initied();
            bool init(int gpu_id, string models_dir);
            bool update_mstreams(const std::vector<task_id_t>& taskIds, vector<DeviceMemory*> vec_det_input_images, const std::vector<onelevel_det_result> &det_results); 
            std::shared_ptr<results_data_t> get_result_by_objectid(const id_t& id, bool do_erase = true);

            void force_release_result(const task_id_t& task_id);

            MotorRefitProcess(const MotorRefitProcess&) = delete;
            MotorRefitProcess& operator=(const MotorRefitProcess&) = delete;

        private:
            static algorithm_type_t algor_type_;
            int m_devId; 
            aclrtContext m_algorthim_ctx;

            bool init_;
            void* tools_;
            task_param_manager* task_param_manager_;
            std::map<id_t, mn_frame_t> id_to_mn_;
            std::map<id_t, results_data_t> id_to_result_;
        };
    }  // namespace motocycle_refit_process
} // namespace ai_engine_module