/**

 * GMyth Library

 *

 * @file gmyth/gmyth_recorder.c

 * 

 * @brief <p> GMythRecorder defines functions for playing live tv.

 *

 * The remote encoder is used by gmyth_tvplayer to setup livetv. 

 *

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

 * @author Hallyson Luiz de Morais Melo <hallyson.melo@indt.org.br>

 * @author Rosfran 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

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gmyth_recorder.h"

#include <assert.h>

#include "gmyth_stringlist.h"

#include "gmyth_util.h"

#include "gmyth_common.h"

#include "gmyth_debug.h"

#define	 GMYTHTV_RECORDER_HEADER			"QUERY_RECORDER"

static void gmyth_recorder_class_init(GMythRecorderClass * klass);

static void gmyth_recorder_init(GMythRecorder * object);

static void gmyth_recorder_dispose(GObject * object);

static void gmyth_recorder_finalize(GObject * object);

G_DEFINE_TYPE(GMythRecorder, gmyth_recorder, G_TYPE_OBJECT)

	 static void gmyth_recorder_class_init(GMythRecorderClass * klass)

{

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  gobject_class->dispose = gmyth_recorder_dispose;

  gobject_class->finalize = gmyth_recorder_finalize;

}

static void

gmyth_recorder_init(GMythRecorder * gmyth_remote_encoder)

{

}

static void

gmyth_recorder_dispose(GObject * object)

{

  GMythRecorder *recorder = GMYTH_RECORDER(object);

  gmyth_recorder_close(recorder);

  if (recorder->mutex != NULL)

	{

	  g_mutex_free(recorder->mutex);

	  recorder->mutex = NULL;

	}

  if (recorder->myth_socket != NULL)

	{

	  g_object_unref(recorder->myth_socket);

	  recorder->myth_socket = NULL;

	}

  if (recorder->progs_info_list != NULL)

	gmyth_free_program_list(recorder->progs_info_list);

  if (recorder->hostname != NULL)

	g_string_free(recorder->hostname, TRUE);

  G_OBJECT_CLASS(gmyth_recorder_parent_class)->dispose(object);

}

static void

gmyth_recorder_finalize(GObject * object)

{

  g_signal_handlers_destroy(object);

  G_OBJECT_CLASS(gmyth_recorder_parent_class)->finalize(object);

}

void

gmyth_recorder_close(GMythRecorder * recorder)

{

  if (recorder != NULL && recorder->recorder_num != -1)

	{

	  g_mutex_lock(recorder->mutex);

	  gmyth_recorder_stop_playing(recorder);

	  gmyth_recorder_stop_livetv(recorder);

	  gmyth_recorder_finish_recording(recorder);

	  gmyth_recorder_free_tuner(recorder);

	  g_mutex_unlock(recorder->mutex);

	}

}

/** Creates a new instance of GMythRecorder.

 * 

 * @return a new instance of GMythRecorder.

 */

GMythRecorder *

gmyth_recorder_new(int num, GString * hostname, gshort port)

{

  GMythRecorder *encoder =

	GMYTH_RECORDER(g_object_new(GMYTH_RECORDER_TYPE, FALSE));

  encoder->recorder_num = num;

  encoder->hostname = g_string_new(hostname->str);

  encoder->port = port;

  encoder->mutex = g_mutex_new();

  encoder->progs_info_list = NULL;

  return encoder;

}

/** Configures the remote encoder instance connecting it to Mythtv backend.

 * 

 * @param recorder the GMythRecorder instance.

 * 

 * @return TRUE if successfull, FALSE if any error happens.

 */

gboolean

gmyth_recorder_setup(GMythRecorder * recorder)

