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

}