/**
 * GMyth Library
 *
 * @file gmyth/mmyth_tvplayer.c
 * 
 * @brief <p> This component provides playback of the remote A/V using
 * GStreamer.
 * 
 * Copyright (C) 2006 INdT - Instituto Nokia de Tecnologia.
 * @author Hallyson Luiz de Morais Melo <hallyson.melo@indt.org.br>
 *
 *//*
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "mmyth_tvplayer.h"
 
#include <gdk/gdkx.h>

#include "gmyth_context.h"
#include "gmyth_remote_util.h"

typedef struct _GstPlayerWindowStateChange
{
    GstElement *play;
    GstState old_state, new_state;
    MMythTVPlayer *tvplayer;
} GstPlayerWindowStateChange;

typedef struct _GstPlayerWindowTagFound
{
    GstElement *play;
    GstTagList *taglist;
    MMythTVPlayer *tvplayer;
} GstPlayerWindowTagFound;

/*
static gboolean idle_state (gpointer data);
*/
static gboolean bus_call (GstBus * bus, GstMessage * msg, gpointer data);

static void mmyth_tvplayer_class_init          (MMythTVPlayerClass *klass);
static void mmyth_tvplayer_init                (MMythTVPlayer *object);

static void mmyth_tvplayer_dispose  (GObject *object);
static void mmyth_tvplayer_finalize (GObject *object);

G_DEFINE_TYPE(MMythTVPlayer, mmyth_tvplayer, G_TYPE_OBJECT)

static gboolean mmyth_tvplayer_create_pipeline (MMythTVPlayer* tvplayer);
static void     new_pad_cb (GstElement *element, 
                            GstPad *pad, gpointer data);

static gboolean expose_cb (GtkWidget * widget, 
                           GdkEventExpose * event, 
                           gpointer user_data);

static void
mmyth_tvplayer_class_init (MMythTVPlayerClass *klass)
{
	GObjectClass *gobject_class;

    gobject_class = (GObjectClass *) klass;
	
    gobject_class->dispose  = mmyth_tvplayer_dispose;
    gobject_class->finalize = mmyth_tvplayer_finalize;	
}

static void
new_pad_cb (GstElement *element, GstPad *pad, gpointer data)
{
	MMythTVPlayer *tvplayer = MMYTH_TVPLAYER (data);
	GstPadLinkReturn ret;
	char *s;
	
	s = gst_caps_to_string (pad->caps);

	if ( s[0] == 'a') {
		ret = gst_pad_link (pad, gst_element_get_pad (tvplayer->audioqueue, "sink"));
	} else {
		ret = gst_pad_link (pad, gst_element_get_pad (tvplayer->videoqueue, "sink")); 
	}
	
	g_free(s);
}

static gboolean
expose_cb (GtkWidget * widget, GdkEventExpose * event, gpointer user_data)
{
    MMythTVPlayer *tvplayer = MMYTH_TVPLAYER (user_data);

	if (tvplayer && tvplayer->videow) {
	    gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (tvplayer->gst_videosink),
                                  GDK_WINDOW_XWINDOW (widget->window));
		return TRUE;
	}
	
	g_warning ("MMythTVPlayer expose called before setting video window\n");
	
    return FALSE;
}

static void
mmyth_tvplayer_init (MMythTVPlayer *tvplayer)
{
    tvplayer->gst_pipeline = NULL;
    tvplayer->gst_source = NULL;
    tvplayer->gst_videodec = NULL;
    tvplayer->gst_videosink = NULL;
    tvplayer->videoqueue = NULL;
    tvplayer->audioqueue = NULL;
    
    /* GTKWidget for rendering the video */
    tvplayer->videow = NULL;
	tvplayer->expose_handler = 0;
	    
	tvplayer->backend_hostname = NULL;
	tvplayer->backend_port = 0;
	tvplayer->local_hostname = NULL;

	tvplayer->remote_encoder = NULL;
	tvplayer->tvchain = NULL;
	tvplayer->proginfo = NULL;
}

static void
mmyth_tvplayer_dispose (GObject *object)
{

	G_OBJECT_CLASS (mmyth_tvplayer_parent_class)->dispose (object);
}

