/* vim: set sw=2: -*- Mode: C; tab-width: 2; indent-tabs-mode: t; c-basic-offset: 2; c-indent-level: 2-*- */

 /**

  * GMyth Library

  *

  * @file gmyth/gmyth_monitor_handler.c

  * 

  * @brief <p> GMythMonitorHandler deals with the streaming media events remote/local

  * that are sent to the MythTV frontend.

  *

  * Copyright (C) 2006 INdT - Instituto Nokia de Tecnologia.

  * @author Rosfran Lins Borges <rosfran.borges@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

  *

  * GStreamer MythTV plug-in properties:

  * - location (backend server hostname/URL) [ex.: myth://192.168.1.73:28722/1000_1092091.nuv]

  * - path (qurl - remote file to be opened)

  * - port number *   

  */

 #include "gmyth_uri.h"

 #include "gmyth_livetv.h"

 #include "gmyth_util.h"

 #include "gmyth_socket.h"

 #include "gmyth_stringlist.h"

 #include "gmyth_monitor_handler.h"

 #include "gmyth_debug.h"

 #include <unistd.h>

 #include <glib.h>

 #include <arpa/inet.h>

 #include <sys/types.h>

 #include <sys/socket.h>

 #include <netdb.h>

 #include <errno.h>

 #include <stdlib.h>

 #include <assert.h>

 #define GMYTHTV_QUERY_HEADER		"QUERY_FILETRANSFER "

 #define GMYTHTV_VERSION							30

 #define GMYTHTV_TRANSFER_MAX_WAITS	700

 #define GMYTHTV_BUFFER_SIZE					8*1024

 #ifdef GMYTHTV_ENABLE_DEBUG

 #define GMYTHTV_ENABLE_DEBUG				1

 #else

 #undef GMYTHTV_ENABLE_DEBUG

 #endif

 /* this NDEBUG is to maintain compatibility with GMyth library */

 #ifndef NDEBUG

 #define GMYTHTV_ENABLE_DEBUG				1

 #endif

 GMainContext *io_watcher_context = NULL;

 GThreadPool *monitor_th = NULL;

 enum myth_sock_types {

   GMYTH_PLAYBACK_TYPE = 0,

   GMYTH_MONITOR_TYPE,

   GMYTH_FILETRANSFER_TYPE,

   GMYTH_RINGBUFFER_TYPE

 };

 //static gboolean* myth_control_sock_listener( GIOChannel *io_channel );

 //static gboolean myth_control_sock_listener( GIOChannel *io_channel, GIOCondition condition, 

 //				gpointer data );

 static void myth_control_sock_listener( GIOChannel *io_channel, gboolean* ret );

 static GMutex*				mutex 					 = NULL;

 static GCond*					io_watcher_cond  = NULL;

 static void gmyth_monitor_handler_class_init          (GMythMonitorHandlerClass *klass);

 static void gmyth_monitor_handler_init                (GMythMonitorHandler *object);

 static void gmyth_monitor_handler_dispose  (GObject *object);

 static void gmyth_monitor_handler_finalize (GObject *object);

 static gboolean gmyth_connect_to_backend_monitor (GMythMonitorHandler *monitor);

 void gmyth_monitor_handler_close( GMythMonitorHandler *monitor );

 G_DEFINE_TYPE(GMythMonitorHandler, gmyth_monitor_handler, G_TYPE_OBJECT)

 static void

 gmyth_monitor_handler_class_init (GMythMonitorHandlerClass *klass)

 {

   GObjectClass *gobject_class;

   gobject_class = (GObjectClass *) klass;

   gobject_class->dispose  = gmyth_monitor_handler_dispose;

   gobject_class->finalize = gmyth_monitor_handler_finalize;

 }

 static void

 gmyth_monitor_handler_init (GMythMonitorHandler *monitor)

 { 

   g_return_if_fail( monitor != NULL );

   monitor->event_sock = NULL;

   monitor->hostname = NULL;

   monitor->port = 0;

   monitor->actual_index = 0;

   monitor->backend_msgs = g_hash_table_new( g_int_hash, g_int_equal );

   /* it is used for signalizing the event socket consumer thread */

   io_watcher_cond = g_cond_new();

   /* mutex to control access to the event socket consumer thread */

   mutex = g_mutex_new();

 }

 static void

 gmyth_monitor_handler_dispose  (GObject *object)

 {

 	GMythMonitorHandler *monitor = GMYTH_MONITOR_HANDLER (object);

   if ( monitor->event_sock != NULL )  

   {

   	g_object_unref( monitor->event_sock );

   	monitor->event_sock = NULL;

   }

   if ( monitor->hostname != NULL )  

   {

   	g_free( monitor->hostname );

   	monitor->hostname = NULL;

   }

   if ( monitor->backend_msgs != NULL )  

   {

   	g_hash_table_unref( monitor->backend_msgs );

   	monitor->backend_msgs = NULL;

   }

   if ( mutex != NULL )  

   {

   	g_mutex_free( mutex );

   	mutex = NULL;

   }

   if ( io_watcher_cond != NULL )  

   {

   	g_cond_free( io_watcher_cond );

   	io_watcher_cond = NULL;

   }

   if ( monitor_th != NULL )  

   {

   	g_thread_pool_free( monitor_th, TRUE, FALSE );

   	//g_object_unref( monitor_th );

   	monitor_th = NULL;

   }

   G_OBJECT_CLASS (gmyth_monitor_handler_parent_class)->dispose (object);

 }

 static void

 gmyth_monitor_handler_finalize (GObject *object)

 {

   g_signal_handlers_destroy (object);

   G_OBJECT_CLASS (gmyth_monitor_handler_parent_class)->finalize (object);

 }

 // fixme: do we need the card_id????

 GMythMonitorHandler*

 gmyth_monitor_handler_new (void)

 {

   GMythMonitorHandler *monitor = GMYTH_MONITOR_HANDLER ( g_object_new (

 				GMYTH_MONITOR_HANDLER_TYPE, FALSE ));

   return monitor;

 }

 gboolean

 gmyth_monitor_handler_open (GMythMonitorHandler *monitor, gchar *hostname, gint port)

 {

   gboolean ret = TRUE;

   if (monitor->hostname != NULL) {

     g_free (monitor->hostname);

     monitor->hostname = NULL;

   }

   monitor->hostname = g_strdup( hostname );

   monitor->port = port;

   gmyth_debug ("Monitor event socket --- hostname: %s, port %d\n", monitor->hostname, monitor->port);

   /* configure the event socket */

   if (monitor->event_sock == NULL) { 

     if (!gmyth_connect_to_backend_monitor (monitor)) {

       g_printerr( "Connection to backend failed (Event Socket).\n" );

       ret = FALSE;

     }

   } else {

     g_warning("Remote monitor event socket already created.\n");

   }

   return ret;

 }

 static void

 //myth_control_sock_listener( GIOChannel *io_channel, GIOCondition condition, gpointer data )

 myth_control_sock_listener( GIOChannel *io_channel, gboolean* ret )

 {

   GIOStatus io_status;

   GError *error = NULL;

   GIOCondition io_cond;

   GIOCondition condition;

   gchar *trash = NULL;

   GByteArray *byte_array = NULL;

   guint recv = 0;

   ret = g_new0( gboolean, 1 );

   *ret = TRUE;

   //gboolean ret = TRUE;

   gsize len = 0;

   static guint count = 0;  

   //GMythMonitorHandler *monitor = (GMythMonitorHandler*)data;

   //myth_control_acquire_context (TRUE);

   if ( io_channel == NULL ) {

   	g_debug ("Monitor socket is NULL!\n");

   	*ret = FALSE;

   	goto clean_up;

   }

   while (TRUE) {

   	++count;

   	gmyth_debug ("%d - Listening on Monitor socket...!\n", count);

 	  condition = g_io_channel_get_buffer_condition( io_channel );	  

 	  //while ( !has_io_access ) 

 	  //	g_cond_wait( io_watcher_cond, mutex );

 	  //myth_control_acquire_context (TRUE);  

 	  if (condition & G_IO_HUP) {

 	    gmyth_debug ("Read end of pipe died!\n");

 	    ret = FALSE;

 	    //goto clean_up;

 	  }

 	  //if ( ( condition & G_IO_IN ) != 0 ) {

 	  	byte_array = g_byte_array_new();

 	  	io_status = g_io_channel_set_encoding( io_channel, NULL, &error );

 	  	guint buffer_size = GMYTHTV_BUFFER_SIZE;

 	    do 

 	    {

 	      trash = g_new0( gchar, buffer_size );

 	      io_status = g_io_channel_read_chars( io_channel, trash, 

 	      		buffer_size, &len, &error);

 	      gmyth_debug ( "[%s] Received data buffer from IO binary channel... %d bytes gone!\n", 

 	      		__FUNCTION__, len );

 	      recv += len;

 	      byte_array = g_byte_array_append( byte_array, (const guint8*)trash, len );

 	      if ( trash != NULL )

 	      	g_free( trash );

 	      io_cond = g_io_channel_get_buffer_condition( io_channel );

 	    } while ( ( io_cond & G_IO_IN ) != 0 );

 	    gmyth_debug ("\n\n\n[%s]\tEVENT: Read %d bytes: %s\n\n\n", __FUNCTION__, recv, byte_array != NULL && byte_array->data != NULL ? (gchar*)byte_array->data : "[no event data]" );

 	  //}	  

 	  if ( byte_array != NULL ) {

 	  	g_byte_array_free( byte_array, TRUE );

 	  	byte_array = NULL;

 	  }

 	  g_usleep( 300 );

   }

   if ( io_status == G_IO_STATUS_ERROR || error != NULL ) {

     gmyth_debug ("[%s] Error reading: %s\n", __FUNCTION__, error != NULL ? error->message : "" );

    	*ret = FALSE;

    	goto clean_up;   	

   }

   //g_hash_table_insert( monitor->backend_msgs, (gpointer)monitor->actual_index,

   //				  byte_array->data );

   //monitor->actual_index += recv;

 clean_up:

   if ( byte_array != NULL ) {

   	g_byte_array_free( byte_array, TRUE );

   	byte_array = NULL;

   }

   //return ret;

 }

 static gboolean

 gmyth_connect_to_backend_monitor (GMythMonitorHandler *monitor)

 {

   gboolean ret = TRUE;

   /* Creates the event socket */

   if (monitor->event_sock != NULL) {

     g_object_unref (monitor->event_sock);

     monitor->event_sock = NULL;

   }

   monitor->event_sock = gmyth_socket_new();

   /* Connects the socket, send Mythtv ANN Monitor and verify Mythtv protocol version */ 

   if (!gmyth_socket_connect_to_backend_events ( monitor->event_sock,

           monitor->hostname, monitor->port, FALSE ) ) 

   {

     g_object_unref (monitor->event_sock);

     monitor->event_sock = NULL;

     ret = FALSE;

   }

   return ret;

 }    

 static gboolean*

 myth_control_sock_setup( GIOChannel *channel )

 {

 	gboolean *ret = g_new0( gboolean, 1 );

 	//guint src_id = 0;

 	*ret = TRUE;

   io_watcher_context = g_main_context_default();

   GMainLoop *loop = g_main_loop_new( io_watcher_context, TRUE );

   GSource *source;

   if ( channel != NULL ) {

     source = g_io_create_watch( channel, G_IO_IN | G_IO_HUP );

     //src_id = g_io_add_watch( channel, G_IO_IN | G_IO_HUP, 

     //					(GSourceFunc)myth_control_sock_listener, NULL );

   } else {

   	*ret = FALSE;

   	goto cleanup;

   }

   g_source_set_callback ( source, (GSourceFunc)myth_control_sock_listener, NULL, NULL );

   g_source_attach( source, io_watcher_context );

   if (NULL == source){

     gmyth_debug( "[%s] Error adding watch listener function to the IO control channel!\n", __FUNCTION__ );

     *ret = FALSE;

     goto cleanup;

   }

   g_main_loop_run( loop );

 cleanup:

   if ( source != NULL )

     g_source_unref( source );

   //if ( io_watcher_context != NULL )

   //  g_main_context_unref( io_watcher_context );

   //if ( loop != NULL )

   //  g_main_loop_unref( loop );

   return ret;

 }

 gboolean 

 gmyth_monitor_handler_start (GMythMonitorHandler *monitor)

 {

 	gboolean *ret = g_new0( gboolean, 1 ); 

 	*ret = TRUE;	

 	if (!g_thread_supported () ) 	g_thread_init (NULL);

   monitor_th = g_thread_pool_new( (GFunc)myth_control_sock_listener, 

   					monitor->event_sock->sd_io_ch, 3, FALSE, NULL );

   //if ( ( ret = g_thread_join( monitor_th ) ) == FALSE )

   if ( monitor_th != NULL )

   {

   	gmyth_debug ( "\n[%s]\tOK! Starting listener on the MONITOR event socket...[thread location = %p]\n", 

   				__FUNCTION__, g_thread_self( ) );

   	*ret = TRUE;  	  	

   } else {

   	gmyth_debug ( "\n[%s]\tERROR! Coudn't start listener on the MONITOR event socket...[thread location = %p]\n", 

   				__FUNCTION__, g_thread_self( ) );

   	*ret = FALSE;

   }

 //cleanup:

   gmyth_debug( "[%s] Watch listener function over the IO control channel? %s!!!\n", 

   			__FUNCTION__, ( *ret == TRUE ? "YES" : "NO" ) );

     return *ret;

 }

 void

 gmyth_monitor_handler_close( GMythMonitorHandler *monitor )

 {

   if (monitor->event_sock) {

     g_object_unref( monitor->event_sock );

     monitor->event_sock = NULL;

   }

   if (monitor->hostname) {

     g_free( monitor->hostname );

     monitor->hostname = NULL;

   }

 }