/**
 * 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 *   
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

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

#include "gmyth_marshal.h"

#include "gmyth_monitor_handler.h"

#include "gmyth.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;

//GThread *monitor_th = NULL;

//static gboolean* myth_control_sock_listener( GIOChannel *io_channel );
//static gboolean gmyth_monitor_handler_listener( GIOChannel *io_channel, 
//						GIOCondition condition, gpointer data );

//gboolean* gmyth_monitor_handler_listener( GMythMonitorHandler *monitor );

void gmyth_monitor_handler_listener( GMythMonitorHandler *monitor, gpointer user_data );

static void gmyth_monitor_handler_default_listener( GMythMonitorHandler *monitor, gint msg_code, gchar* message );

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;
  GMythMonitorHandlerClass *gmonitor_class;

  gobject_class = (GObjectClass *) klass;
  gmonitor_class = (GMythMonitorHandlerClass *) gobject_class;

  gobject_class->dispose  = gmyth_monitor_handler_dispose;
  gobject_class->finalize = gmyth_monitor_handler_finalize;
  
	gmonitor_class->backend_events_handler_signal_id = 
		  g_signal_new ("backend-events-handler",
		                 G_TYPE_FROM_CLASS (gmonitor_class),
		                 G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
		                 0,
										 NULL,
										 NULL,
										 gmyth_marshal_VOID__INT_STRING,
										 G_TYPE_NONE,
										 2,
										 G_TYPE_INT,
										 G_TYPE_STRING);
										 
	gmonitor_class->backend_events_handler = gmyth_monitor_handler_default_listener;

}

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->allow_msgs_listener = TRUE;
  
  //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();
  
  monitor->monitor_th = NULL;
  
  monitor->gmyth_monitor_handler_listener = gmyth_monitor_handler_listener;
}

static void
gmyth_monitor_handler_dispose  (GObject *object)
{
	
	GMythMonitorHandler *monitor = GMYTH_MONITOR_HANDLER (object);
	
	monitor->allow_msgs_listener = FALSE;
	
	if ( monitor->monitor_th != NULL )  
  {
  	g_thread_pool_free( monitor->monitor_th, TRUE, FALSE );
  	//g_thread_exit( monitor->monitor_th );
  	if ( monitor->monitor_th != NULL )
  		g_object_unref( monitor->monitor_th );
  	monitor->monitor_th = NULL;
  }
	
  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_destroy ( 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;
  }
  */
  
  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;
}

static gboolean 
myth_control_acquire_context( gboolean do_wait ) 
{
	
	gboolean ret = TRUE;	
	//guint max_iter = 50;
	
	//g_mutex_lock( mutex );
	
  //while ( !has_io_access ) 
  //	g_cond_wait( io_watcher_cond, mutex );
  	
  //has_io_access = FALSE;
  /*
  if ( do_wait ) {
  	while ( --max_iter > 0 && !g_main_context_wait( io_watcher_context, io_watcher_cond, mutex ) )
  		ret = FALSE;
  } else if ( !g_main_context_acquire( io_watcher_context ) )
  	ret = FALSE;
  */
  	
  //g_static_mutex_lock( &st_mutex );
  
  return ret;
  
}

static gboolean 
myth_control_release_context( ) 
{
	
	gboolean ret = TRUE;
    
  //g_static_mutex_unlock( &st_mutex );
  
	//g_main_context_release( io_watcher_context );
  
  //g_main_context_wakeup( io_watcher_context );
  
  //has_io_access = TRUE;

  //g_cond_broadcast( io_watcher_cond );
  
  //g_mutex_unlock( mutex );  
 
  return ret;
  
}

