/**

 * GMyth Library

 *

 * @file gmyth/gmyth_scheduler.c

 *

 * @brief <p> The scheduler encapsulates all functions for browsing, scheduling

 * and modifying the recorded content.

 *

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

 * @author Alexsandro Jose Virginio dos Santos <alexsandro.santos@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 <assert.h>

#include <glib.h>

#include <glib/gprintf.h>

#include "gmyth_scheduler.h"

#include "gmyth_util.h"

#include "gmyth_query.h"

#include "gmyth_socket.h"

#include "gmyth_debug.h"

#include "gmyth_remote_util.h"

static void     gmyth_scheduler_class_init(GMythSchedulerClass * klass);

static void     gmyth_scheduler_init(GMythScheduler * object);

static void     gmyth_scheduler_dispose(GObject * object);

static void     gmyth_scheduler_finalize(GObject * object);

static gint

gmyth_scheduler_is_program_live_recorded (GMythScheduler * scheduler,

                                          ScheduleInfo *schedule_info,

                                          GMythProgramInfo **prog_info);

static gboolean

gmyth_scheduler_set_live_record (GMythScheduler * scheduler,

                                ScheduleInfo * schedule_info,

                                gint recorder_num, gboolean enable);

static gboolean

gmyth_scheduler_change_record_group (GMythScheduler* scheduler,

                                     GMythProgramInfo *prog_info,

                                     gchar *new_group);

static gint

gmyth_scheduler_query_schedule_list (GMythScheduler * scheduler,

                                     GList ** schedule_list,

                                     gchar *filter);

static gint 

gmyth_scheduler_query_schedule_id (GMythScheduler *scheduler,

                                   GMythProgramInfo *prog_info);

static gint gmyth_scheduler_query_old_schedule (GMythScheduler *scheduler,

                                    gint channel_id, GTimeVal *startts,

                                    gboolean reactivate);

static gboolean update_backend(GMythScheduler * scheduler, gint record_id);

G_DEFINE_TYPE(GMythScheduler, gmyth_scheduler, G_TYPE_OBJECT)

    static void     gmyth_scheduler_class_init(GMythSchedulerClass * klass)

{

    GObjectClass   *gobject_class;

    gobject_class = (GObjectClass *) klass;

    gobject_class->dispose = gmyth_scheduler_dispose;

    gobject_class->finalize = gmyth_scheduler_finalize;

}

static void

gmyth_scheduler_init(GMythScheduler * sched)

{

    sched->recordid = 0;

    sched->type = 0;

    sched->search = 0;

    sched->profile = g_string_new("");

    sched->dupin = 0;

    sched->dupmethod = 0;

    sched->autoexpire = 0;

    sched->autotranscode = 0;

    sched->transcoder = 0;

    sched->autocommflag = 0;

    sched->autouserjob1 = 0;

    sched->autouserjob2 = 0;

    sched->autouserjob3 = 0;

    sched->autouserjob4 = 0;

    sched->startoffset = 0;

    sched->endoffset = 0;

    sched->maxepisodes = 0;

    sched->maxnewest = 0;

    sched->recpriority = 0;

    sched->recgroup = g_string_new("");

    sched->playgroup = g_string_new("");

    sched->prefinput = 0;

    sched->inactive = 0;

    sched->search_type = g_string_new("");

    sched->search_what = g_string_new("");

    sched->msqlquery = gmyth_query_new();

}

static void

gmyth_scheduler_dispose(GObject * object)

{

    GMythScheduler *scheduler = GMYTH_SCHEDULER(object);

    if (scheduler->backend_info) {

        g_object_unref(scheduler->backend_info);

        scheduler->backend_info = NULL;

    }

    if (scheduler->msqlquery) {

        g_object_unref(scheduler->msqlquery);

        scheduler->msqlquery = NULL;

    }

    g_string_free(scheduler->profile, TRUE);

    g_string_free(scheduler->recgroup, TRUE);

    g_string_free(scheduler->playgroup, TRUE);

    g_string_free(scheduler->search_type, TRUE);

    g_string_free(scheduler->search_what, TRUE);

    G_OBJECT_CLASS(gmyth_scheduler_parent_class)->dispose(object);

}

static void

gmyth_scheduler_finalize(GObject * object)

{

    g_signal_handlers_destroy(object);

    G_OBJECT_CLASS(gmyth_scheduler_parent_class)->finalize(object);

}

/** Creates a new instance of GMythScheduler.

 * 

 * @return a new instance of GMythScheduler.

 */

