/***************************************************************************************
 *
 * video.cc is part of SimpleSkyCam.
 *
 *****************************************************************************************/

#include <list>
#include <string>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "gui.h"
#include "video.h"
#include "filter.h"
#include "detect.h"
#include "configuration.h"

VideoDev videodev;
GtkWidget *video_da = NULL;
GdkPixbuf *video_pixbuf = NULL;
extern GtkBuilder *_builder_;			// work around for threads
extern Detect detect;
extern int video_enterdata;
extern position_2d video_enterdata_pos;
extern detect_movement detectedpos_data;
extern Configuration config;

gboolean videoctrl_update(gpointer data) {
	GtkWidget *grid = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "vidctrl-grid"));
	GtkWidget *scale = NULL;
	GtkWidget *entry = NULL;
	GtkWidget *label = NULL;

	int value;
	int min;
	int max;
	int i;

	for (i = 0; (label = gtk_grid_get_child_at(GTK_GRID(grid), 0, i)) != NULL; i++) {
		if (videodev.GetCtrlMinMaxValue(gtk_label_get_text(GTK_LABEL(label)), &min, &max, &value) == VDEV_STATUS_OK) {
			scale = gtk_grid_get_child_at(GTK_GRID(grid), 1, i);
			if (!gtk_widget_has_focus(scale))
				gtk_range_set_value(GTK_RANGE(scale), value);
			entry = gtk_grid_get_child_at(GTK_GRID(grid), 2, i);
			if (!gtk_widget_has_focus(entry))
				gtk_entry_set_text(GTK_ENTRY(entry), std::to_string(value).c_str());
		}
	}

	return TRUE;
}


void videoframe_to_pixbuf(GdkPixbuf* dest, VideoFrame *src) {
	int destw, desth;
	unsigned char *destpixel;

	if (dest == NULL || src == NULL) return;

	desth = gdk_pixbuf_get_height(dest);
	destw = gdk_pixbuf_get_width(dest);
	destpixel = gdk_pixbuf_get_pixels(dest);

	if (destw * desth < src->h * src->w) {
		destw = src->w;
		desth = src->h;
	}

	memcpy (destpixel, src->data, 3*destw*desth);
}


