#ifndef _PL_BlockGrouping_H_
#define _PL_BlockGrouping_H_

#include "PipeLine.h"
#include "MaterialBuffer.h"
#include "GraphicHelper.h"

#include <vector>
#include <list>

typedef bool (*user_test_grouping_func_t)();

typedef float (*user_score_func_t)(const MB_Frame* ptr_frame, const PLGH_Rect& rects, uint8_t* croppedData);

#define PLBG_MAX_CACHE_FRAMES 10//#todo
#define PLBG_MAX_GROUPS 10

struct RectWrapper
{
    PLGH_Rect rect;
    float user_score_1;
	void* userData;

	typedef void (*user_data_deleter_func_t)(RectWrapper& rw);
	user_data_deleter_func_t user_data_deleter;

	RectWrapper() :
            rect(), user_score_1(0.0f), userData(nullptr), user_data_deleter(nullptr)
    { }
};

typedef void (*plbg_get_rect_func_t)(const PipeMaterial& ptr_pm, const MB_Frame& data_frame, std::list<RectWrapper>& rects);

struct PLBG_Output
{
	uint16_t groupID;
	uint16_t blockID;
    RectWrapper rectInOriginFrame;
	MB_Frame* originframe;
	float score;
	uint8_t* croppedData;
	size_t croppedDataSize;
	
	PLBG_Output() : 
		groupID(0), blockID(0), 
		rectInOriginFrame(), originframe(nullptr), 
		score(0.0f), croppedData(nullptr), croppedDataSize(0)
	{
	}
};

typedef std::vector<PLBG_Output> plbg_output_vec_t;

struct PL_BlockGrouping_Config
{
	bool copyData;

	int precfg_fps;
	int precfg_interval;
	int precfg_delay;

	plbg_get_rect_func_t get_rect_func;
	
	int group_size_min; // group内数量需要产生输出，但数量小于group_size_min时，丢弃组
	int group_size_max; // 一组block的数量，当测试组中累积block数量大于等于group_size_max时，产生输出
	int frame_count_max; // 对于一组block，当输入帧数量大于此值时，产生输出
	int group_top_n; // 对于不容忍的变化，组内产生group_top_n个输出
	
	// tolerance for grouping

	int block_center_x_diff; // block中心X容忍的移动距离
	int block_center_y_diff; // block中心Y容忍的移动距离
	
	int block_area_diff; // block面积容忍的变化
	
	int continuity_max; // 输入连续性的最大间隔
	
	int accept_blocks_max_per_frame; // 每帧每组接受的最大block数量

    user_test_grouping_func_t user_test_group_accept_rect;

	// scoring
	// user_score_rate = 1 - canny_focus - histogram_uniformy;
	// score = canny_focus * canny(image) + 
	//         histogram_uniformy * histogram(image) + 
	//         user_score_rate * user_score_func(image)
	
	float canny_focus; // 对焦度（模糊度）评分所占比例，返回0~1.0得分（边缘锐度）
	float histogram_uniformy; // 直方图幅度????
    float user_score_1_rate;
	user_score_func_t user_score_2_func; // 用户评分函数评分，返回0~1.0得分

	PL_BlockGrouping_Config() : 
		//copyData(false),
		//get_rect_func(nullptr),
		//group_size_max(10), frame_count_max(10), group_top_n(2),
		//block_center_x_diff(5), block_center_y_diff(5),
		//block_area_diff(500), continuity_max(2), accept_blocks_max_per_frame(1),
		//canny_focus(0.4), histogram_uniformy(0.0), user_score_func(nullptr)

    // camera 640x480,fps=30,dist=1(meter),interval=25
        //copyData(false),
        //get_rect_func(nullptr),
        //group_size_min(2), group_size_max(20), frame_count_max(fps * 6), group_top_n(1),
        //block_center_x_diff(100), block_center_y_diff(100),
        //block_area_diff(20000), continuity_max(2.0 * rect_interval), accept_blocks_max_per_frame(1), user_test_group_accept_rect(),
        //canny_focus(0.3), user_score_1_rate(0.4), histogram_uniformy(0.0), user_score_2_func(nullptr)

    // dahua 1920x1080,fps=25,dist=3,i=10
		precfg_fps(25), precfg_interval(2), precfg_delay(4),
        copyData(false),
        get_rect_func(nullptr),
        group_size_min(1 + precfg_interval), group_size_max(2 * (precfg_fps * precfg_delay) / precfg_interval), frame_count_max(precfg_fps * precfg_delay), group_top_n(1),
        block_center_x_diff(100), block_center_y_diff(100),
        block_area_diff(20000), continuity_max(8.0 * precfg_interval), accept_blocks_max_per_frame(1), user_test_group_accept_rect(),
        canny_focus(0.3), user_score_1_rate(0.4), histogram_uniformy(0.0), user_score_2_func(nullptr)
	{ }
};

class PL_BlockGrouping : public PipeLineElem
{
public:
	PL_BlockGrouping();
	virtual ~PL_BlockGrouping();

	virtual bool init(void* args);
	virtual void finit();

	virtual bool pay(const PipeMaterial& pm);
	virtual bool gain(PipeMaterial& pm);
	
private:
	static bool pay_breaker_MBFT_YUV(const PipeMaterial* pm, void* args);
	
private:
	void* internal;
};

PipeLineElem* create_PL_BlockGrouping();

#endif