GMythScheduler *

gmyth_scheduler_new()

{

    GMythScheduler *scheduler =

        GMYTH_SCHEDULER(g_object_new(GMYTH_SCHEDULER_TYPE, NULL));

    return scheduler;

}

gboolean

gmyth_scheduler_connect(GMythScheduler * scheduler,

                        GMythBackendInfo * backend_info)

{

    return gmyth_scheduler_connect_with_timeout(scheduler, backend_info,

                                                0);

}

/** Connects to the Mysql database in the backend. The backend address

 * is loaded from the GMythSettings instance.

 *

 * @param scheduler the GMythScheduler instance to be connected.

 * @return true if connection was success, false if failed.

 */

gboolean

gmyth_scheduler_connect_with_timeout(GMythScheduler * scheduler,

                                     GMythBackendInfo * backend_info,

                                     guint timeout)

{

    assert(scheduler);

    g_return_val_if_fail(backend_info != NULL, FALSE);

    if (scheduler->backend_info)

        g_object_unref(scheduler->backend_info);

    scheduler->backend_info = g_object_ref(backend_info);

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] GMythScheduler db initializing", __FUNCTION__);

        scheduler->msqlquery = gmyth_query_new();

    }

    if (!gmyth_query_connect_with_timeout(scheduler->msqlquery,

                                          scheduler->backend_info,

                                          timeout)) {

        g_warning("[%s] Error while connecting to db", __FUNCTION__);

        return FALSE;

    }

    return TRUE;

}

gboolean

gmyth_scheduler_is_connected (GMythScheduler *scheduler)

{

    g_return_val_if_fail (scheduler != NULL, FALSE);

    return gmyth_query_is_alive (scheduler->msqlquery);

}

/** Disconnects from the Mysql database in the backend.

 *

 * @param scheduler the GMythScheduler instance to be disconnected

 * @return true if disconnection was success, false if failed.

 */

gboolean

gmyth_scheduler_disconnect(GMythScheduler * scheduler)

{

    assert(scheduler);

    if (scheduler->msqlquery != NULL) {

        gmyth_query_disconnect(scheduler->msqlquery);

    }

    return TRUE;

}

/** Retrieves from the backend Mysql database the list of recording schedules.

 * 

 * @param scheduler The GMythScheduler instance.

 * @param schedule_list the GList pointer to be filled with the loaded list of ScheduleInfo items.

 * @return The amount of schedules retrieved from database, or -1 if error.

 */

gint

gmyth_scheduler_get_schedule_list (GMythScheduler * scheduler,

                                   GList ** schedule_list)

{

    return gmyth_scheduler_query_schedule_list (scheduler, schedule_list, NULL);

}

ScheduleInfo*

gmyth_scheduler_get_schedule (GMythScheduler * scheduler, gint sched_id)

{

    GList *sched_list = NULL;

    ScheduleInfo *schedule = NULL;

    gchar *filter;

    gint count;

    filter = g_strdup_printf ("WHERE recordid=%d", sched_id);

    count = gmyth_scheduler_query_schedule_list (scheduler, &sched_list, filter);

    if ((count > 0) && (sched_list != NULL)) {

        schedule = (ScheduleInfo*) sched_list->data;

	g_list_free (sched_list);

    }

    g_free (filter);

    return schedule;

}

static gint

gmyth_scheduler_query_schedule_list (GMythScheduler * scheduler,

		                     GList ** schedule_list,

				     gchar *filter)