#define S_X(_x_) (((_x_) * clientw / pixbufw))
#define S_Y(_y_) (((_y_) * clienth / pixbufh))
void cb_videoda_draw(GtkWidget *area, cairo_t *cr, int w, int h, gpointer data) {
	int clientw, clienth, pixbufw, pixbufh;
	float clientar, pixbufar;
	GdkPixbuf *pixbuf = NULL;
	char txt1[255];
	char txt2[255];

	GdkRGBA color;
	GtkWidget *e_x = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "detect-entry-posx"));
	GtkWidget *e_y = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "detect-entry-posy"));
	GtkWidget *e_w = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "detect-entry-w"));
	GtkWidget *e_h = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "detect-entry-h"));
	int x, y, w1, h1;

	if (video_da == NULL) return;

	clienth = gtk_widget_get_allocated_height(video_da);
	clientw = gtk_widget_get_allocated_width(video_da);
	clientar = (float)clientw/(float)clienth;
	pixbufh = gdk_pixbuf_get_height(video_pixbuf);
	pixbufw = gdk_pixbuf_get_width(video_pixbuf);
	pixbufar = (float)pixbufw/(float)pixbufh;

	if (pixbufar < clientar) {
		clientw = (pixbufar * (float) clienth);
	}
	else {
		clienth = ((float) clientw / pixbufar);
	}

	pixbuf = gdk_pixbuf_scale_simple (video_pixbuf, clientw, clienth, GDK_INTERP_NEAREST);

    gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
    cairo_paint(cr);
    cairo_fill (cr);

    g_object_unref (pixbuf);

	//
	// need to draw the select new position cross
    if (video_enterdata == VID_ENTERDATA_POS) {
		color.blue = 1.0;
		color.red = 0.0;
		color.green = 1.0;
		color.alpha = 1.0;
		gdk_cairo_set_source_rgba(cr, &color);

		cairo_move_to(cr, S_X(video_enterdata_pos.x)-10, S_Y(video_enterdata_pos.y)-10);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)+10, S_Y(video_enterdata_pos.y)+10);
		cairo_move_to(cr, S_X(video_enterdata_pos.x)+10, S_Y(video_enterdata_pos.y)-10);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)-10, S_Y(video_enterdata_pos.y)+10);

		cairo_move_to(cr, S_X(video_enterdata_pos.x)-15, S_Y(video_enterdata_pos.y)-20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)-20, S_Y(video_enterdata_pos.y)-20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)-20, S_Y(video_enterdata_pos.y)-15);

		cairo_move_to(cr, S_X(video_enterdata_pos.x)+15, S_Y(video_enterdata_pos.y)-20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)+20, S_Y(video_enterdata_pos.y)-20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)+20, S_Y(video_enterdata_pos.y)-15);

		cairo_move_to(cr, S_X(video_enterdata_pos.x)-15, S_Y(video_enterdata_pos.y)+20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)-20, S_Y(video_enterdata_pos.y)+20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)-20, S_Y(video_enterdata_pos.y)+15);

		cairo_move_to(cr, S_X(video_enterdata_pos.x)+15, S_Y(video_enterdata_pos.y)+20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)+20, S_Y(video_enterdata_pos.y)+20);
		cairo_line_to(cr, S_X(video_enterdata_pos.x)+20, S_Y(video_enterdata_pos.y)+15);

		cairo_stroke(cr);
    }
    else {
		x = atoi (gtk_entry_get_text(GTK_ENTRY(e_x)));
		y = atoi (gtk_entry_get_text(GTK_ENTRY(e_y)));
		w1 = atoi (gtk_entry_get_text(GTK_ENTRY(e_w)));
		h1 = atoi (gtk_entry_get_text(GTK_ENTRY(e_h)));

		if (x >= (w1/2) && x < (pixbufw-w1/2)
				&& y >= (h1/2) && y < (pixbufh-h1/2)) {
			//
			// draw red cross
			cairo_set_line_width(cr, 1.0);
			color.blue = 0.0;
			color.red = 1.0;
			color.green = 0.0;
			color.alpha = 1.0;
			gdk_cairo_set_source_rgba(cr, &color);

			cairo_move_to(cr, S_X(x), S_Y(y)-10);
			cairo_line_to(cr, S_X(x), S_Y(y)+10);
			cairo_move_to(cr, S_X(x)-10, S_Y(y));
			cairo_line_to(cr, S_X(x)+10, S_Y(y));
			cairo_stroke(cr);

			//
			// green width border
			color.blue = 0.0;
			color.red = 0.0;
			color.green = 1.0;
			color.alpha = 1.0;
			gdk_cairo_set_source_rgba(cr, &color);

			cairo_move_to(cr, S_X(x-w1/2), S_Y(y-h1/2)+10);
			cairo_line_to(cr, S_X(x-w1/2), S_Y(y-h1/2));
			cairo_line_to(cr, S_X(x+w1/2), S_Y(y-h1/2));
			cairo_line_to(cr, S_X(x+w1/2), S_Y(y-h1/2)+10);

			cairo_move_to(cr, S_X(x-w1/2), S_Y(y+h1/2)-10);
			cairo_line_to(cr, S_X(x-w1/2), S_Y(y+h1/2));
			cairo_line_to(cr, S_X(x+w1/2), S_Y(y+h1/2));
			cairo_line_to(cr, S_X(x+w1/2), S_Y(y+h1/2)-10);

			cairo_stroke(cr);
		}
	}

    // draw movement vector to screen
    snprintf (txt1, 255, "%f", detectedpos_data.dx);
    snprintf (txt2, 255, "%f", detectedpos_data.dy);
    for (int i = 0; i < 5; i++) {
    	int dx, dy;

    	switch (i) {
    	case 0:
        	cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
        	dx = -1;
        	dy = 0;
    		break;
    	case 1:
        	dx = +1;
        	dy = 0;
    		break;
    	case 2:
        	dx = 0;
        	dy = -1;
    		break;
    	case 3:
        	dx = 0;
        	dy = +1;
    		break;
    	case 4:
        	cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
        	dx = 0;
        	dy = 0;
    		break;
    	}

    	cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
    	cairo_set_font_size (cr, 12);
    	cairo_move_to (cr, 10+dx, 15+dy);
    	cairo_show_text(cr, txt1);
    	cairo_stroke(cr);
    	cairo_move_to (cr, 10+dx, 30+dy);
    	cairo_show_text(cr, txt2);
    	cairo_stroke(cr);
    }
};



