#ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <stdio.h>

 #include <glib.h>

 #include "gmyth_backendinfo.h"

 #include "gmyth_scheduler.h"

 #include "gmyth_util.h"

 #include "gmyth_epg.h"

 typedef struct {

     GMythBackendInfo *b_info;

     gboolean        list_channels;

 } ls_options_t;

 static ls_options_t *

 _ls_options_new()

 {

     ls_options_t   *options = g_new0(ls_options_t, 1);

     options->b_info = gmyth_backend_info_new();

     return options;

 }

 static void

 _ls_options_free(ls_options_t * options)

 {

     g_return_if_fail(options != NULL);

     if (options->b_info)

         g_object_unref(options->b_info);

 }

 static          gboolean

 _parse_args(int argc, char *argv[], ls_options_t * options)

 {

     GError         *error = NULL;

     GOptionContext *context;

     gchar          *host_ip = NULL;

     gint            host_port = 0;

     gint            db_port = 0;

     gboolean        list_channels = FALSE;

     gchar          *username = NULL;

     gchar          *password = NULL;

     GOptionEntry    entries[] = {

         {"hostname", 'h', 0, G_OPTION_ARG_STRING, &host_ip,

          "Mythtv backend hostname or " "IP address", "IP_ADDRESS"},

         {"port", 'p', 0, G_OPTION_ARG_INT, &host_port,

          "Mythtv backend port",

          "PORT"},

         {"list_channels", 'c', 0, G_OPTION_ARG_NONE, &list_channels,

          "List channels",

          "LIST_CHANNELS"},

         {"username", 'u', 0, G_OPTION_ARG_STRING, &username,

          "Mysql database username. Default: mythtv",

          "MYSQL_USER"},

         {"password", 'w', 0, G_OPTION_ARG_STRING, &password,

          "Mysql database password. Default: mythtv",

          "MYSQL_PASSWD"},

         {"db_port", 'P', 0, G_OPTION_ARG_STRING, &db_port,

          "Mysql database port. Default: 0",

          "MYSQL_PORT"},

         {NULL}

     };

     g_return_val_if_fail(options != NULL, FALSE);

     context =

         g_option_context_new

         ("- list recorded programs and channels from a mythtv backend\n");

     g_option_context_add_main_entries(context, entries, NULL);

     g_option_context_parse(context, &argc, &argv, &error);

     g_option_context_set_help_enabled(context, TRUE);

     g_option_context_free(context);

     if ((!host_ip) || (host_port == 0)) {

         g_free(host_ip);

         return FALSE;

     }

     gmyth_backend_info_set_hostname(options->b_info, host_ip);

     gmyth_backend_info_set_port(options->b_info, host_port);

     if (username)

         gmyth_backend_info_set_username(options->b_info, username);

     else

         gmyth_backend_info_set_username(options->b_info, "mythtv");

     if (password)

         gmyth_backend_info_set_password(options->b_info, password);

     else

         gmyth_backend_info_set_password(options->b_info, "mythtv");

     gmyth_backend_info_set_db_name(options->b_info, "mythconverg");

     options->list_channels = list_channels;

     g_free(host_ip);

     return TRUE;

 }

 static          gboolean

 _ls_recorded_files(ls_options_t * options)

 {

     GMythScheduler *scheduler;

     GList          *list,

                    *iter;

     gint            res = 0,

                     count = 0;

     g_return_val_if_fail(options != NULL, FALSE);

     g_return_val_if_fail(options->b_info != NULL, FALSE);

     scheduler = gmyth_scheduler_new();

     if (gmyth_scheduler_connect_with_timeout(scheduler,

                                              options->b_info, 10) == FALSE)

     {

         g_print("Could not connect to database server.\n");

         g_object_unref(scheduler);

         return FALSE;

     }

     res = gmyth_scheduler_get_recorded_list(scheduler, &list);

     gmyth_scheduler_disconnect(scheduler);

     g_object_unref(scheduler);

     if (res < 0) {

         g_print("Could not retrieve list of recorded programs.\n");

         return FALSE;

     }

     iter = list;

     while (iter) {

         RecordedInfo   *recorded_info = (RecordedInfo *) iter->data;

         if (gmyth_util_file_exists

             (options->b_info, recorded_info->basename->str)) {

             count++;

             g_print("%s\n", recorded_info->basename->str);

         }

         gmyth_recorded_info_free(recorded_info);

         iter = g_list_next(iter);

     }

     if (!count)

         g_print("No recorded programs.\n");

     g_list_free(list);

     return TRUE;

 }

 static          gboolean

 _ls_channels(ls_options_t * options)

 {

     GMythEPG       *epg;

     gint            length;

     GList          *clist,

                    *ch;

     g_return_val_if_fail(options != NULL, FALSE);

     g_return_val_if_fail(options->b_info != NULL, FALSE);

     epg = gmyth_epg_new();

     if (!gmyth_epg_connect(epg, options->b_info)) {

         g_object_unref(epg);

         return FALSE;

     }

     length = gmyth_epg_get_channel_list(epg, &clist);

     for (ch = clist; ch != NULL; ch = ch->next) {

         GMythChannelInfo *info = (GMythChannelInfo *) ch->data;

         if ((info->channel_name == NULL) || (info->channel_num == NULL)) {

             continue;

         }

         g_print("%s\t\t%s\n", info->channel_num->str,

                 info->channel_name->str);

     }

     gmyth_free_channel_list(clist);

     gmyth_epg_disconnect(epg);

     g_object_unref(epg);

     return TRUE;

 }

 int

 main(int argc, char *argv[])

 {

     gboolean        res = FALSE;

     ls_options_t   *options;

     g_type_init();

     g_thread_init(NULL);

     options = _ls_options_new();

     res = _parse_args(argc, argv, options);

     if (!res) {

         g_printerr("Argument invalid. Type --help\n");

         return 1;

     }

     if (options->list_channels)

         res = _ls_channels(options);

     else

         res = _ls_recorded_files(options);

     _ls_options_free(options);

     return 0;

 }