{

    ScheduleInfo   *schedule;

    MYSQL_RES      *msql_res;

    GString        *query_str = g_string_new("");

    gchar          *date_time = NULL;

    assert(scheduler);

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] Scheduler db connection not initialized",

                  __FUNCTION__);

        return -1;

    }

    if (filter == NULL) {

        g_string_printf(query_str,

                        "SELECT recordid,programid,chanid,starttime,startdate,"

                        "endtime,enddate,title,subtitle,description,category,type,parentid,seriesid FROM record;");

    } else {

        g_string_printf(query_str,

                        "SELECT recordid,programid,chanid,starttime,startdate,"

                        "endtime,enddate,title,subtitle,description,category,type,parentid,seriesid FROM record "

			"%s;", filter);

    }

    msql_res =

        gmyth_query_process_statement(scheduler->msqlquery,

                                      query_str->str);

    if (msql_res == NULL) {

        g_warning("DB retrieval of schedule list failed");

        return -1;

    } else {

        MYSQL_ROW       row;

        *schedule_list = NULL;

        while ((row = mysql_fetch_row(msql_res)) != NULL) {

            schedule = g_new0(ScheduleInfo, 1);

            gint type = 0;

            schedule->schedule_id =

                (guint) g_ascii_strtoull(row[0], NULL, 10);

            schedule->program_id = g_string_new (row[1]);

            schedule->channel_id = (gint) g_ascii_strtoull (row[2], NULL, 10);

            /*

             * generate a time_t from a time and a date db field 

             */

            date_time = g_strdup_printf("%sT%s", row[4], row[3]);

            schedule->start_time =

                gmyth_util_string_to_time_val(date_time);

            g_free(date_time);

            /*

             * generate a time_t from a time and a date db field 

             */

            date_time = g_strdup_printf("%sT%s", row[6], row[5]);

            schedule->end_time = gmyth_util_string_to_time_val(date_time);

            g_free(date_time);

            schedule->title = g_string_new(row[7]);

            schedule->subtitle = g_string_new(row[8]);

            schedule->description = g_string_new(row[9]);

            schedule->category = g_string_new(row[10]);

            type = g_ascii_strtoull (row[11], NULL, 10);

            if (type == 4) {

                schedule->type = GMYTH_SCHEDULE_ALL_OCCURRENCES;

            } else if (type == 1) {

                schedule->type = GMYTH_SCHEDULE_ONE_OCCURRENCE;

            } else if (type == 8) {

                schedule->type = GMYTH_SCHEDULE_EXCEPTION;

                schedule->parentid = (gint) g_ascii_strtoull (row[12], NULL, 10);

            }

            schedule->seriesid = g_string_new (row[13]);

            (*schedule_list) = g_list_append(*(schedule_list), schedule);

        }

    }

    mysql_free_result(msql_res);

    g_string_free(query_str, TRUE);

    return (*schedule_list == NULL) ? 0 : g_list_length(*schedule_list);

}

/** Retrieves from the backend Mysql database the list of recorded programs.

 * 

 * @param scheduler The GMythScheduler instance.

 * @param recorded_list the GList pointer to be filled with the loaded RecordInfo items.

 * @return The amount of recorded retrieved from database, or -1 if error.

 */

gint

gmyth_scheduler_get_recorded_list(GMythScheduler * scheduler,

                                  GList ** recorded_list)

{

    RecordedInfo   *record;

    MYSQL_RES      *msql_res;

    GString        *query_str = g_string_new("");

    assert(scheduler);

    g_string_printf(query_str,

                    "SELECT recordid,programid,chanid,starttime,progstart,"

                    "endtime,progend,title,subtitle,description,category,"

                    "filesize,basename,seriesid FROM recorded WHERE recgroup != 'LiveTV'");

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] Scheduler db connection not initialized",

                  __FUNCTION__);

        return -1;

    }

    msql_res =

        gmyth_query_process_statement(scheduler->msqlquery,

                                      query_str->str);

    if (msql_res == NULL) {

        g_warning("DB retrieval of recording list failed");

        return -1;

    } else {

        MYSQL_ROW       row;

        (*recorded_list) = NULL;

        while ((row = mysql_fetch_row(msql_res)) != NULL) {

            record = g_new0(RecordedInfo, 1);

            record->record_id = (guint) g_ascii_strtoull(row[0], NULL, 10);

            record->program_id = g_string_new (row[1]);

            record->channel_id = (gint) g_ascii_strtoull(row[2], NULL, 10);

            record->start_time = gmyth_util_string_to_time_val(row[3]);

            record->end_time = gmyth_util_string_to_time_val(row[5]);

            record->title = g_string_new(row[7]);

            record->subtitle = g_string_new(row[8]);

            record->description = g_string_new(row[9]);

            record->category = g_string_new(row[10]);

            record->filesize = g_ascii_strtoull(row[11], NULL, 10);

            record->basename = g_string_new(row[12]);

            record->seriesid = g_string_new(row[13]);

            (*recorded_list) = g_list_append((*recorded_list), record);

        }

    }

    mysql_free_result(msql_res);

    g_string_free(query_str, TRUE);

    return (*recorded_list == NULL) ? 0 : g_list_length(*recorded_list);

}