/*
 * refresh the possible devices
 */
void cb_video_btnrefreshlist (GtkWidget *widget, gpointer data) {
	GtkWidget *cbox = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "cb-videodev"));
	GtkListStore *model = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(cbox)));

	std::list<std::string> devlist;
	std::list<std::string>::iterator iter;

	printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);

	if (model == NULL) {
		model = gtk_list_store_new(1, G_TYPE_STRING);
		gtk_combo_box_set_model(GTK_COMBO_BOX(cbox),GTK_TREE_MODEL(model));
	}

	gtk_list_store_clear(GTK_LIST_STORE(model));

	if (videodev.GetDeviceList(&devlist)) {
		for (iter = devlist.begin(); iter != devlist.end(); iter++) {
			gtk_list_store_insert_with_values(GTK_LIST_STORE(model), NULL, -1,
			                                      0, iter->c_str(),
			                                      -1);
		}
	}
};


/*
 * start recording from the videodev (will start a new thread)
 * load list of controls from the video device and create the GtkGrid
 * with all elements. Also connect the signals to the callback functions.
 */
void cb_video_btnrec (GtkWidget *widget, gpointer data) {
	std::list<std::string> list;
	std::list<std::string>::iterator iter;
	GtkWidget *cbox = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "cb-videodev"));
	GtkWidget *btnstart = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "btn-video-rec"));
	GtkWidget *btnstop = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "btn-video-stop"));
	GtkWidget *grid = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "vidctrl-grid"));
	GtkWidget *gridchild = NULL;
	int i;

	GtkWidget *cbdevice = gtk_bin_get_child(GTK_BIN(cbox));
	std::string device = gtk_entry_get_text(GTK_ENTRY(cbdevice));
	device = device.substr (0, device.find(' '));

	printf ("%s:%d %s   open device: '%s'\n", __FILE__, __LINE__, __FUNCTION__, device.c_str());
	gtk_widget_set_sensitive(btnstart, false);
	gtk_widget_set_sensitive(btnstop, true);

	videodev.Start(device, cb_thread_video);
	videodev.GetCtrlList(&list);

	//
	// clear grid
	while ((gridchild = gtk_grid_get_child_at(GTK_GRID(grid), 0, 0)) != NULL) {
		gtk_grid_remove_row (GTK_GRID(grid), 0);
	}

	//
	// add elements
	for (i = 0, iter = list.begin(); iter != list.end(); iter++, i++) {
		int min = 0;
		int max = 100;
		int value = 50;

		videodev.GetCtrlMinMaxValue((*iter), &min, &max, &value);

		//
		// label
		GtkWidget *label = gtk_label_new(iter->c_str());

		//
		// scale/range
		GtkWidget *scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, min, max, 1);
		gtk_range_set_value(GTK_RANGE(scale),value);
		gtk_widget_set_hexpand (scale,true);
		gtk_scale_set_draw_value(GTK_SCALE(scale), false);
		g_signal_connect (GTK_RANGE(scale), "value-changed", G_CALLBACK(cb_vidctrl_scale_change), (void*)(long int)i);

		//
		// entry field
		GtkWidget *entry = gtk_entry_new();
		gtk_entry_set_text(GTK_ENTRY(entry), std::to_string(value).c_str());
		g_signal_connect (entry, "activate", G_CALLBACK(cb_vidctrl_entry_change), (void*)(long int)i);

		gtk_grid_insert_row(GTK_GRID(grid), i);
		if (i == 0) {
			gtk_grid_insert_column(GTK_GRID(grid), 0);
			gtk_grid_insert_column(GTK_GRID(grid), 0);
			gtk_grid_insert_column(GTK_GRID(grid), 0);
		}
		gtk_grid_attach(GTK_GRID(grid), label, 0, i, 1, 1);
		gtk_grid_attach(GTK_GRID(grid), scale, 1, i, 1, 1);
		gtk_grid_attach(GTK_GRID(grid), entry, 2, i, 1, 1);
		gtk_widget_show (label);
		gtk_widget_show (scale);
		gtk_widget_show (entry);
	}
};


/*
 * stop recording from the videodev (will stop the running thread)
 */