static void
mmyth_tvplayer_finalize (GObject *object)
{
	g_signal_handlers_destroy (object);

	MMythTVPlayer *tvplayer = MMYTH_TVPLAYER (object);

	g_debug ("[%s] Finalizing tvplayer", __FUNCTION__);
	
	if (tvplayer->videow != NULL) {
		if (g_signal_handler_is_connected (tvplayer->videow, 
						tvplayer->expose_handler)) {
			g_signal_handler_disconnect (tvplayer->videow,
				tvplayer->expose_handler);
		}
		g_object_unref (tvplayer->videow);
	}
	
	if ( tvplayer->remote_encoder != NULL )
		g_object_unref (tvplayer->remote_encoder);
	if ( tvplayer->tvchain != NULL )
		g_object_unref (tvplayer->tvchain);
	if ( tvplayer->proginfo != NULL )
		g_object_unref (tvplayer->proginfo);	

	// Release Gstreamer elements
	if ( tvplayer->gst_pipeline != NULL )
		g_object_unref (tvplayer->gst_pipeline);	
	if ( tvplayer->gst_source != NULL )
		g_object_unref (tvplayer->gst_source);	
	if ( tvplayer->gst_videodec != NULL )
		g_object_unref (tvplayer->gst_videodec);	
	if ( tvplayer->gst_videosink != NULL )
		g_object_unref (tvplayer->gst_videosink);	
	if ( tvplayer->videoqueue != NULL )
		g_object_unref (tvplayer->videoqueue);	
	if ( tvplayer->audioqueue != NULL )
		g_object_unref (tvplayer->audioqueue);	

	G_OBJECT_CLASS (mmyth_tvplayer_parent_class)->finalize (object);
}

/** Creates a new instance of MMythTVPlayer. 
 * 
 * @return a new instance of MMythTVPlayer.
 */
MMythTVPlayer *
mmyth_tvplayer_new ()
{
    MMythTVPlayer *tvplayer = 
        MMYTH_TVPLAYER (g_object_new(MMYTH_TVPLAYER_TYPE, NULL));
    
    return tvplayer;
}

/** Initializes the tv player.
 *
 * @param tvplayer the object instance.
 * @return gboolean TRUE if the pipeline was created 
 * successfully, FALSE otherwise.
 */
gboolean
mmyth_tvplayer_initialize (MMythTVPlayer *tvplayer)
{
	
    if (!mmyth_tvplayer_create_pipeline (tvplayer)) {
    	g_warning ("[%s] Error while creating pipeline. TV Player not initialized", __FUNCTION__);
		return FALSE;
	} else {
		g_debug ("[%s] GStreamer pipeline created", __FUNCTION__);	
    }

	return TRUE;
}

/** Creates the GStreamer pipeline used by the player.
 *
 * @param tvplayer the object instance.
 * @return gboolean TRUE if the pipeline was created 
 * successfully, FALSE otherwise.
 */
static gboolean
mmyth_tvplayer_create_pipeline (MMythTVPlayer* tvplayer)
{
    GstElement *pipeline;
    GstElement *source, *parser;
    GstElement *videodec, *videosink;
#ifndef MAEMO_PLATFORM    
    GstElement *audiodec, *audioconv;
#endif
    GstElement *audiosink;
    GstElement *videoqueue, *audioqueue;

    g_debug ("MMythTVPlayer: Setting the Gstreamer pipeline\n");
	
    pipeline = gst_pipeline_new ("video-player");
    source = gst_element_factory_make ("mythtvsrc", "myth-source");
    parser = gst_element_factory_make ("ffdemux_nuv", "nuv-demux");

    /* Gstreamer Video elements */
    videoqueue = gst_element_factory_make ("queue", "video-queue");
    videodec = gst_element_factory_make ("ffdec_mpeg4", "video-decoder");
#ifdef MAEMO_PLATFORM
    videosink = gst_element_factory_make ("sdlvideosink", "image-output");
#else
    videosink = gst_element_factory_make ("xvimagesink", "image-output");
#endif
    
    /* Gstreamer Audio elements */
    audioqueue = gst_element_factory_make ("queue", "audio-queue");    
#ifdef MAEMO_PLATFORM    
    audiosink = gst_element_factory_make ("dspmp3sink", "audio-output");
#else    
    audiodec = gst_element_factory_make ("ffdec_mp3", "audio-decoder");
    audioconv = gst_element_factory_make ("audioconvert", "audio-converter");
    audiosink = gst_element_factory_make ("alsasink", "audio-output");
#endif    
    
    if (!(pipeline && source && parser && videodec && videosink) ||
    	!(videoqueue && audioqueue && audiosink)) {
        /* FIXME: hanlde the error correctly */
        /* video_alignment is not being created (below) 
           and is causing problems to the ui */

	    tvplayer->gst_pipeline = NULL;
	    tvplayer->gst_videodec = NULL;
	    tvplayer->gst_videosink = NULL;
           
        g_warning ("GstElement creation error!\n");
        return FALSE;
    }

#ifndef MAEMO_PLATFORM    
    if (!(audiodec && audioconv)) {
        g_warning ("GstElement for audio stream creation error!");
        return FALSE;
    }
#endif    
    
    
    tvplayer->gst_pipeline = pipeline;
    tvplayer->gst_source = source;
    tvplayer->gst_videodec = videodec;
    tvplayer->gst_videosink = videosink;
    g_object_ref (tvplayer->gst_pipeline);
    g_object_ref (tvplayer->gst_source);
    g_object_ref (tvplayer->gst_videodec);
    g_object_ref (tvplayer->gst_videosink);

    tvplayer->videoqueue = videoqueue;
    tvplayer->audioqueue = audioqueue;
    g_object_ref (tvplayer->videoqueue);
    g_object_ref (tvplayer->audioqueue);
   	
    g_object_set (G_OBJECT (videosink), "sync", TRUE, NULL);
    g_object_set (G_OBJECT (audiosink), "sync", FALSE, NULL);

    gst_bus_add_watch (gst_pipeline_get_bus (GST_PIPELINE (tvplayer->gst_pipeline)),
                       bus_call, tvplayer);

    gst_bin_add_many (GST_BIN (pipeline), source, parser, videoqueue,
    			videodec, videosink, audioqueue, audiodec, audioconv, audiosink, NULL);

    {
//        GstCaps *rtpcaps = gst_caps_new_simple ("application/x-rtp", NULL);
//        gst_element_link_filtered(source, parser, rtpcaps);
    }
    
    gst_element_link (source, parser);
    gst_element_link_many (videoqueue, videodec, videosink, NULL);
    gst_element_link_many (audioqueue, audiodec, audioconv, audiosink, NULL);
    
    g_signal_connect (parser, "pad-added", G_CALLBACK (new_pad_cb), tvplayer);
    
    return TRUE;
}