RecordedInfo*

gmyth_scheduler_get_recorded_info (GMythScheduler *scheduler,

                                   const gchar* basename)

{

    RecordedInfo   *record = NULL;

    MYSQL_RES      *msql_res;

    GString        *query_str = g_string_new("");

    assert(scheduler);

    g_string_printf(query_str,

                    "SELECT recordid,programid,chanid,starttime,progstart,"

                    "endtime,progend,title,subtitle,description,category,"

                    "filesize,basename,seriesid FROM recorded "

                    "WHERE recgroup != 'LiveTV' AND basename = '%s'", basename);

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] Scheduler db connection not initialized", 

                        __FUNCTION__);

        return NULL;

    }

    msql_res =

        gmyth_query_process_statement(scheduler->msqlquery,

                                      query_str->str);

    if (msql_res == NULL) {

        g_warning("DB retrieval of recording list failed");

        return NULL;

    } else {

        MYSQL_ROW       row;

        row = mysql_fetch_row(msql_res);

        if (row != NULL) {

            record = g_new0(RecordedInfo, 1);

            record->record_id = (guint) g_ascii_strtoull(row[0], NULL, 10);

            record->program_id = g_string_new (row[1]);

            record->channel_id = (gint) g_ascii_strtoull(row[2], NULL, 10);

            record->start_time = gmyth_util_string_to_time_val(row[3]);

            record->end_time = gmyth_util_string_to_time_val(row[5]);

            record->title = g_string_new(row[7]);

            record->subtitle = g_string_new(row[8]);

            record->description = g_string_new(row[9]);

            record->category = g_string_new(row[10]);

            record->filesize = g_ascii_strtoull(row[11], NULL, 10);

            record->basename = g_string_new(row[12]);

            record->seriesid = g_string_new(row[13]);

        }

    }

    mysql_free_result(msql_res);

    g_string_free(query_str, TRUE);

    return record;

}

static void

_set_value(GMythQuery * myth_query, char *field, gchar * value,

           gint rec_id)

{

    gchar          *query =

        g_strdup_printf

        ("UPDATE record SET recordid = %d, %s = \"%s\" WHERE recordid = %d;",

         rec_id, field, value, rec_id);

    gmyth_query_process_statement(myth_query, query);

    g_free(query);

}

static void

_set_int_value(GMythQuery * myth_query, char *field, gint value,

               gint rec_id)

{

    gchar *str_value = g_strdup_printf("%d", value);

    _set_value(myth_query, field, str_value, rec_id);

    g_free(str_value);

}

ScheduleInfo*

gmyth_scheduler_add_schedule_program (GMythScheduler * scheduler,

                                      GMythProgramInfo *program,

                                      GMythScheduleType type)

{

    ScheduleInfo *info;

    info = g_new0 (ScheduleInfo, 1);

    info->program_id = g_string_new (program->program_id->str);

    info->channel_id = program->channel_id;

    info->start_time = g_new0 (GTimeVal, 1);

    *info->start_time = *program->startts;

    info->end_time = g_new0 (GTimeVal, 1);

    *info->end_time = *program->endts;

    info->seriesid = g_string_new (program->seriesid->str);

    info->title = g_string_new (program->title->str);

    info->subtitle = g_string_new (program->subtitle->str);

    info->description = g_string_new (program->description->str);

    info->category = g_string_new (program->category->str);

    info->type = type;

    if (gmyth_scheduler_add_schedule_full (scheduler, info, type))

    {

        if (!program->recstartts)

            program->recstartts = g_new0 (GTimeVal, 1);

        *program->recstartts = *info->start_time;

        if (!program->recendts)

            program->recendts = g_new0 (GTimeVal, 1);

        *program->recendts = *info->end_time;

        program->recordid = info->schedule_id;

        return info;

    }

    gmyth_schedule_info_free (info);

    return NULL;

}

