#include <gst/gst.h>

 #include <gtk/gtk.h>

 #include <gdk/gdkx.h>

 #include <gst/interfaces/xoverlay.h>

 #include <unistd.h>

 #include "mmyth_ui.h"

 #include "mmyth_videoplayer.h"

 #include "mmyth_sdpreader.h"

 #include "esg_database.h"

 #include "ipd_demux.h"

 #include "ipd_network.h"

 #ifdef INDT_IP_DECAPSULATOR

 #include <sys/types.h>

 #include <signal.h>

 #endif

 /* Global flag/semaphore to control IP decapsulator threads */

 gboolean state_keep_running = 0;

 typedef struct _GstPlayerWindowStateChange

 {

     GstElement *play;

     GstState old_state, new_state;

     MMythUi *mmyth_ui;

 } GstPlayerWindowStateChange;

 typedef struct _GstPlayerWindowTagFound

 {

     GstElement *play;

     GstTagList *taglist;

     MMythUi *mmyth_ui;

 } GstPlayerWindowTagFound;

 GstElement *gst_pipeline, *gst_decoder, *gst_videosink;

 static gboolean idle_state (gpointer data);

 static gboolean

 bus_call (GstBus * bus, GstMessage * msg, gpointer data)

 {

     MMythUi *mmyth_ui = (MMythUi *) data;

     GMainLoop *loop = mmyth_ui->loop;

     switch (GST_MESSAGE_TYPE (msg)) {

         case GST_MESSAGE_EOS:

             if (mmyth_ui->idle_id != 0) {

                 g_source_remove (mmyth_ui->idle_id);

                 mmyth_ui->idle_id = 0;

             }

             //g_idle_add ((GSourceFunc) idle_eos, data);

             gst_element_set_state (GST_ELEMENT (GST_MESSAGE_SRC (msg)),

                                    GST_STATE_READY);

             break;

         case GST_MESSAGE_ERROR:{

                 gchar *debug;

                 GError *err;

                 gst_message_parse_error (msg, &err, &debug);

                 g_free (debug);

                 printf ("Error: %s\n", err->message);

                 g_error_free (err);

                 g_main_loop_quit (loop);

             }

             break;

         case GST_MESSAGE_STATE_CHANGED:{

                 GstState oldstate;

                 GstState newstate;

                 GstState pending;

                 GstPlayerWindowStateChange *st =

                     g_new (GstPlayerWindowStateChange, 1);

                 gst_message_parse_state_changed (msg,

                                                  &oldstate,

                                                  &newstate, &pending);

                 st->play = mmyth_ui->play;

                 gst_object_ref (GST_OBJECT (mmyth_ui->play));

                 st->old_state = oldstate;

                 st->new_state = newstate;

                 st->mmyth_ui = mmyth_ui;

                 /* State debug messages */

                 printf ("oldstate = %s, newstate = %s, pendingstate = %s\n",

                         gst_element_state_get_name (oldstate),

                         gst_element_state_get_name (newstate),

                         gst_element_state_get_name (pending));

                 g_idle_add ((GSourceFunc) idle_state, st);

             }

             break;

         default:

             printf (gst_message_type_get_name (GST_MESSAGE_TYPE (msg)));

             printf ("\n");

             break;

     }

     return TRUE;

 }

 static gboolean

 cb_iterate (gpointer data)

 {

     MMythUi *mmyth_ui = (MMythUi *) data;

     //gboolean res;

     g_main_loop_run (mmyth_ui->loop);

 /*

 	if (!GST_FLAG_IS_SET (mmyth_ui->play, GST_BIN_SELF_SCHEDULABLE)) {

     	res = gst_bin_iterate (GST_BIN (mmyth_ui->play));

 	} else {

     	g_usleep (100);

 		res = (gst_element_get_state (mmyth_ui->play) == GST_STATE_PLAYING);

 	}

 	if (!res)

     	mmyth_ui->idle_id = 0;

     return res;

 */

     return FALSE;

 }

 static gboolean

 idle_state (gpointer data)

 {

     GstPlayerWindowStateChange *st = data;

     if (st->old_state == GST_STATE_PLAYING) {

         if (st->mmyth_ui->idle_id != 0) {

             g_source_remove (st->mmyth_ui->idle_id);

             st->mmyth_ui->idle_id = 0;

         }

     }

     else if (st->new_state == GST_STATE_PLAYING) {

         if (st->mmyth_ui->idle_id != 0)

             g_source_remove (st->mmyth_ui->idle_id);

         st->mmyth_ui->idle_id = g_idle_add (cb_iterate, st->mmyth_ui);

     }

     /* new movie loaded? */

     if (st->old_state == GST_STATE_READY && st->new_state > GST_STATE_READY) {

         /* gboolean have_video = FALSE; */

         gtk_widget_show (st->mmyth_ui->videow);

         gtk_window_resize (GTK_WINDOW (st->mmyth_ui->main_window), 1, 1);

     }

     /* discarded movie? */

     if (st->old_state > GST_STATE_READY && st->new_state == GST_STATE_READY) {

         if (st->mmyth_ui->tagcache) {

             gst_tag_list_free (st->mmyth_ui->tagcache);

             st->mmyth_ui->tagcache = NULL;

         }

     }

     gst_object_unref (GST_OBJECT (st->play));

     //g_object_unref (G_OBJECT (st->win));

     g_free (st);

     /* once */

     return FALSE;

 }

 static gboolean

 expose (GtkWidget * widget, GdkEventExpose * event, gpointer user_data)

 {

     MMythUi *mmyth_ui = (MMythUi *) user_data;

     gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (mmyth_ui->videosink),

                                   GDK_WINDOW_XWINDOW (mmyth_ui->videow->

                                                       window));

     return TRUE;

 }

 void

 mmyth_player_init (MMythUi * mmyth_ui)

 {

     GstElement *play;

     GstElement *source, *parser, *decoder, *videosink;

     play = gst_pipeline_new ("video-player");

     source = gst_element_factory_make ("udpsrc", "file-source");

     parser = gst_element_factory_make ("rtph263pdepay", "rtp-demux");

     decoder = gst_element_factory_make ("ffdec_h263", "mpeg-decoder");

     videosink = gst_element_factory_make ("xvimagesink", "image-output");

     gst_pipeline = play;

     gst_decoder = decoder;

     gst_videosink = videosink;

     if (!(gst_pipeline && source && parser && decoder && videosink)) {

         /* FIXME: hanlde the error correctly */

         /* video_alignment is not being created (below) 

            and is causing problems to the ui */

         g_print ("GstElement creation error!\n");

         return;

     }

     g_object_set (G_OBJECT (videosink), "sync", FALSE, NULL);

     gst_bus_add_watch (gst_pipeline_get_bus (GST_PIPELINE (gst_pipeline)),

                        bus_call, mmyth_ui);

     gst_bin_add_many (GST_BIN (gst_pipeline), source, parser, decoder,

                       videosink, NULL);

     {

         GstCaps *rtpcaps = gst_caps_new_simple ("application/x-rtp", NULL);

         gst_element_link_filtered(source, parser, rtpcaps);

     }

     gst_element_link_many (/*source,*/ parser, decoder, videosink, NULL);

     /* actual window */

     mmyth_ui->play = play;

     mmyth_ui->videosink = videosink;

     mmyth_ui->udpsource = source;

     g_object_ref (mmyth_ui->play);

     g_object_ref (mmyth_ui->videosink);

     /* video widget */

     //mmyth_ui->videow = gst_player_video_new (videosink, play);

     mmyth_ui->videow = gtk_drawing_area_new ();

     gtk_widget_set_size_request (mmyth_ui->videow, 300, 240);

     mmyth_ui->logo = gdk_pixbuf_new_from_file ("logo.png", NULL);

     mmyth_ui->video_alignment = gtk_alignment_new (0.5, 0.5, 0, 0);

     gtk_widget_hide (mmyth_ui->video_alignment);

     gtk_container_add (GTK_CONTAINER (mmyth_ui->video_alignment),

                        mmyth_ui->videow);

     g_signal_connect (mmyth_ui->videow, "expose-event", G_CALLBACK (expose),

                       mmyth_ui);

     //g_signal_connect(mmyth_ui->videow, "size_request", G_CALLBACK(cb_preferred_video_size), mmyth_ui);

     g_object_ref (mmyth_ui->videow);

     g_object_ref (mmyth_ui->video_alignment);

     //gnome_app_set_contents (app, videow);

     //gtk_widget_show (mmyth_ui->videow);

 //fail:

 //  gst_object_unref (GST_OBJECT (play));

 //  return NULL;  

 }

 void

 mmyth_player_stop (MMythUi * mmyth_ui)

 {

     gst_element_set_state (mmyth_ui->play, GST_STATE_NULL);

     if(mmyth_ui->videow != NULL)

         gtk_widget_hide (mmyth_ui->videow);

     /* Disable IP Decapsulator playing threads */

     state_keep_running = FALSE;	

 }

 static gboolean

 idle_play (gpointer data)

 {

     MMythUi *mmyth_ui = (MMythUi *) data;

     sleep (2);

     gst_element_set_state (mmyth_ui->play, GST_STATE_PLAYING);

     return FALSE;

 }

 /* Run IP decapsulator play function in a new thread. The thread is finished setting the

  * semaphore "state_keep_running" to FALSE*/

 gpointer

 run_ipd(gpointer data)

 {

     GString *ip_addr = (GString*) data;

 	state_keep_running = TRUE;

 	printf("Inside thread\n");

 	ipd_mpe_play_section (ip_addr->str, &state_keep_running);

 	return 0;

 }

 void

 mmyth_play_channel (MMythUi * mmyth_ui, gint service_number)

 {

 	ESGDatabase *esg_db;

     DVBHService *service;

 	SDPData sdp_data;

 	GString *service_ip_addr;

 	/* First verifies if there is a tuned network */

 	if ( !ipd_network_is_tuned() ) {

 		/* FIXME: show alert and handle this error */

         g_warning ("Play not possible, network not tuned");

 		return;

 	}

     esg_db = esg_database_get_instance();

     /* Gets the service structure */

     service = (DVBHService *) esg_database_get_service_from_number

                                  (esg_db, service_number);

 	/* Verifies if sdp fragment exists to this service */

 	if ( service->sdp_file == NULL ) {

 		/* FIXME: Implement error handling */

         g_warning ("SDP fragment not available to access service");

 		return;

     }

 	/* Parses the sdp to get ipv6 address and port */

 	mmyth_sdp_parse_file (service->sdp_file->str, &sdp_data);

     /* Sets the gstreamer properties acording to the service access address */

 	/* FIXME: Develop sdp_bin in gstreamer to give sdp file as pipeline config */

     g_object_set (G_OBJECT (mmyth_ui->udpsource), "multicast_group",

                   sdp_data.ip_addr->str, NULL);

     g_object_set (G_OBJECT (mmyth_ui->udpsource), "port", sdp_data.video_port, NULL);

     /* Shows the video widget on screen */

     mmyth_ui_set_widget (mmyth_ui, mmyth_ui->video_uicommon);

     gtk_widget_show (mmyth_ui->videow);

     gtk_widget_queue_draw (mmyth_ui->videow);

 #ifdef INDT_IP_DECAPSULATOR

     /* Will be dealocated in run_ipd */	

 	service_ip_addr = g_string_new (sdp_data.ip_addr->str);

 	/* Requests the IP decapsulator to play the channel stream*/

 	g_thread_create (run_ipd, (gpointer) service_ip_addr, FALSE, NULL);

 #endif

     //gst_element_set_state (mmyth_ui->play, GST_STATE_PLAYING);

     g_idle_add (idle_play, mmyth_ui);

 }