/** Configures the backend and the tv player 
 * for playing the recorded content A/V.
 *
 * FIXME: Change filename to program info or other structure about the recorded
 *
 * @param tvplayer the object instance.
 * @param filename the file uri of the recorded content to be played.
 * @return TRUE if successfull, FALSE if any error happens.
 */
gboolean
mmyth_tvplayer_record_setup (MMythTVPlayer *tvplayer, gchar *filename)
{
	GMythSettings *msettings = gmyth_context_get_settings();
	
	// FIXME: we should receive the uri instead of filename
	GString *hostname = gmyth_settings_get_backend_hostname (msettings);
	int port = gmyth_settings_get_backend_port(msettings);
	
	GString *fullpath = g_string_new ("myth://");
	g_string_append_printf (fullpath, "%s:%d/%s", hostname->str, port, filename);
	
	tvplayer->is_livetv = FALSE;

	g_debug ("[%s] Setting record uri to gstreamer pipeline to %s", __FUNCTION__, fullpath->str);
		
    g_object_set (G_OBJECT (tvplayer->gst_source), "location",
          fullpath->str, NULL);
          
    return TRUE;
}

/** Configures the backend and the tv player 
 * for playing the live tv.
 *
 * @param tvplayer the object instance.
 * @return TRUE if successfull, FALSE if any error happens.
 */