gboolean

gmyth_scheduler_add_schedule_full (GMythScheduler * scheduler,

                             ScheduleInfo *schedule_info, GMythScheduleType type)

{

    MYSQL_RES      *msql_res;

    gchar          *query_str = NULL;

    gchar          *station = NULL;

    gulong          rec_id;

    g_return_val_if_fail (IS_GMYTH_SCHEDULER (scheduler), FALSE);

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] Scheduler db connection not initialized",

                  __FUNCTION__);

        return FALSE;

    }

    /*

    if (!gmyth_query_is_alive (scheduler->msqlquery)) {

	g_warning ("[%s] MySql connection is not alive", __FUNCTION__);

        return FALSE;

    }

    */

    {

        /* Before adding the schedule, we need to check if program is been played */

        GMythProgramInfo *prog_info = NULL;

	gint recorder_num = 

                gmyth_scheduler_is_program_live_recorded (scheduler, schedule_info,

                                                          &prog_info);

	if ((recorder_num > 0) && (prog_info != NULL)) {

	    gboolean res;

            gmyth_scheduler_change_record_group (scheduler, prog_info, "Default");

            res = gmyth_scheduler_set_live_record (scheduler, schedule_info,

			recorder_num, TRUE);

	    schedule_info->schedule_id = gmyth_scheduler_query_schedule_id (scheduler, prog_info);

            return res;

	} 

    }

    /* Now, verifies if there is an old schedule for this program */

    /* If threre is one, we reactivate it */

    {

        gint sched_id;

	time_t now = time (NULL);

	if (schedule_info->start_time->tv_sec < now) {

	    sched_id = gmyth_scheduler_query_old_schedule (scheduler, schedule_info->channel_id,

			                               schedule_info->start_time, TRUE);

	    if (sched_id > 0) {

                schedule_info->schedule_id = sched_id;

	        return TRUE;

            } 

	}

    }

    msql_res =

        gmyth_query_process_statement_with_increment(scheduler->msqlquery,

			              "INSERT record (recordid) VALUE (0);",

                                      &rec_id);

    mysql_free_result(msql_res);

    // Retrieves the station info

    query_str =

        g_strdup_printf

        ("SELECT callsign FROM channel WHERE chanid = %d;",

         schedule_info->channel_id);

    msql_res =

        gmyth_query_process_statement(scheduler->msqlquery, query_str);

    if (msql_res == NULL) {

        g_warning("[%s] msql query returned NULL MYSQL_RES", __FUNCTION__);

        return FALSE;

    } else {

        MYSQL_ROW       row;

        if ((row = mysql_fetch_row(msql_res)) != NULL) {

            station = g_strdup(row[0]);

        }

    }

    mysql_free_result(msql_res);

    g_free(query_str);

    // _set_value (field, value, id);

    _set_int_value(scheduler->msqlquery, "chanid",

                   schedule_info->channel_id, rec_id);

    _set_value(scheduler->msqlquery, "station", station, rec_id);

    _set_value(scheduler->msqlquery, "title", schedule_info->title->str,

               rec_id);

    // / subtitle, description 

    _set_value(scheduler->msqlquery, "starttime",

               gmyth_util_time_to_string_only_time(schedule_info->

                                                   start_time), rec_id);

    _set_value(scheduler->msqlquery, "startdate",

               gmyth_util_time_to_string_only_date(schedule_info->

                                                   start_time), rec_id);

    _set_value(scheduler->msqlquery, "endtime",

               gmyth_util_time_to_string_only_time(schedule_info->

                                                   end_time), rec_id);

    _set_value(scheduler->msqlquery, "enddate",

               gmyth_util_time_to_string_only_date(schedule_info->

                                                   end_time), rec_id);

    // / category, series id, program id

    // _set_value (scheduler->msqlquery, "findday",

    // (gmyth_util_time_val_to_date( schedule_info->start_time

    // ))->tm_wday, rec_id);

    // _set_value (scheduler->msqlquery, "findtime",

    // gmyth_util_time_to_string_only_time( schedule_info->start_time),

    // rec_id);

    // _set_int_value (scheduler->msqlquery, "findid",

    // (gint)(schedule_info->start_time->tv_sec/60/60/24 + 719528),

    // rec_id);

    if (schedule_info->seriesid)

       _set_value(scheduler->msqlquery, "seriesid",

                  schedule_info->seriesid->str, rec_id);

    _set_value(scheduler->msqlquery, "parentid", "0", rec_id);

    _set_value(scheduler->msqlquery, "search", "0", rec_id);

    if (type == GMYTH_SCHEDULE_ALL_OCCURRENCES) {

        _set_int_value(scheduler->msqlquery, "type", 3, rec_id);

    } else if (type == GMYTH_SCHEDULE_ONE_OCCURRENCE) {

        _set_int_value(scheduler->msqlquery, "type", 1, rec_id);

    } else if (type == GMYTH_SCHEDULE_EXCEPTION) {

        _set_int_value(scheduler->msqlquery, "type", 8, rec_id);

        _set_int_value(scheduler->msqlquery, "parentid", schedule_info->parentid,

		       rec_id);

    }

    _set_value(scheduler->msqlquery, "recpriority", "0", rec_id);

    _set_value(scheduler->msqlquery, "startoffset", "0", rec_id);

    _set_value(scheduler->msqlquery, "endoffset", "0", rec_id);

    _set_value(scheduler->msqlquery, "dupmethod", "6", rec_id); // ?

    _set_value(scheduler->msqlquery, "dupin", "15", rec_id);    // ?

    _set_value(scheduler->msqlquery, "prefinput", "0", rec_id);

    _set_value(scheduler->msqlquery, "inactive", "0", rec_id);

    _set_value(scheduler->msqlquery, "profile", "Default", rec_id);

    _set_value(scheduler->msqlquery, "recgroup", "Default", rec_id);

    _set_value(scheduler->msqlquery, "storagegroup", "Default", rec_id);

    _set_value(scheduler->msqlquery, "playgroup", "Default", rec_id);

    _set_value(scheduler->msqlquery, "autoexpire", "1", rec_id);

    _set_value(scheduler->msqlquery, "maxepisodes", "0", rec_id);

    _set_value(scheduler->msqlquery, "maxnewest", "0", rec_id);

    _set_value(scheduler->msqlquery, "autocommflag", "1", rec_id);

    _set_value(scheduler->msqlquery, "autotranscode", "0", rec_id);

    _set_value(scheduler->msqlquery, "transcoder", "0", rec_id);

    _set_value(scheduler->msqlquery, "autouserjob1", "0", rec_id);

    _set_value(scheduler->msqlquery, "autouserjob2", "0", rec_id);

    _set_value(scheduler->msqlquery, "autouserjob3", "0", rec_id);

    _set_value(scheduler->msqlquery, "autouserjob4", "0", rec_id);

    schedule_info->schedule_id = rec_id;

    /* Notify the backend of changes */

    return update_backend(scheduler, rec_id);

}

