/**

  * 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_debug.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

 gpointer gmyth_monitor_handler_listener(gpointer data);

 static void gmyth_monitor_handler_default_listener(GMythMonitorHandler *

 												   monitor, gint msg_code,

 												   gchar * message);

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

 static gboolean gmyth_monitor_handler_setup(GMythMonitorHandler * monitor,

 											GIOChannel * channel);

 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 = FALSE;

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

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

   monitor->mutex = g_mutex_new();

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

   gmyth_monitor_handler_close(monitor);

   monitor->allow_msgs_listener = FALSE;

   if (monitor->th != NULL)

 	{

 	  gboolean *ret = (gboolean *) g_thread_join(monitor->th);

 	  if (*ret == FALSE)

 		gmyth_debug("Error closing GThread listener socket!");

 	  else

 		gmyth_debug("Closed GThread listener socket.");

 	 //g_object_unref( monitor->th );

 	}

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

   if (monitor->mutex != NULL)

 	{

 	 //g_mutex_unlock( monitor->mutex );

 	  g_mutex_free(monitor->mutex);

 	  monitor->mutex = 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 ( 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);

 }

 /** 

  * Creates a new instance of GMyth Monitor Handler.

  * 

  * @return a new instance of the Monitor Handler. 

  */

 GMythMonitorHandler *

 gmyth_monitor_handler_new(void)

 {

   GMythMonitorHandler *monitor =

 	GMYTH_MONITOR_HANDLER(g_object_new(GMYTH_MONITOR_HANDLER_TYPE, FALSE));

   return monitor;

 }

 /** 

  * Acquire the mutex to have access to the IO Watcher listener.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * @param do_wait Tells the IO Watcher to wait on the GCond. (obsolete)

  * 

  * @return <code>true</code>, if the access to IO Watcher was acquired. 

  */

 static gboolean

 myth_control_acquire_context(GMythMonitorHandler * monitor, gboolean do_wait)

 {

   gboolean ret = TRUE;

   g_mutex_lock(monitor->mutex);

   return ret;

 }

 /** 

  * Release the mutex to have access to the IO Watcher listener.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * 

  * @return <code>true</code>, if the access to IO Watcher was released. 

  */

 static gboolean

 myth_control_release_context(GMythMonitorHandler * monitor)

 {

   gboolean ret = TRUE;

   g_mutex_unlock(monitor->mutex);

   return ret;

 }

 void

 gmyth_monitor_handler_close(GMythMonitorHandler * monitor)

 {

   monitor->allow_msgs_listener = FALSE;

 #if 0

   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)

 	{

 	  gmyth_socket_close_connection(monitor->event_sock);

 	}

 #endif

 }

 /** 

  * Opens connection the the Monitor socket on MythTV backend server,

  * where all status messages are notified to the client.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * @param hostname The remote host name of the MythTV backend server.

  * @param port The remote port number of the MythTV backend server.

  * 

  * @return <code>true</code>, if the connection was successfully opened.

  */

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

   if (NULL != monitor->event_sock)

 	{

 	  g_object_unref(monitor->event_sock);

 	  monitor->event_sock = NULL;

 	}

  /* configure the event socket */

   if (NULL == monitor->event_sock)

 	{

 	  if (!gmyth_connect_to_backend_monitor(monitor))

 		{

 		  gmyth_debug("Connection to backend failed (Event Socket)!");

 		  ret = FALSE;

 		}

 	  else

 		{

 		  gmyth_debug

 			("Remote monitor event socket had been succesfully created. (io_fd == %d)\n",

 			 g_io_channel_unix_get_fd(monitor->event_sock->sd_io_ch));

 		}

 	}

   else

 	{

 	  gmyth_debug

 		("ASSERT ERROR: Remote monitor event socket is not NULL at the setup...\n");

 	}

   return ret;

 }

 /** 

  * Reads the data got from the connection to the Monitor socket,

  * and looks for some important status messages.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * @param strlist The GMythStringList instance got from the Monitor remote socket.

  * @param back_msg_action A string pointer to the status message detailed description.

  * 

  * @return The backend status message code ID.

  */

 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;

   if (gmyth_string_list_length(strlist) > 0)

 	{

 	  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;

 				}

 			  else if (g_strstr_len

 					   (*back_msg_action, strlen(*back_msg_action), "QUIT"))

 				{

 				  gmyth_debug

 					("MONITOR: message type == GMYTH_BACKEND_STOP_LIVETV, msg = %s",

 					 *back_msg_action);

 				  msg_type = GMYTH_BACKEND_STOP_LIVETV;

 				}

 			 /* g_hash_table_insert ( monitor->backend_msgs,

 			    &(monitor->actual_index), *back_msg_action ); */

 			}

 		 /*  if  */

 		}

 	 /* if */

 	  if (back_msg != NULL)

 		{

 		  g_string_free(back_msg, TRUE);

 		  back_msg = NULL;

 		}

 	}							/* if - Does Monitor got any message from backend? */

   else

 	{

 	  *back_msg_action = g_strdup("");

 	}

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

 }

 /** 

  * Opens connection the the Monitor socket on MythTV backend server,

  * where all status messages are notified to the client.

  * 

  * @param data Pointer to the GMythMonitorHandler.

  * 

  * @return Pointer to a gboolean <code>true</code> value, if the data was 

  * 	successfully read.

  */

 gpointer

 gmyth_monitor_handler_listener(gpointer data)

 {

   GMythMonitorHandler *monitor = (GMythMonitorHandler *) data;

   guint recv = 0;

   gboolean *ret = g_new0(gboolean, 1);

   gsize len = 0;

   GIOChannel *io_channel = monitor->event_sock->sd_io_ch;

   GIOCondition io_cond = g_io_channel_get_buffer_condition(io_channel);

   static guint count = 0;

   *ret = TRUE;

   gmyth_debug("Entering MONITOR handler listener...");

   myth_control_acquire_context(monitor, TRUE);

   if ((io_cond & G_IO_HUP) != 0)

 	{

 	  *ret = FALSE;

 	  goto clean_up;

 	}

   GMythStringList *strlist = NULL;

   if (NULL == io_channel)

 	{

 	  gmyth_debug("Monitor socket is NULL! (GIOChannel)");

 	  *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 ((len > 0) && 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);

 				  if (monitor != NULL && msg_type != GMYTH_BACKEND_NO_MESSAGE)

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

 			  strlist = NULL;

 			}

 		  io_cond = g_io_channel_get_buffer_condition(io_channel);

 		  g_usleep(500);

 		}

 	  while (recv <= 0 && ((io_cond & G_IO_HUP) == 0));

 	  gmyth_debug("\tMONITOR EVENT: Read %d bytes\n", recv);

 	}							/* main GThread while */

 clean_up:

   myth_control_release_context(monitor);

   g_thread_exit(ret);

   return (gpointer) ret;

 }

 /** 

  * Opens connection events' socket the the Monitor socket on 

  * MythTV backend server.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * 

  * @return <code>true</code>, if the socket was successfully opened.

  */

 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;

 }

 /** 

  * Opens connection the the Monitor socket on MythTV backend server,

  * where all status messages are notified to the client.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * @param channel The GIOChannel instance to the Monitor socket.

  * 

  * @return Pointer to the boolean value, and it is <code>true</code> only if the 

  * 				 GMythMonitorHandler could be configured.

  */

 static gboolean

 gmyth_monitor_handler_setup(GMythMonitorHandler * monitor,

 							GIOChannel * channel)

 {

   gboolean ret = TRUE;

   if (channel != NULL)

 	{

 	  monitor->allow_msgs_listener = TRUE;

 	  monitor->th =

 		g_thread_create((GThreadFunc) gmyth_monitor_handler_listener,

 						monitor, TRUE, NULL);

 	  gmyth_debug("MONITOR GThread created!");

 	}

   else

 	{

 	  ret = FALSE;

 	  goto cleanup;

 	}

   if (NULL == monitor->th)

 	{

 	  gmyth_debug

 		("[%s] Error adding GThread listener function to the IO control channel!\n",

 		 __FUNCTION__);

 	  ret = FALSE;

 	  goto cleanup;

 	}

 cleanup:

   return ret;

 }

 /** 

  * Starts the MonitorHandler thread to the GIOWatcher.

  * 

  * @param monitor The GMythMonitorHandler instance.

  * 

  * @return <code>true</code>, if the MonitorHandler was started.

  */

 gboolean

 gmyth_monitor_handler_start(GMythMonitorHandler * monitor)

 {

   gboolean ret = TRUE;

   if (!(ret = g_thread_supported()))

 	{

 	  gmyth_debug("Thread system wasn't initialized, starting NOW!!!");

 	  g_thread_init(NULL);

 	}

   ret = gmyth_monitor_handler_setup(monitor, monitor->event_sock->sd_io_ch);

   if (ret)

 	{

 	  gmyth_debug

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

 		 __FUNCTION__, g_thread_self());

 	}

   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;

 	}

   gmyth_debug

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

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

   return ret;

 }