gboolean
gmyth_monitor_handler_open (GMythMonitorHandler *monitor, const gchar *hostname, gint port)
{
  gboolean ret = TRUE;
  
  g_return_val_if_fail( hostname != NULL, FALSE );

  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 ( NULL == monitor->event_sock ) { 
    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 gint
gmyth_monitor_handler_is_backend_message( GMythMonitorHandler *monitor,
                        GMythStringList* strlist, gchar **back_msg_action )
{
	gint msg_type = GMYTH_BACKEND_NO_MESSAGE;
	GString *back_msg = NULL;
	
	back_msg = gmyth_string_list_get_string( strlist, 0 );
	if ( back_msg != NULL && back_msg->str != NULL &&
	                                strstr( back_msg->str, "BACKEND" ) != NULL )
	{
		gmyth_debug( "MONITOR HANDLER - Received backend message = %s", back_msg->str );
  	*back_msg_action = gmyth_string_list_get_char_array( strlist, 1 );
  	
  	if ( back_msg_action != NULL )
  	{	        	
  	
    	if ( g_strstr_len( *back_msg_action, strlen( *back_msg_action ), "LIVETV_CHAIN" ) ||
    			g_strstr_len( *back_msg_action, strlen( *back_msg_action ), "RECORDING_LIST_CHANGE" ) || 
    			g_strstr_len( *back_msg_action, strlen( *back_msg_action ), "SCHEDULE_CHANGE" ) ||
    			g_strstr_len( *back_msg_action, strlen( *back_msg_action ), "LIVETV_WATCH" ) )
    	{
    		gmyth_debug( "MONITOR: message type == GMYTH_BACKEND_PROGRAM_INFO_CHANGED, msg = %s", *back_msg_action );
    		msg_type = GMYTH_BACKEND_PROGRAM_INFO_CHANGED;
    	} else if ( g_strstr_len( *back_msg_action, strlen( *back_msg_action ), "DONE_RECORDING" ) ) {
    		gmyth_debug( "MONITOR: message type == GMYTH_BACKEND_DONE_RECORDING, msg = %s", *back_msg_action );
    		msg_type = GMYTH_BACKEND_DONE_RECORDING;
    	}    	  	

      //g_hash_table_insert ( monitor->backend_msgs,
      //                       &(monitor->actual_index), *back_msg_action );
	    
	  } // if
	}
	
	if ( back_msg != NULL )
	{
		g_string_free( back_msg, TRUE );
		back_msg = NULL;        	
	}
	
	return msg_type;

}

static void
gmyth_monitor_handler_default_listener( GMythMonitorHandler *monitor, gint msg_code, gchar* message )
{
	//assert( message!= NULL );  
	gmyth_debug( "DEFAULT Signal handler ( msg = %s, code = %d )\n", 
				message, msg_code );
}

static void
gmyth_monitor_handler_print( GString *str, gpointer ptr )
{
	gmyth_debug( "Backend message event: %s --- ", str->str );
}

//static void
//gmyth_monitor_handler_listener (GMythMonitorHandler *monitor, gpointer user_data)
//static gboolean
//gmyth_monitor_handler_listener( GIOChannel *io_channel, GIOCondition condition, gpointer data )
//gboolean* gmyth_monitor_handler_listener( GMythMonitorHandler *monitor )
void
gmyth_monitor_handler_listener (GMythMonitorHandler *monitor, gpointer user_data)
{
	//GMythMonitorHandler *monitor = (GMythMonitorHandler*)data; 
  GIOStatus io_status;
  GIOCondition io_cond;  
  guint recv = 0;
  gboolean *ret = g_new0( gboolean, 1 );
  *ret = TRUE;
  //gboolean ret = TRUE;
  gsize len = 0;
  
  static guint count = 0;
  
  GIOChannel *io_channel = monitor->event_sock->sd_io_ch;
  //GIOCondition condition = g_io_channel_get_buffer_condition( io_channel );
  
  GMythStringList *strlist = NULL;
  
  //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 (monitor->allow_msgs_listener) {
  	++count;
  	
  	gmyth_debug ("%d - Listening on Monitor socket...!\n", count);
	
    do 
    {
    	
    	gint bytes_sent = 0;
    	
    	strlist = gmyth_string_list_new();
    	
    	if ( monitor->event_sock != NULL )
    	{
    		
	      len = gmyth_socket_read_stringlist( monitor->event_sock, strlist );
	      
		    if ( strlist != NULL && gmyth_string_list_length( strlist ) > 0 ) 
		    { 
			    bytes_sent = gmyth_string_list_get_int( strlist,  0 ); // -1 on backend error
	
		      gmyth_debug ( "[%s] MONITOR: received data buffer from IO event channel... %d strings gone!\n", 
		      		__FUNCTION__, len );
		      		
		      recv += len;
		      
		      /* debug purpose: prints out all the string list elements */
		      g_list_foreach( strlist->glist, (GFunc)gmyth_monitor_handler_print, NULL );
		      
		      gchar *back_msg_action = g_new0( gchar, 1 );
		      gint msg_type = gmyth_monitor_handler_is_backend_message( monitor, strlist, 
		      		&back_msg_action );
		      
	        g_signal_emit ( monitor,
	               GMYTH_MONITOR_HANDLER_GET_CLASS (monitor)->backend_events_handler_signal_id,
	               0, /* details */
	               msg_type, back_msg_action );
	               
	        if (back_msg_action!= NULL)
	        	g_free( back_msg_action );
		      
		    }
		    
    	}
	    
	    if (strlist!=NULL)
	    	g_object_unref( strlist );
      	
      io_cond = g_io_channel_get_buffer_condition( io_channel );

    } while ( recv <= 0 && ( io_cond & G_IO_IN ) != 0 );
    
    gmyth_debug ("[%s]\tMONITOR EVENT: Read %d bytes\n", __FUNCTION__, recv );

	  g_usleep( 300 );
	  
  } /* main GThread while */
  
  myth_control_release_context ();
  
  if ( io_status == G_IO_STATUS_ERROR ) {
    //gmyth_debug ("[%s] Error reading: %s\n", __FUNCTION__, error != NULL ? error->message : "" );
    gmyth_debug ("Error reading MONITOR event socket.\n");
   	*ret = FALSE;
   	goto clean_up;   	
  }
  
clean_up:

  if (strlist!=NULL)
  	g_object_unref( strlist );
  	
 	return;

}

static gboolean
gmyth_connect_to_backend_monitor (GMythMonitorHandler *monitor)
{
  gboolean ret = TRUE;

  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*
gmyth_monitor_handler_setup( GMythMonitorHandler *monitor, 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, 
    					(GIOFunc)gmyth_monitor_handler_listener, monitor );
  } else {
  	*ret = FALSE;
  	goto cleanup;
  }

  //g_source_set_callback ( source, (GSourceFunc)gmyth_monitor_handler_listener, NULL, NULL );

  //g_source_attach( source, io_watcher_context );
  
  //if (NULL == source){
  if (src_id < 0){
    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->monitor_th = g_thread_pool_new( (GThreadFunc)gmyth_monitor_handler_listener, 
  					monitor, TRUE, NULL );
 */				
  monitor->monitor_th = g_thread_pool_new( (GFunc)gmyth_monitor_handler_listener, 
  					monitor, 3, TRUE, NULL );
  g_thread_pool_push( monitor->monitor_th, monitor, NULL ); 
  					
  //if ( ( ret = g_thread_join( monitor_th ) ) == FALSE )
  if ( monitor->monitor_th != NULL )
  //if ( gmyth_monitor_handler_setup( monitor, monitor->event_sock->sd_io_ch ) )
  {
  	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;
  }
  
}