/** Requests the Mysql database in the backend to add a new schedule.

 * 

 * @param scheduler the GMythScheduler instance.

 * @param schedule_info the ScheduleInfo with recording schedule information

 * to be added. record_id = -1 to add a new schedule, otherwise this

 * function will update the schedule in the db

 * @return gboolean returns FALSE if some error occurs, TRUE otherwise

 */

gboolean

gmyth_scheduler_add_schedule (GMythScheduler * scheduler,

                             ScheduleInfo * schedule_info)

{

    return gmyth_scheduler_add_schedule_full (scheduler, schedule_info, 

                                              GMYTH_SCHEDULE_ONE_OCCURRENCE);

}

static gint

gmyth_scheduler_query_schedule_id (GMythScheduler *scheduler,

		                   GMythProgramInfo *prog_info)

{

    MYSQL_RES *mysql_res;

    gint sched_id = -1;

    gchar *query_str, *startts;

    startts = gmyth_util_time_to_string_from_time_val (prog_info->recstartts);

    query_str = g_strdup_printf ("SELECT recordid from recorded "

		    "WHERE chanid= \"%d\" AND starttime = \"%s\";",

                    prog_info->channel_id, startts);

    mysql_res = gmyth_query_process_statement(scheduler->msqlquery, query_str);

    if (mysql_res) {

        MYSQL_ROW msql_row = mysql_fetch_row(mysql_res);

        if (msql_row) {

            sched_id = g_ascii_strtoull (msql_row[0], NULL, 10);

        } 

    }

    return sched_id;

}

