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

     gboolean        list_rules;

     gboolean        list_upcoming;

 } 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 = 6543;

     gint            db_port = 0;

     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, &options->list_channels,

          "List channels", NULL},

         {"list_rules", 'r', 0, G_OPTION_ARG_NONE, &options->list_rules,

          "List recording rules", NULL},

         {"list_upcoming", 'u', 0, G_OPTION_ARG_NONE, &options->list_upcoming,

          "List upcoming recordings", NULL},

         {"username", 'n', 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 mythtv recorded programs etc.");

     g_option_context_add_main_entries(context, entries, NULL);

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

     g_option_context_free(context);

     if (error) {

         g_printerr("%s.\n", error->message);

         g_error_free(error);

         g_free(host_ip);

         return FALSE;

     }

     if (!!options->list_channels + !!options->list_rules +

       !!options->list_upcoming > 1) {

         g_printerr("Only one --list option may be given.\n");

         g_free(host_ip);

         return FALSE;

     }

     gmyth_backend_info_set_hostname(options->b_info,

       host_ip ? host_ip : "localhost");

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

     g_free(host_ip);

     return TRUE;

 }

 static gboolean

 _ls_recording_rules(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_schedule_list(scheduler, &list);

     gmyth_scheduler_disconnect(scheduler);

     g_object_unref(scheduler);

     if (res < 0) {

         g_print("Could not retrieve list of recording rules.\n");

         return FALSE;

     }

     iter = list;

     while (iter) {

         ScheduleInfo   *schedule_info = (ScheduleInfo *) iter->data;

         count++;

         g_print("%s\n", schedule_info->title->str);

         gmyth_schedule_info_free(schedule_info);

         iter = g_list_next(iter);

     }

     if (!count)

         g_print("No recording rules.\n");

     g_list_free(list);

     return TRUE;

 }

 static gboolean

 _ls_upcoming_recordings(ls_options_t * options)

 {

     GSList         *list,

                    *iter;

     gint            count = 0;

     gboolean        conflicts;

     time_t          recstart;

     struct tm      *tm;

     char            buffer[64];

     g_return_val_if_fail(options != NULL, FALSE);

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

     list = gmyth_util_get_all_pending(options->b_info, &conflicts);

     iter = list;

     while (iter) {

         GMythProgramInfo *program = (GMythProgramInfo *) iter->data;

         if (program->recstatus == GMYTH_REC_STATUS_RECORDING ||

           program->recstatus == GMYTH_REC_STATUS_WILL_RECORD) {

             count++;

             recstart = program->recstartts->tv_sec;

             tm = localtime(&recstart);

             strftime(buffer, sizeof(buffer), "%F %R", tm);

             g_print("%s %s", buffer, program->title->str);

             if (program->subtitle->len)

                 g_print(": %s", program->subtitle->str);

             g_print("\n");

         }

         g_object_unref(program);

         iter = g_slist_next(iter);

     }

     if (!count)

         g_print("No upcoming recordings.\n");

     else if (conflicts)

         g_print("Conflicts found.\n");

     else

         g_print("No conflicts found.\n");

     g_slist_free(list);

     return TRUE;

 }

 static          gboolean

 _ls_recorded_files(ls_options_t * options)

 {

     GMythScheduler *scheduler;

     GList          *list,

                    *iter;

     gint            res = 0,

                     count = 0;

     GMythSocket    *socket;

     GString        *path;

     GMythProgramInfo *program;

     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;

     socket = gmyth_backend_info_get_connected_socket(options->b_info);

     while (iter) {

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

         program = gmyth_program_info_new();

         program->pathname = g_string_new(recorded_info->basename->str);

         program->channel_id = recorded_info->channel_id;

         program->recstartts = g_memdup(recorded_info->start_time,

                                        sizeof(*program->startts));

         path = gmyth_util_check_file_from_socket(socket, program);

         if (path) {

             count++;

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

             g_string_free(path, TRUE);

         }

         gmyth_recorded_info_free(recorded_info);

         g_object_unref(program);

         iter = g_list_next(iter);

     }

     g_object_unref(socket);

     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 if (options->list_rules)

         res = _ls_recording_rules(options);

     else if (options->list_upcoming)

         res = _ls_upcoming_recordings(options);

     else

         res = _ls_recorded_files(options);

     _ls_options_free(options);

     return 0;

 }