#ifndef __DVPP_DEVICE_MEMORY_H__
#define __DVPP_DEVICE_MEMORY_H__

#include <string.h>
#include <memory>
#include <vector>

#include "utiltools.hpp"

using namespace std;

struct AreaInfo {
    string task_id;              //该物体属于的任务ID号
    int task_frame_count;     //该物体当前出现的帧号
    int object_id;            //该物体的ID号
    int index;                //该物体所属类别的编号
    double confidence;        //该物体的置信度

    int left;                 //该物体位置的左坐标
    int top;                  //该物体位置的上坐标
    int right;                //该物体位置的右坐标
    int bottom;               //该物体位置的下坐标
};

struct HostData {
    unsigned char * pData {nullptr};
    int width{0};
    int width_stride{0};
    int height{0};
    int height_stride{0};
    int data_size{0};
    int channel{3};

    string id;

    HostData(int w, int w_s, int h, int h_s, int s, string _id) {
        width = w;
        width_stride = w_s;
        height = h;
        height_stride = h_s;
        data_size = s;
        id = _id;

        pData = (unsigned char *)malloc(data_size);
    }

    HostData(HostData* pSrc) {
        width = pSrc->width;
        width_stride = pSrc->width_stride;
        height = pSrc->height;
        height_stride = pSrc->height_stride;
        data_size = pSrc->data_size;
        id = pSrc->id;

        pData = (unsigned char *)malloc(data_size);
        memcpy(pData, pSrc->pData, data_size);
    }

    HostData* clone() {
        return new HostData(this);
    }

    ~HostData() {
        if(pData) {
            free(pData);
            pData = nullptr;
        }

        width = 0;
        width_stride = 0;
        height = 0;
        height_stride = 0;
        data_size = 0;
        channel = 0;
        id = "";
    }
};

// typedef shared_ptr<HostData> HostDataPtr;


class DeviceMemory {

public:
     DeviceMemory(int _channel, int _width, int _width_stride, int _height, int _height_stride, int _size, string _id, string _dev_id, bool _key_frame, unsigned long long _frame_nb, bool _isused){
        channel = _channel;
        width = _width;
        width_stride = _width_stride;
        height = _height;
        height_stride = _height_stride;
        data_size = _size;
        isused = _isused;
        id = _id;
        device_id = _dev_id;
        key_frame = _key_frame;
        frame_nb = _frame_nb;
        timestamp = UtilTools::get_cur_time_ms();
    }

    virtual ~DeviceMemory(){
        
    }

    virtual HostData* memCpy2Host() = 0;

    virtual DeviceMemory* clone() = 0;

    int getSize() {
        return data_size;
    }

    void setSize(int size) {
        data_size = size;
    }
    
    bool isIsused() {
        return isused;
    }

    void setIsused(bool _isused) {
        isused = _isused;
        // 更新时间戳
        timestamp = UtilTools::get_cur_time_ms();
    }

    string getId() {
        return id;
    }

    void setId(string _id) {
        id = _id;
    }

    string getDeviceId() {
        return device_id;
    }

    int getDeviceId_i() {
        return atoi(device_id.c_str());
    }

    void setDeviceId(string _device_id) {
        device_id = _device_id;
    }

    unsigned char* getMem(){
        return pHwRgb;
    }

    void setMem(unsigned char* _pHwRgb) {
        pHwRgb = _pHwRgb;
    }

    long long getTimesstamp(){
        return timestamp;
    }

    void setTimesstamp(long long _timestamp) {
        timestamp = _timestamp;
    }

    int getWidth(){
        return width;
    }

    void setWidth(int _width) {
        width = _width;
    }

    int getWidthStride(){
        return width_stride;
    }

    void setWidthStride(int _width_stride) {
        width_stride = _width_stride;
    }

    int getHeight(){
        return height;
    }

    void setHeight(int _height) {
        height = _height;
    }

    int getHeightStride(){
        return height_stride;
    }

    void setHeightStride(int _height_stride) {
        height_stride = _height_stride;
    }

    int getChannel(){
        return channel;
    }

    void setChannel(int _channel) {
        channel = _channel;
    }

    bool isKeyFrame(){
        return key_frame;
    }

    void setKeyFrame(bool _key_frame) {
        key_frame = _key_frame;
    }

    unsigned long long getFrameNb() {
        return frame_nb;
    }

    void setFrameNb(unsigned long long _frame_nb) {
        frame_nb = _frame_nb;
    }

    unsigned long long getDisplayFrameNb() {
        return display_frame_nb;
    }

    void setDisplayFrameNb(unsigned long long _display_frame_nb) {
        display_frame_nb = _display_frame_nb;
    }

public:
    int data_size;
    bool isused;
    string id;
    string device_id;
    unsigned char * pHwRgb{nullptr};
    long long timestamp;
    int width{0};
    int width_stride{0};
    int height{0};    
    int height_stride{0};
    int channel{3};
    bool key_frame;
    unsigned long long frame_nb;
    unsigned long long display_frame_nb;
};

// typedef std::shared_ptr<DeviceMemory> DeviceMemoryPtr;


#endif  // __DVPP_DEVICE_MEMORY_H__