/* Queries if there is an old schedule previously set to this program.

 * If reactivate flag is set, the recording will be reactivated.

 * @returns the schedule id.

 */

static int

gmyth_scheduler_query_old_schedule (GMythScheduler *scheduler,

		                    gint channel_id, GTimeVal *startts,

                                    gboolean reactivate)

{

    MYSQL_RES *mysql_res;

    gint sched_id = -1;

    gchar *query_str, *startts_str;

    startts_str = gmyth_util_time_to_string_from_time_val (startts);

    query_str = g_strdup_printf ("SELECT recordid from oldrecorded "

                    "WHERE chanid= \"%d\" AND starttime=\"%s\";",

                    channel_id, startts_str);

    mysql_res = gmyth_query_process_statement(scheduler->msqlquery, query_str);

    g_free (query_str);

    if (mysql_res) {

        MYSQL_ROW msql_row = mysql_fetch_row(mysql_res);

        if (msql_row) {

            sched_id = g_ascii_strtoull (msql_row[0], NULL, 10);

            if ((sched_id > 0) && (reactivate)) {

                query_str = g_strdup_printf ("UPDATE oldrecorded SET reactivate = 1 "

                    "WHERE chanid= \"%d\" AND starttime=\"%s\";",

                    channel_id, startts_str);

                update_backend (scheduler, 0);

            }

        }

    }

    return sched_id;

}

/** Queries if the given schedule info is currently been recorded by any 

 * backend recorder.

 * @return The recorder num currently recording the scheduled item, or -1

 * if program is not been recorded.

 */

static gint

gmyth_scheduler_is_program_live_recorded (GMythScheduler * scheduler,

                                         ScheduleInfo *schedule_info,

                                         GMythProgramInfo **prog_info)

{

   GList *list; 

   gint recorder_num = -1;

   if (gmyth_remote_util_get_recorder_list (scheduler->backend_info, &list) > 0) {

        GList *iter = list;

	while (iter) {

	    GMythRecorder *recorder = GMYTH_RECORDER ( iter->data );

            if (gmyth_recorder_is_recording (recorder)) {

                GMythProgramInfo *pinfo = gmyth_recorder_get_current_program_info (recorder);

		if (pinfo != NULL) {

		    if ((schedule_info->channel_id == pinfo->channel_id) &&

			(schedule_info->start_time->tv_sec == pinfo->startts->tv_sec)) {

			recorder_num = recorder->recorder_num;

                        *prog_info = pinfo;

			break;

		    }

		    g_object_unref (pinfo);

		}

	    }

	    iter = iter->next;

	}

	g_list_foreach (list, (GFunc) g_object_unref, NULL);

	g_list_free (list);

   }

   return recorder_num;

}

static gboolean

gmyth_scheduler_set_live_record (GMythScheduler * scheduler,

                                ScheduleInfo * schedule_info,

				gint recorder_num, gboolean enable)

{

    gchar* datastr;

    GMythSocket *socket;

    gboolean ret = FALSE;

    GMythStringList *strlist = gmyth_string_list_new();

    datastr = g_strdup_printf ("QUERY_RECORDER %d", recorder_num);

    gmyth_string_list_append_char_array (strlist, datastr);

    gmyth_string_list_append_char_array (strlist, "SET_LIVE_RECORDING");

    gmyth_string_list_append_int (strlist, enable ? 1 : 0);

    socket = gmyth_backend_info_get_connected_socket (scheduler->backend_info);

    if (socket != NULL) {

        ret = (gmyth_socket_sendreceive_stringlist(socket, strlist) > 0);

        g_object_unref (socket);

    } else {

        g_warning("[%s] Connection to backend failed!", __FUNCTION__);

    }

    g_free(datastr);

    g_object_unref(strlist);

    return ret;

}

static gboolean

gmyth_scheduler_change_record_group (GMythScheduler* scheduler,

                                     GMythProgramInfo *prog_info,

                                     gchar *new_group)