void cb_video_btnstop (GtkWidget *widget, gpointer data) {
	GtkWidget *btnstart = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "btn-video-rec"));
	GtkWidget *btnstop = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "btn-video-stop"));

	printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);

	videodev.Stop();
	gtk_widget_set_sensitive(btnstart, true);
	gtk_widget_set_sensitive(btnstop, false);
};


/*
 * callback from videodev thread. data will point to the latest VideoFrame.
 * Access to this data must be Locked before use.
 */
gboolean cb_thread_video (gpointer data) {
	GtkWidget *btnstart;
	GtkWidget *btnstop;
	VideoFrame *vf = (VideoFrame *) data;

	btnstop = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "btn-video-stop"));
	btnstart = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "btn-video-rec"));

	if (video_da == NULL)
		video_da = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "video-da"));

	if (vf == NULL) {
		printf ("%s:%d %s something went wrong\n", __FILE__, __LINE__, __FUNCTION__);
		videodev.Stop();
		if (video_pixbuf == NULL) {
			video_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, false, 8, 100, 100);
		}
		memset (gdk_pixbuf_get_pixels(video_pixbuf), 0, 3 * gdk_pixbuf_get_height(video_pixbuf) * gdk_pixbuf_get_width(video_pixbuf));

		gtk_widget_set_sensitive(btnstart, true);
		gtk_widget_set_sensitive(btnstop, false);
	}
	else {
		int pix_h, pix_w;

		videodev.LockMutex();
		if (video_pixbuf) {
			pix_h = gdk_pixbuf_get_height(video_pixbuf);
			pix_w = gdk_pixbuf_get_width(video_pixbuf);
		}
		else pix_h = 0;

		if (video_pixbuf == NULL || pix_h != vf->h || pix_w != vf->w) {
			if (video_pixbuf != NULL) g_object_unref (video_pixbuf);

			printf ("%s:%d %s New Pixbuf: %d x %d\n", __FILE__, __LINE__, __FUNCTION__, vf->w, vf->h);
			video_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, false, 8, vf->w, vf->h);
			pix_w = vf->w;
			pix_h = vf->h;
		}
		videoframe_to_pixbuf(video_pixbuf, vf);
		detect.NewFrame(vf);
		videodev.UnLockMutex();
	}
    gdk_window_invalidate_rect(gtk_widget_get_window(video_da), NULL, true);

	return false;
};


/*
 * set ctrl on the device
 */
void videoctrl_set(std::string name, int value) {
	videodev.SetCtrlValue(name, value);
}


/*
 * callback video control scale change
 */
void cb_vidctrl_scale_change (GtkRange *range, gpointer data) {
	GtkWidget *grid = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "vidctrl-grid"));
	GtkWidget *scale = NULL;
	GtkWidget *label = NULL;
	int idx = (long int)data;
	double value;

	label = gtk_grid_get_child_at(GTK_GRID(grid), 0, idx);
	scale = gtk_grid_get_child_at(GTK_GRID(grid), 1, idx);
	if (scale == NULL) return;

	value = gtk_range_get_value(GTK_RANGE(scale));
	videoctrl_set((std::string)gtk_label_get_text(GTK_LABEL(label)), (int)value);
};


/*
 * callback video control entry change
 */
void cb_vidctrl_entry_change (GtkWidget *widget, gpointer data) {
	GtkWidget *grid = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), "vidctrl-grid"));
	GtkWidget *label = NULL;
	GtkWidget *entry = NULL;
	int idx = (long int)data;
	int value;

	label = gtk_grid_get_child_at(GTK_GRID(grid), 0, idx);
	entry = gtk_grid_get_child_at(GTK_GRID(grid), 2, idx);
	if (entry == NULL) return;

	value = atoi(gtk_entry_get_text(GTK_ENTRY(entry)));
	videoctrl_set((std::string)gtk_label_get_text(GTK_LABEL(label)), (int)value);
};


void cb_videoda_motionevent (GtkWidget *widget, GdkEvent *event, gpointer data) {
	int dw, dh, sw, sh;
	float sar, dar;

	if (video_pixbuf != NULL) {
		sh = gtk_widget_get_allocated_height(video_da);
		sw = gtk_widget_get_allocated_width(video_da);

		dw = gdk_pixbuf_get_width(video_pixbuf);
		dh = gdk_pixbuf_get_height(video_pixbuf);

		sar = (float)sw/(float)sh;
		dar = (float)dw/(float)dh;

		if (dar < sar) {
			sw = (dar * (float) sh);
		}
		else {
			sh = ((float) sw / dar);
		}

		video_enterdata_pos.x = event->motion.x * dw / sw;
		video_enterdata_pos.y = event->motion.y * dh / sh;

	    gdk_window_invalidate_rect(gtk_widget_get_window(video_da), NULL, true);
	}
};