gboolean
mmyth_tvplayer_livetv_setup (MMythTVPlayer *tvplayer)
{
	GMythSettings *msettings = gmyth_context_get_settings ();
	gboolean res = TRUE;

	res = gmyth_context_check_connection();
	if (!res) {
		g_warning ("[%s] LiveTV can not connect to backend", __FUNCTION__);	
		res = FALSE;
		goto error;
	}

	tvplayer->backend_hostname = gmyth_settings_get_backend_hostname(msettings);
	tvplayer->backend_port = gmyth_settings_get_backend_port (msettings);

	tvplayer->local_hostname  = g_string_new("");    
	gmyth_context_get_local_hostname (tvplayer->local_hostname);

	if ( tvplayer->local_hostname == NULL ) {
		res = FALSE;
		goto error;
	}

	// Gets the remote encoder num
	tvplayer->remote_encoder = remote_request_next_free_recorder (-1);

	if ( tvplayer->remote_encoder == NULL ) {
		g_warning ("[%s] None remote encoder available", __FUNCTION__);
		res = FALSE;
		goto error;
	}

	// Creates livetv chain handler
	tvplayer->tvchain = GMYTH_TVCHAIN ( g_object_new(GMYTH_TVCHAIN_TYPE, NULL) );
	gmyth_tvchain_initialize ( tvplayer->tvchain, tvplayer->local_hostname );

	if ( tvplayer->tvchain == NULL || tvplayer->tvchain->tvchain_id == NULL ) {
		res = FALSE;
		goto error;
	}

	// Init remote encoder. Opens its control socket.
	res = gmyth_remote_encoder_setup(tvplayer->remote_encoder);
	if ( !res ) {
		g_warning ("[%s] Fail while setting remote encoder\n", __FUNCTION__);
		res = FALSE;
		goto error;
	}
	// Spawn live tv. Uses the socket to send mythprotocol data to start livetv in the backend (remotelly)
	res = gmyth_remote_encoder_spawntv ( tvplayer->remote_encoder,
			gmyth_tvchain_get_id(tvplayer->tvchain) );
	if (!res) {
		g_warning ("[%s] Fail while spawn tv\n", __FUNCTION__);
		res = FALSE;
		goto error;
	}

	// Reload all TV chain from Mysql database.
	gmyth_tvchain_reload_all (tvplayer->tvchain);

	if ( tvplayer->tvchain == NULL ) {
		res = FALSE;
		goto error;
	}

	// Get program info from database using chanid and starttime
	tvplayer->proginfo = gmyth_tvchain_get_program_at (tvplayer->tvchain, -1);
	if ( tvplayer->proginfo == NULL ) {
		g_warning ("[%s] LiveTV not successfully started.\n", __FUNCTION__ );
		res = FALSE;
		goto error;
	} else {
		g_debug ("[%s] MythLiveTV: All requests to backend to start TV were OK.\n", __FUNCTION__ );
	}

	return res;

error:
	if ( tvplayer->backend_hostname != NULL ) {
		g_string_free( tvplayer->backend_hostname, TRUE );
		res = FALSE;
	}

	if ( tvplayer->local_hostname != NULL ) {
		g_string_free( tvplayer->local_hostname, TRUE );
		res = FALSE;
	}

	if ( tvplayer->remote_encoder != NULL ) {
		g_object_unref (tvplayer->remote_encoder);
		tvplayer->remote_encoder = NULL;
	}

	if ( tvplayer->tvchain != NULL ) {
		g_object_unref (tvplayer->tvchain);
		tvplayer->tvchain = NULL;
	}

	if ( tvplayer->proginfo != NULL ) {
		g_object_unref (tvplayer->proginfo);
		tvplayer->proginfo = NULL;
	}

	return res;

}

/** Sets the GTK video widget for the tv player. 
 *
 * @param tvplayer the object instance.
 * @param videow the GTK video window.
 * @return TRUE if successfull, FALSE if any error happens.
 */
gboolean
mmyth_tvplayer_set_widget (MMythTVPlayer *tvplayer, GtkWidget *videow)
{
	tvplayer->videow = videow;
	g_object_ref (videow);
	
	g_debug ("[%s] Setting widget for tv player render", __FUNCTION__);
	
    tvplayer->expose_handler = g_signal_connect (tvplayer->videow, "expose-event", 
                                                 G_CALLBACK (expose_cb), tvplayer);

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

    return TRUE;
}

static gboolean
bus_call (GstBus * bus, GstMessage * msg, gpointer data)
{
    //MMythTVPlayer *tvplayer = MMYTH_TVPLAYER ( data );
    //GMainLoop *loop = tvplayer->loop;

    switch (GST_MESSAGE_TYPE (msg)) {
        case GST_MESSAGE_EOS:
			printf ("End of stream\n");
            //g_idle_add ((GSourceFunc) idle_eos, data);
            gst_element_set_state ( GST_ELEMENT (GST_MESSAGE_SRC (msg)), GST_STATE_NULL );
	    gst_element_set_locked_state ( GST_ELEMENT (GST_MESSAGE_SRC (msg)), TRUE );
            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;
        default:
            printf (gst_message_type_get_name (GST_MESSAGE_TYPE (msg)));
            printf ("\n");
            break;
    }

    return TRUE;
}