{

  assert(recorder);

  gmyth_debug("[%s] Creating socket and connecting to backend", __FUNCTION__);

  if (recorder->myth_socket == NULL)

	{

	  recorder->myth_socket = gmyth_socket_new();

	  if (!gmyth_socket_connect_to_backend(recorder->myth_socket,

										   recorder->hostname->str,

										   recorder->port, TRUE))

		{

		  gmyth_debug("GMythRemoteEncoder: Connection to backend failed");

		  return FALSE;

		}

	}

  else

	{

	  gmyth_debug("Remote encoder socket already created\n");

	}

  return TRUE;

}

/** Sends the SPAWN_LIVETV command through Mythtv protocol. This command

 * requests the backend to start capturing TV content.

 * 

 * @param recorder The GMythRecorder instance.

 * @param tvchain_id The tvchain unique id.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_spawntv(GMythRecorder * recorder, GString * tvchain_id)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] Spawntv with tvchain_id = %s", __FUNCTION__,

			  tvchain_id->str);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "SPAWN_LIVETV");

  gmyth_string_list_append_string(str_list, tvchain_id);

  gmyth_string_list_append_int(str_list, 0);	// PIP = FALSE (0)

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] Spawntv request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2))

	{

	  gmyth_debug("[%s] Spawntv request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** 

 * Sends the SPAWN_LIVETV command through Mythtv protocol. This command

 * requests the backend to start capturing TV content, but it doesn't need

 * the TV chain ID.

 * 

 * @param recorder The GMythRecorder instance.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_spawntv_no_tvchain(GMythRecorder * recorder)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] Spawntv, no TV chain!", __FUNCTION__);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "SPAWN_LIVETV");

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] Spawntv request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2))

	{

	  gmyth_debug("[%s] Spawntv request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** Sends the command STOP_LIVETV to Mythtv backend.

 * 

 * @param recorder the GMythRecorder instance.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_stop_livetv(GMythRecorder * recorder)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s]", __FUNCTION__);

  str_list = gmyth_string_list_new();

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "STOP_LIVETV");

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2))

	{

	  gmyth_debug("[%s] Stop livetv request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** Sends the FRONTEND_READY command through Mythtv protocol. This command

 * advertises the backend to start capturing TV content.

 * 

 * @param recorder The GMythRecorder instance.

 * @return TRUE if success, FALSE if any error happens.

 */

gboolean