void cb_videoda_btnpress (GtkWidget *widget, GdkEvent *event, gpointer data) {
	int x = event->motion.x;
	int y = event->motion.y;

	printf ("%s:%d %s %d, %d\n", __FILE__, __LINE__, __FUNCTION__, x, y);
};


void cb_videoda_btnrelease (GtkWidget *widget, GdkEvent *event, gpointer data) {
	if (video_enterdata == VID_ENTERDATA_POS) {
		detect.SetObjectPos(video_enterdata_pos.x, video_enterdata_pos.y);
		video_enterdata = VID_ENTERDATA_NONE;
	}
};


/*
 *  cb_video_pre_click/cb_video_pre_pressed, are needed to detect is we press
 *  the button longer as two seconds. If it is, all settings will be saved.
 */
#define BTNDOWN_TIME 1.0
struct {
	int idx;
	struct timeval tv;
	guint timer;
} presetbtn;
void cb_video_pre_click (GtkWidget *widget, gpointer data) {
	float pushtime = get_cycletime(&presetbtn.tv);
	std::string s;
	int idx;
	GtkWidget *btn;

	if (pushtime > BTNDOWN_TIME && presetbtn.idx >= 0 && presetbtn.idx < BTN_PRESET_MAX) {
		//
		// save the settings
		//
		list<VideoDevCtrl> ctrls = videodev.GetCtrlsMinMaxValue();
		config.SetPresetButton(presetbtn.idx, &ctrls);

		//
		// reset button label
		//
		for (idx = 0; idx < BTN_PRESET_MAX; idx++) {
			s = "btn-video-pre"+std::to_string(idx+1);
			if ((btn = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), s.c_str()))) != NULL) {
				gtk_button_set_label(GTK_BUTTON(btn), std::to_string(idx+1).c_str());
			}
		}
	}
	else if (presetbtn.idx >= 0 && presetbtn.idx < BTN_PRESET_MAX) {
		//
		// callup settings
		//
		int i, retry = 5, again = 1;
		list<VideoDevCtrl> ctrls = config.GetPresetButton(presetbtn.idx);
		list<VideoDevCtrl>::iterator iter;
		presetbtn.idx = -1;

		for (retry = 5; retry > 0 && again; retry--) {
			again = 0;
			for (iter = ctrls.begin(); iter != ctrls.end(); iter++) {
				videodev.SetCtrlValue(iter->name, iter->value);
				usleep(10000);
				videodev.GetCtrlMinMaxValue(iter->name, NULL, NULL, &i);
				if (i != iter->value)		again = 1;
			}
		}
	}
};


/*
 * should determine the pressed button and save it together with the current
 * time in structure presetbtn.
 */
void cb_video_pre_pressed (GtkWidget *widget, gpointer data) {
	int idx = -1;
	std::string s;
	GtkWidget *btn;

	for (idx = 0; idx < BTN_PRESET_MAX; idx++) {
		s = "btn-video-pre"+std::to_string(idx+1);
		if ((btn = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), s.c_str()))) == widget) {
			if (presetbtn.timer <= 0)
				presetbtn.timer = g_timeout_add((int)(BTNDOWN_TIME*1000.0), video_pre_long, NULL);
			break;
		}
	}

	presetbtn.idx = idx;
	gettimeofday (&presetbtn.tv, NULL);
};


/*
 * gnome timer callback if any presetbutton was pressed down
 * in case the button is still pressed, we write SAVED in the buttons label.
 */
gboolean video_pre_long(gpointer data) {
	std::string s = "btn-video-pre"+std::to_string(presetbtn.idx+1);
	GtkWidget *btn = GTK_WIDGET(gtk_builder_get_object (GTK_BUILDER(_builder_), s.c_str()));

	if (btn && presetbtn.idx >= 0 && presetbtn.idx < BTN_PRESET_MAX)
		gtk_button_set_label(GTK_BUTTON(btn), "Saved");

	presetbtn.timer = 0;
	return FALSE;
};