#if 0
static gboolean
idle_state (gpointer data)
{
    GstPlayerWindowStateChange *st = data;

    if (st->old_state == GST_STATE_PLAYING) {
        if (st->miptv_ui->idle_id != 0) {
            g_source_remove (st->miptv_ui->idle_id);
            st->miptv_ui->idle_id = 0;
        }
    }
    else if (st->new_state == GST_STATE_PLAYING) {
        if (st->miptv_ui->idle_id != 0)
            g_source_remove (st->miptv_ui->idle_id);

        st->miptv_ui->idle_id = g_idle_add (cb_iterate, st->miptv_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->miptv_ui->videow);

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

    }

    /* discarded movie? */
    if (st->old_state > GST_STATE_READY && st->new_state == GST_STATE_READY) {

        if (st->miptv_ui->tagcache) {
            gst_tag_list_free (st->miptv_ui->tagcache);
            st->miptv_ui->tagcache = NULL;
        }
    }

    gst_object_unref (GST_OBJECT (st->play));
    //g_object_unref (G_OBJECT (st->win));
    g_free (st);

    /* once */
    return FALSE;
}

#endif

/** Stops playing the current A/V.
 *
 * FIXME: How to proceed differently between livetv 
 * and recorded content?
 *
 * @param tvplayer the object instance.
 * @return void 
 */
void
mmyth_tvplayer_stop_playing (MMythTVPlayer *tvplayer) 
{
    g_debug ("[%s] Setting gstreamer pipeline state to NULL", __FUNCTION__);

    gst_element_set_state (tvplayer->gst_pipeline, GST_STATE_NULL);
    
    if (tvplayer->is_livetv) {
	    if (!gmyth_remote_encoder_stop_livetv (tvplayer->remote_encoder)) {
	    	g_warning ("[%s] Error while stoping remote encoder", __FUNCTION__);	
	    }
    }
}

/** Queries if the tvplayer is active playing A/V content.
 *
 * @param tvplayer the object instance.
 * @return TRUE if the tvplayer is active, FALSE otherwise.
 */
gboolean
mmyth_tvplayer_is_playing (MMythTVPlayer *tvplayer)
{
	return (GST_STATE (tvplayer->gst_pipeline) == GST_STATE_PLAYING);
}

/** Static function that sets the tvplayer state to PLAYING.
 *
 * @param tvplayer the object instance.
 * @return TRUE if the tvplayer is active, FALSE otherwise.
 */
static gboolean
idle_play (gpointer data)
{
    MMythTVPlayer *tvplayer = MMYTH_TVPLAYER (data);

	g_debug ("MMythTVPlayer: Setting pipeline state to PLAYING\n");

    gst_element_set_state (tvplayer->gst_pipeline, GST_STATE_PLAYING);

    return FALSE;
}

/** Start playing A/V with the tvplayer attributes.
 *
 * @param tvplayer the object instance.
 */
void
mmyth_tvplayer_start_playing (MMythTVPlayer *tvplayer)
{

	// FIXME: Move this to livetv_setup??
	if (tvplayer->is_livetv) {

	#if 0
		if (!tvplayer || !(tvplayer->proginfo) || !(tvplayer->local_hostname)
				|| !(tvplayer->gst_source)) {
			g_warning ("GMythtvPlayer not ready to start playing\n");		
		}

		if (!(tvplayer->proginfo->pathname)) {
			g_warning ("[%s] Playback url is null, could not play the myth content", __FUNCTION__);
			return;
		}

		g_debug ("MMythTVPlayer: Start playing %s", tvplayer->proginfo->pathname->str);
#endif
		g_object_set (G_OBJECT (tvplayer->gst_source), "mythtv-live",
				TRUE, NULL);
#if 0
		if ( tvplayer->tvchain != NULL ) {
			GString *str_chainid = gmyth_tvchain_get_id(tvplayer->tvchain);
			g_print( "[%s]\tCHAIN ID: %s\n", __FUNCTION__, str_chainid->str );

			g_object_set (G_OBJECT (tvplayer->gst_source), "mythtv-live-chainid", 
					g_strdup( str_chainid->str ), NULL);      
			if ( str_chainid!=NULL)
				g_string_free( str_chainid, FALSE );
		}

		if ( tvplayer->remote_encoder != NULL )	
			g_object_set (G_OBJECT (tvplayer->gst_source), "mythtv-live-id",
					tvplayer->remote_encoder->recorder_num, NULL );
		g_debug ("[%s] Setting location to %s", __FUNCTION__, 
				tvplayer->proginfo->pathname->str);

		/* Sets the gstreamer properties acording to the service access address */
		g_object_set (G_OBJECT (tvplayer->gst_source), "location",
				tvplayer->proginfo->pathname->str, NULL);              
#endif
	}

	g_object_set (G_OBJECT (tvplayer->gst_source), "mythtv-version",
              MYTHTV_VERSION_DEFAULT, NULL);

    g_object_set (G_OBJECT (tvplayer->gst_source), "mythtv-debug",
              TRUE, NULL);

    g_idle_add (idle_play, tvplayer);

}