gmyth_recorder_send_frontend_ready_command(GMythRecorder * recorder)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] FRONTEND_READY with recorder id = %d", __FUNCTION__,

			  recorder->recorder_num);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "FRONTEND_READY");

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug

		("[%s] FRONTEND_READY command request couldn't returns, reason: %s",

		 __FUNCTION__, tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2))

	{

	  gmyth_debug("[%s] FRONTEND_READY request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** Send a CHECK_CHANNEL command request to the backend, in order to find if a 

 * certain channel actually exists.

 * 

 * @param recorder The GMythRecorder instance.

 * @param channel	 The new channel to be checked (string format).

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_check_channel_name(GMythRecorder * recorder, gchar * channel)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] CHECK_CHANNEL with channel = %s", __FUNCTION__, channel);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "CHECK_CHANNEL");

  gmyth_string_list_append_char_array(str_list, channel);

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] CHECK_CHANNEL request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2) == 0

	  || g_ascii_strncasecmp(tmp_str->str, "0", 1) == 0)

	{

	  gmyth_debug("[%s] CHECK_CHANNEL request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** Send a CHECK_CHANNEL command request to the backend, in order to find if a 

 * certain channel actually exists.

 * 

 * @param recorder The GMythRecorder instance.

 * @param channel	 The new channel to be checked (decimal integer value).

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_check_channel(GMythRecorder * recorder, gint channel)

{

  return gmyth_recorder_check_channel_name(recorder, g_strdup_printf("%d",

																	 channel));

}

/** Send a SET_CHANNEL command request to the backend, to start streaming on another 

 * TV content channel.

 * 

 * @param recorder The GMythRecorder instance.

 * @param channel	 The new channel to be loaded.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_set_channel(GMythRecorder * recorder, gint channel)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] SET_CHANNEL with channel = %d", __FUNCTION__, channel);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "SET_CHANNEL");

  gmyth_string_list_append_int(str_list, channel);

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] SET_CHANNEL request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2))

	{

	  gmyth_debug("[%s] SET_CHANNEL request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** Send a SET_CHANNEL command request to the backend, to start streaming on another 

 * TV content channel.

 * 

 * @param recorder The GMythRecorder instance.

 * @param channel	 The new channel to be loaded.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_set_channel_name(GMythRecorder * recorder,

								const gchar * channel)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] SET_CHANNEL with channel name = %s", __FUNCTION__,

			  channel);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "SET_CHANNEL");

  gmyth_string_list_append_char_array(str_list, channel);

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] SET_CHANNEL name request returned NULL!",

				  __FUNCTION__);

	  ret = FALSE;

	  goto cleanup;

	}

  if (tmp_str != NULL && g_ascii_strncasecmp(tmp_str->str, "ok", 2)

	 /*|| g_ascii_strtoull( tmp_str->str, NULL, 10 ) == 0 */

	)

	{

	  g_warning("[%s] SET_CHANNEL name request returned not ok",

				__FUNCTION__);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/**

 * Changes the channel of the actual Recorder.

 * 

 * CHANNEL_DIRECTION_UP       - Go up one channel in the listing

 *

 * CHANNEL_DIRECTION_DOWN     - Go down one channel in the listing

 *

 * CHANNEL_DIRECTION_FAVORITE - Go to the next favorite channel

 *

 * CHANNEL_DIRECTION_SAME     - Stay

 * 

 * @param recorder 	 The GMythRecorder instance.

 * @param direction	 The new channel direction where to move to.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_change_channel(GMythRecorder * recorder,

							  const GMythRecorderChannelChangeDirection

							  direction)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] CHANGE_CHANNEL to the channel direction = %u",

			  __FUNCTION__, direction);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "CHANGE_CHANNEL");

  gmyth_string_list_append_int(str_list, direction);

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] CHANGE_CHANNEL name request returned %s",

				  __FUNCTION__, tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2)

	  || g_ascii_strtoull(tmp_str->str, NULL, 10) == 0)

	{

	  gmyth_debug("[%s] CHANGE_CHANNEL name request returned %s",

				  __FUNCTION__, tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

/** 

 * Gets the channel's list from the MythTV backend server.

 * 

 * @param recorder The GMythRecorder instance.

 * 

 * @return a GList* instance with all the channel names.

 */

GList *

gmyth_recorder_get_channel_list(GMythRecorder * recorder)

{

  GList *channel_list = NULL;

  gchar *channel = NULL;

  guint i;

  for (i = 0; i < 1000; i++)

	{

	  channel = g_strdup_printf("%u", i);

	  if (gmyth_recorder_check_channel_name(recorder, channel))

		{

		  channel_list = g_list_append(channel_list, g_strdup(channel));

		}

	}							/* for - channel list */

  g_free(channel);

  return channel_list;

}

/** Send a PAUSE command request to the backend, to pause streaming on another 

 * TV content channel.

 * 

 * @param recorder The GMythRecorder instance.

 * @return true if success, false if any error happens.

 */

gboolean

gmyth_recorder_pause_recording(GMythRecorder * recorder)

{

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gboolean ret = TRUE;

  gmyth_debug("[%s] PAUSE", __FUNCTION__);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  g_string_free(tmp_str, TRUE);

  gmyth_string_list_append_char_array(str_list, "PAUSE");

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  tmp_str = gmyth_string_list_get_string(str_list, 0);

  if (tmp_str == NULL)

	{

	  gmyth_debug("[%s] PAUSE name request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

  if (g_ascii_strncasecmp(tmp_str->str, "ok", 2))

	{

	  gmyth_debug("[%s] PAUSE name request returned %s", __FUNCTION__,

				  tmp_str->str);

	  ret = FALSE;

	  goto cleanup;

	}

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return ret;

}

static gboolean

gmyth_recorder_find_if_program_exists(GMythRecorder * recorder,

									  GMythProgramInfo * prog)

{

  GList *lst = NULL;

  g_return_val_if_fail(recorder != NULL

					   && recorder->progs_info_list != NULL, FALSE);

  for (lst = recorder->progs_info_list; lst != NULL; lst = g_list_next(lst))

	{

	  gmyth_debug("Got program info from list = [%s]",

				  gmyth_program_info_to_string((GMythProgramInfo *)

											   lst->data));

	  if (gmyth_program_info_is_equals(prog, (GMythProgramInfo *) lst->data))

		return TRUE;

	}

  return FALSE;

}

/**

 * Requests the actual program info from the MythTV backend server.

 * 

 * @param recorder The GMythRecorder instance.

 * @return The actual program info.

 */

GMythProgramInfo *

gmyth_recorder_get_current_program_info(GMythRecorder * recorder)

{

  GMythStringList *str_list = NULL;

  GMythProgramInfo *program_info = NULL;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  gmyth_string_list_append_string(str_list, tmp_str);

  if (recorder->myth_socket->mythtv_version >= 26)

	gmyth_string_list_append_char_array(str_list, "GET_CURRENT_RECORDING");

  else

	gmyth_string_list_append_char_array(str_list, "GET_PROGRAM_INFO");

  gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list);

  if (str_list == NULL)

	{

	  gmyth_debug

		("[%s] GET_PROGRAM_INFO request returned. Error getting program info, string list equals to NULL!",

		 __FUNCTION__);

	  goto cleanup;

	}

  program_info = gmyth_program_info_from_string_list(str_list);

  if (NULL == program_info || NULL == program_info->pathname

	  || program_info->pathname->len <= 0)

	{

	  gmyth_debug

		("GET_PROGRAM_INFO request returned. Error getting program info, it is equals to NULL!!!");

	  if (program_info)

		g_object_unref(program_info);

	  program_info = NULL;

	  goto cleanup;

	}

  if (!gmyth_recorder_find_if_program_exists(recorder, program_info))

	recorder->progs_info_list = g_list_append(recorder->progs_info_list,

											  g_object_ref(program_info));

cleanup:

  g_mutex_unlock(recorder->mutex);

  g_string_free(tmp_str, TRUE);

  g_object_unref(str_list);

  return program_info;

}

/**

 * Requests the actual program info from the MythTV backend server.

 * 

 * @param rec_id The GMythRecorder record number.

 * @return The GMythRecorder instance.

 */

GMythRecorder *

gmyth_recorder_get_recorder_from_num(gint rec_id)

{

  GMythRecorder *recorder = NULL;

  GMythStringList *str_list;

  GString *tmp_str = g_string_new("GET_RECORDER_FROM_NUM");

  gint command_size = 0;

  gchar *recorder_host = NULL;

  gint recorder_port;

  str_list = gmyth_string_list_new();

 /* g_string_append_printf ( tmp_str, " %d", recorder->recorder_num ); */

  g_mutex_lock(recorder->mutex);

  gmyth_string_list_append_string(str_list, tmp_str);

  gmyth_string_list_append_int(str_list, rec_id);

  command_size = gmyth_socket_sendreceive_stringlist(recorder->myth_socket,

													 str_list);

  if (str_list == NULL)

	{

	  gmyth_debug

		("[%s] GET_RECORDER_FROM_NUM request returned. Error getting recorder number %d, it is equals to NULL!!!",

		 __FUNCTION__, rec_id);

	  return NULL;

	}

  if (command_size > 0)

	{

	  recorder_host = gmyth_string_list_get_char_array(str_list, 0);

	  recorder_port = gmyth_string_list_get_int(str_list, 1);

	  if (g_strstr_len(recorder_host, strlen(recorder_host), "nohost")

		  != NULL)

		{

		  gmyth_debug

			("No available recorder with the recorder ID number %d!", rec_id);

		}

	  else

		{

		  recorder = gmyth_recorder_new(rec_id,

										g_string_new(recorder_host),

										(gshort) recorder_port);

		  if (NULL == recorder)

			{

			  gmyth_debug

				("[%s] GET_RECORDER_FROM_NUM request returned. Error getting recorder number %d, it is equals to NULL!!!",

				 __FUNCTION__, rec_id);

			  g_object_unref(recorder);

			  return NULL;

			}

		}

	}

  else

	{

	  gmyth_debug

		("Cannot find a valuable recorder with the recorder ID number %d, backend server error!",

		 rec_id);

	}

  g_mutex_unlock(recorder->mutex);

  g_object_unref(str_list);

  g_string_free(tmp_str, TRUE);

  g_free(recorder_host);

  return recorder;

}

/**

 * Requests the actual program info from the MythTV backend server.

 * 

 * @param recorder The GMythRecorder instance.

 * @param direction The direction to move based on the current channel (forward, backward,

 *            up, down).

 * 

 * @return The GMythProgramInfo next program info instance.

 */

GMythProgramInfo *

gmyth_recorder_get_next_program_info(GMythRecorder * recorder,

									 const GMythRecorderBrowseDirection

									 direction)

{

  GMythProgramInfo *actual_proginfo = NULL;

  GMythProgramInfo *program_info = NULL;

  GMythStringList *str_list;

  GString *tmp_str = g_string_new(GMYTHTV_RECORDER_HEADER);

  gchar *date = NULL;

  struct tm *tm = NULL;

  time_t t;

  actual_proginfo = gmyth_recorder_get_current_program_info(recorder);

  str_list = gmyth_string_list_new();

  g_mutex_lock(recorder->mutex);

  g_string_append_printf(tmp_str, " %d", recorder->recorder_num);

  t = time(NULL);

  tm = localtime(&t);

  date = g_strdup_printf("%.4d%.2d%.2d%.2d%.2d%.2d", tm->tm_year + 1900,

						 tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,

						 tm->tm_min, tm->tm_sec);

  gmyth_string_list_append_string(str_list, tmp_str);

  gmyth_string_list_append_char_array(str_list, "GET_NEXT_PROGRAM_INFO");

  gmyth_string_list_append_string(str_list, actual_proginfo->channame);

  gmyth_string_list_append_string(str_list, actual_proginfo->chanid);

  gmyth_string_list_append_int(str_list, direction);

  gmyth_string_list_append_char_array(str_list, date);

  if (gmyth_socket_sendreceive_stringlist(recorder->myth_socket, str_list)

	  > 0)

	{

	  if (str_list == NULL)

		{

		  gmyth_debug

			("[%s] GET_NEXT_PROGRAM_INFO request returned. Error getting program info, it is equals to NULL!!!",

			 __FUNCTION__);

		  goto done;

		}

	  program_info = gmyth_program_info_from_string_list_next_prog(str_list);

	  if (NULL == program_info)

		{

		  gmyth_debug

			("[%s] GET_NEXT_PROGRAM_INFO request returned. Error getting next program info, it is equals to NULL!!!",

			 __FUNCTION__);

		  g_object_unref(program_info);

		  goto done;

		}

	  if (						/*( program_info->chanid != NULL && strlen( program_info->chanid->str ) > 0  ) && */

		   (program_info->chansign != NULL

			&& strlen(program_info->chansign->str) > 0))

		{

		  gmyth_debug("OK!!! Got the next program info... [%s].",

					  program_info->chansign->str);

		}

	  else

		{

		  gmyth_debug

			("GET_NEXT_PROGRAM_INFO request returned. Error getting next program info, it is equals to NULL!!!");

		  g_object_unref(program_info);

		  program_info = NULL;

		}

	}

 /* if */

done:

  g_mutex_unlock(recorder->mutex);

  if (actual_proginfo != NULL)

	g_object_unref(actual_proginfo);

  if (str_list != NULL)

	g_object_unref(str_list);