{

    gchar *query_str = NULL;

    gchar* startts = NULL;

    if (prog_info == NULL) {

        g_warning ("Scheduler receiver a NULL program info to change its record group");

        return FALSE;

    }

    startts = gmyth_util_time_to_string_from_time_val (prog_info->recstartts);

    query_str = g_strdup_printf("UPDATE recorded SET recgroup = \"%s\" "

                    "WHERE chanid = \"%d\" AND starttime = \"%s\";",

                     new_group, prog_info->channel_id, startts);

    gmyth_query_process_statement(scheduler->msqlquery, query_str);

    g_free (query_str);

    g_free (startts);

    return TRUE ;

}

/** Requests the Mysql database in the backend to remove an existing schedule.

 * 

 * @param scheduler the GMythScheduler instance.

 * @param schedule_id The schedule's record id to be removed

 * @return gboolean TRUE if success, FALSE if error

 */

gboolean

gmyth_scheduler_delete_schedule (GMythScheduler * scheduler, gint schedule_id)

{

    MYSQL_RES *msql_res;

    GString *query_str = NULL;

    g_return_val_if_fail (scheduler != NULL, FALSE);

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] Scheduler db connection not initialized",

                  __FUNCTION__);

        return FALSE;

    }

    {

        /* Before adding the schedule, we need to check if program is been played */

        GMythProgramInfo *prog_info = NULL;

        ScheduleInfo *sched_info = NULL;

        sched_info = gmyth_scheduler_get_schedule (scheduler, schedule_id);

        if (sched_info != NULL) {

            gint recorder_num =

                gmyth_scheduler_is_program_live_recorded (scheduler, sched_info,

                                                          &prog_info);

            if ((recorder_num > 0) && (prog_info != NULL)) {

		gboolean ret;

                gmyth_scheduler_change_record_group (scheduler, prog_info, "LiveTV");

                ret = gmyth_scheduler_set_live_record (scheduler, sched_info,

                            recorder_num, FALSE);

                gmyth_schedule_info_free (sched_info);

		return ret;		

            } 

	}

    }

    query_str = g_string_new("");

    g_string_printf(query_str,

                    "DELETE FROM record WHERE recordid=%d", schedule_id);

    msql_res =

        gmyth_query_process_statement(scheduler->msqlquery,

                                      query_str->str);

    mysql_free_result(msql_res);

    g_string_free(query_str, TRUE);

    // Notify the backend of the changes

    return update_backend(scheduler, schedule_id);

}

/*

 * Add an exception program to be removed from the schedule list, when programs

 * where scheduled with the GMYTH_SCHEDULE_ALL_OCCURRENCES option.

 * @param scheduler the GMythScheduler instance.

 * @param schedule_id the schedule id of the all occurrence schedule to be changed

 * @param exception_info the ScheduleInfo to be removed from all schedule occurrences

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

 */

gboolean

gmyth_scheduler_add_exception (GMythScheduler *scheduler, gint schedule_id,

			       ScheduleInfo *exception_info)

{

    gboolean res;

    g_return_val_if_fail (scheduler != NULL, FALSE);

    g_return_val_if_fail (exception_info != NULL, FALSE);

    exception_info->parentid = schedule_id;

    res = gmyth_scheduler_add_schedule_full (scheduler, exception_info, GMYTH_SCHEDULE_EXCEPTION);

    return res;

}

/** Requests the Mysql database in the backend to remove an existing recorded item.

 * 

 * @param scheduler the GMythScheduler instance.

 * @param record_id The recorded item id to be removed

 * @return gboolean TRUE if success, FALSE if error

 */

gboolean

gmyth_scheduler_delete_recorded(GMythScheduler * scheduler, gint record_id)

{

    MYSQL_RES      *msql_res;

    GString        *query_str = g_string_new("");

    assert(scheduler);

    if (scheduler->msqlquery == NULL) {

        g_warning("[%s] Scheduler db connection not initialized",

                  __FUNCTION__);

        return FALSE;

    }

    // ========================================

    g_string_printf(query_str,

                    "DELETE FROM recorded WHERE recordid=%d", record_id);

    // FIXME: Mythtv implementation runs also: DELETE FROM oldfind WHERE