#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);

}