#ifndef __SMARTVISION_EXAMPLE__
#define __SMARTVISION_EXAMPLE__

#include <iostream>
#include <string>
#include <opencv2/opencv.hpp>
#include <aidlite.hpp>
#include "AIObjectDet.hpp"

enum AI_Model_Type_
{
    AI_Model_Type_Ocr,
    AI_Model_Type_Object,
    AI_Model_Type_Align,
    AI_Model_Type_Seg,
    AI_Model_Type_Reconstruct,
    AI_Model_Type_EdgeAngle,
    AI_Model_Type_Count,
};
enum AI_MODEL_TYPE_
{
    AI_MODEL_TYPE_CPU,
    AI_MODEL_TYPE_INT8,
    AI_MODEL_TYPE_FLOAT32,
    AI_MODEL_TYPE_FLOAT16,
};
enum AI_DATA_IDX_
{
    AI_DATA_IDX_T,
    AI_DATA_IDX_HEIGHT,
    AI_DATA_IDX_WIDTH,
    AI_DATA_IDX_CHANNELS,
    AI_DATA_IDX_COUNT,
};
struct AI_ConfigInfo
{
    std::string strdetect_model_path;             // 模型路径
    int ai_Model_Type;                            // 模型使用类型      AI_MODEL_TYPE_
    bool useMean_Div;                             // 是否要做均值方差处理
    std::string strName_Out;                      // 模型输出名称
    unsigned int dataArr_In[AI_DATA_IDX_COUNT];   // 输入 数据尺寸大小
    unsigned int dataArr_Out[AI_DATA_IDX_COUNT];  // 输出 数据尺寸大小
    unsigned int dataArr_Out1[AI_DATA_IDX_COUNT]; // 输出 数据尺寸大小
    cv::Scalar means_scale;                       // 均值
    cv::Scalar stds_scale;                        // 方差
    int outImgChannlse;                           // 输出图片的通道数，如果是单通道，就 只取第一通道的图片，如果是多通道，就全取所有输出通道
    float fmaskThreshold;                         // mask 输出的阈值
    int userflag;
    AI_ConfigInfo()
    {
        strdetect_model_path = "";
        ai_Model_Type = AI_MODEL_TYPE_FLOAT16;
        useMean_Div = true;
        strName_Out = "";
        dataArr_In[AI_DATA_IDX_T] = 1;
        dataArr_In[AI_DATA_IDX_HEIGHT] = 480;
        dataArr_In[AI_DATA_IDX_WIDTH] = 480;
        dataArr_In[AI_DATA_IDX_COUNT] = 3;

        dataArr_Out[AI_DATA_IDX_T] = 1;
        dataArr_Out[AI_DATA_IDX_HEIGHT] = 480;
        dataArr_Out[AI_DATA_IDX_WIDTH] = 480;
        dataArr_Out[AI_DATA_IDX_COUNT] = 4;

        means_scale = cv::Scalar(0.485, 0.456, 0.406);
        stds_scale = cv::Scalar(0.229, 0.224, 0.225);
        outImgChannlse = 1;
        fmaskThreshold = 0.5f;
        userflag = 0;
    }
    void copy(AI_ConfigInfo tem)
    {
        this->strdetect_model_path = tem.strdetect_model_path;
        this->ai_Model_Type = tem.ai_Model_Type;
        this->useMean_Div = tem.useMean_Div;
        this->strName_Out = tem.strName_Out;
        for (int i = 0; i < AI_DATA_IDX_COUNT; i++)
        {
            this->dataArr_In[i] = tem.dataArr_In[i];
            this->dataArr_Out[i] = tem.dataArr_Out[i];
        }

        this->means_scale = tem.means_scale;
        this->stds_scale = tem.stds_scale;
        this->outImgChannlse = tem.outImgChannlse;
        this->fmaskThreshold = tem.fmaskThreshold;
        this->userflag = tem.userflag;
    }
};

struct ObjectInfo
{
    cv::Rect roi;
    int classIdx;
    float fscore;
};

class DetectModel
{

public:
    DetectModel();
    ~DetectModel();

    int init(AI_ConfigInfo AIconfig);
    int init_reconstruct(AI_ConfigInfo AIconfig);
    int init_Object(AI_ConfigInfo AIconfig);
    void release();
    int run(const cv::Mat &frame, cv::Mat &maskimg, bool bmeandv);
    int run_Arr_One_Out(const cv::Mat &frame, cv::Mat &maskimg, int imgidx, bool bmeandv, float fT = 0.5);
    int run_arrOut(const cv::Mat &frame, std::vector<cv::Mat> &mask, bool bmeandv, float fT = 0.5);
    int run_Object(const cv::Mat &frame, std::vector<ObjectInfo> &outList, bool bmeandv, float fT = 0.5);
    int run_reconstruct(const cv::Mat &frame,  cv::Mat & reconstructimg, bool bmeandv);

private:
    int Img_Mean_Div(cv::Mat srcimg, cv::Mat &outimg);
    int UpdataObjectParam(int size);

private:
    std::unique_ptr<Aidlux::Aidlite::Interpreter> detect_interpreter;

    uint8_t *m_DetectOutput;

    AI_ConfigInfo m_AIconfig;

    AIObjectDet m_Objectdet;
    // Object
private:
    int MODEL_SIZE;
    int OBJ_NUMB_MAX_SIZE;
    uint32_t STRIDE8_SIZE;
    uint32_t STRIDE16_SIZE;
    uint32_t STRIDE32_SIZE;
};

#endif