/**

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

    if (tmp_str != NULL)

        g_string_free(tmp_str, TRUE);

    if (date != NULL)

        g_free(date);

    // if ( tm != NULL)

    // g_free (tm);

    return program_info;

}

/**

 * Requests the program info from the MythTV backend server, based on its 

 * channel name.

 * 

 * @param recorder The GMythRecorder instance.

 * @return The GMythProgramInfo next program info instance.

 */

GMythProgramInfo *

gmyth_recorder_get_program_info_from_channel_name(GMythRecorder * recorder,

                                                  const gchar * channel)