/*
 * Copyright (C) 2004 Free Software Foundation, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU 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 General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Authors:
 *     Mark McLoughlin  <mark@skynet.ie>
 *     William Jon McCann  <mccann@jhu.edu>
 *     Martin Grimme  <martin@pycage.de>
 *     Christian Kellner  <gicmo@xatom.net>
 */

#include <config.h>

#include "calendar-client.h"

#include <libintl.h>
#include <string.h>
#define HANDLE_LIBICAL_MEMORY
#include <libecal/libecal.h>

#include "calendar-sources.h"

#undef CALENDAR_ENABLE_DEBUG
#include "calendar-debug.h"

#ifndef _
#define _(x) gettext(x)
#endif

#ifndef N_
#define N_(x) x
#endif

typedef struct _CalendarClientQuery  CalendarClientQuery;
typedef struct _CalendarClientSource CalendarClientSource;

struct _CalendarClientQuery
{
  ECalClientView *view;
  GHashTable     *events;
};

struct _CalendarClientSource
{
  CalendarClient      *client;
  ECalClient          *source;

  CalendarClientQuery  completed_query;
  CalendarClientQuery  in_progress_query;

  guint                changed_signal_id;

  guint                query_completed : 1;
  guint                query_in_progress : 1;
};

struct _CalendarClientPrivate
{
  CalendarSources     *calendar_sources;

  GSList              *appointment_sources;
  GSList              *task_sources;

  ICalTimezone        *zone;

  guint                zone_listener;
  GSettings           *calendar_settings;

  guint                day;
  guint                month;
  guint                year;
};

static void calendar_client_finalize     (GObject             *object);
static void calendar_client_set_property (GObject             *object,
					  guint                prop_id,
					  const GValue        *value,
					  GParamSpec          *pspec);
static void calendar_client_get_property (GObject             *object,
					  guint                prop_id,
					  GValue              *value,
					  GParamSpec          *pspec);

static GSList *calendar_client_update_sources_list         (CalendarClient       *client,
							    GSList               *sources,
							    GList                *esources,
							    guint                 changed_signal_id);
static void    calendar_client_appointment_sources_changed (CalendarClient       *client);
static void    calendar_client_task_sources_changed        (CalendarClient       *client);

static void calendar_client_stop_query  (CalendarClient       *client,
					 CalendarClientSource *source,
					 CalendarClientQuery  *query);
static void calendar_client_start_query (CalendarClient       *client,
					 CalendarClientSource *source,
					 const char           *query);

static void calendar_client_source_finalize (CalendarClientSource *source);
static void calendar_client_query_finalize  (CalendarClientQuery  *query);

static void
calendar_client_update_appointments (CalendarClient *client);
static void
calendar_client_update_tasks (CalendarClient *client);

enum
{
  PROP_O,
  PROP_DAY,
  PROP_MONTH,
  PROP_YEAR
};

enum
{
  APPOINTMENTS_CHANGED,
  TASKS_CHANGED,
  LAST_SIGNAL
};

static guint         signals [LAST_SIGNAL] = { 0, };

G_DEFINE_TYPE_WITH_PRIVATE (CalendarClient, calendar_client, G_TYPE_OBJECT)

static void
calendar_client_class_init (CalendarClientClass *klass)
{
  GObjectClass *gobject_class = (GObjectClass *) klass;

  gobject_class->finalize     = calendar_client_finalize;
  gobject_class->set_property = calendar_client_set_property;
  gobject_class->get_property = calendar_client_get_property;

  g_object_class_install_property (gobject_class,
				   PROP_DAY,
				   g_param_spec_uint ("day",
						      "Day",
						      "The currently monitored day between 1 and 31 (0 denotes unset)",
						      0, G_MAXUINT, 0,
						      G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,
				   PROP_MONTH,
				   g_param_spec_uint ("month",
						      "Month",
						      "The currently monitored month between 0 and 11",
						      0, G_MAXUINT, 0,
						      G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,
				   PROP_YEAR,
				   g_param_spec_uint ("year",
						      "Year",
						      "The currently monitored year",
						      0, G_MAXUINT, 0,
						      G_PARAM_READWRITE));

  signals [APPOINTMENTS_CHANGED] =
    g_signal_new ("appointments-changed",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (CalendarClientClass, tasks_changed),
		  NULL,
		  NULL,
		  NULL,
		  G_TYPE_NONE,
		  0);

  signals [TASKS_CHANGED] =
    g_signal_new ("tasks-changed",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (CalendarClientClass, tasks_changed),
		  NULL,
		  NULL,
		  NULL,
		  G_TYPE_NONE,
		  0);
}

/* Timezone code adapted from evolution/calendar/gui/calendar-config.c */
/* The current timezone, e.g. "Europe/London". It may be NULL, in which case
   you should assume UTC. */
static gchar *
calendar_client_config_get_timezone (GSettings *calendar_settings)
{
  return g_settings_get_string (calendar_settings, "timezone");
}

static ICalTimezone *
calendar_client_config_get_icaltimezone (CalendarClient *client)
{
  gchar        *location = NULL;
  ICalTimezone *zone = NULL;

  if (client->priv->calendar_settings != NULL)
    location = calendar_client_config_get_timezone (client->priv->calendar_settings);

  if (!location)
    return i_cal_timezone_get_utc_timezone ();

  zone = i_cal_timezone_get_builtin_timezone (location);
  g_free (location);

  return zone;
}

static void
calendar_client_set_timezone (CalendarClient *client) 
{
  GList *list, *link;

  client->priv->zone = calendar_client_config_get_icaltimezone (client);

  list = calendar_sources_get_appointment_clients (client->priv->calendar_sources);
  for (link = list; link != NULL; link = g_list_next (link))
    {
      ECalClient *cal = E_CAL_CLIENT (link->data);

      e_cal_client_set_default_timezone (cal, client->priv->zone);
    }
  g_list_free (list);
}

static void
calendar_client_timezone_changed_cb (GSettings      *calendar_settings,
                                     const gchar    *key,
                                     CalendarClient *client)
{
  calendar_client_set_timezone (client);
}

static void
load_calendars (CalendarClient    *client,
                CalendarEventType  type) 
{
  GSList *l, *clients;

  switch (type)
    {
      case CALENDAR_EVENT_APPOINTMENT:
        clients = client->priv->appointment_sources;
        break;
      case CALENDAR_EVENT_TASK:
        clients = client->priv->task_sources;
        break;
      case CALENDAR_EVENT_ALL:
      default:
        g_assert_not_reached ();
    }

  for (l = clients; l != NULL; l = l->next)
    {
      if (type == CALENDAR_EVENT_APPOINTMENT)
        calendar_client_update_appointments (client);
      else if (type == CALENDAR_EVENT_TASK)
        calendar_client_update_tasks (client);
    }
}

static void
calendar_client_init (CalendarClient *client)
{
  GList *list;
  GSettingsSchemaSource *schema_source;
  const gchar *evolution_calendar_schema;

  client->priv = calendar_client_get_instance_private (client);

  client->priv->calendar_sources = calendar_sources_get ();

  schema_source = g_settings_schema_source_get_default();
  evolution_calendar_schema = "org.gnome.evolution.calendar";
  if (g_settings_schema_source_lookup (schema_source, evolution_calendar_schema, FALSE))
    client->priv->calendar_settings = g_settings_new (evolution_calendar_schema);

  list = calendar_sources_get_appointment_clients (client->priv->calendar_sources);
  client->priv->appointment_sources =
    calendar_client_update_sources_list (client, NULL, list, signals [APPOINTMENTS_CHANGED]);
  g_list_free (list);

  list = calendar_sources_get_task_clients (client->priv->calendar_sources);
  client->priv->task_sources =
    calendar_client_update_sources_list (client, NULL, list, signals [TASKS_CHANGED]);
  g_list_free (list);
 
  /* set the timezone before loading the clients */ 
  calendar_client_set_timezone (client);
  load_calendars (client, CALENDAR_EVENT_APPOINTMENT);
  load_calendars (client, CALENDAR_EVENT_TASK);

  g_signal_connect_swapped (client->priv->calendar_sources,
			    "appointment-sources-changed",
			    G_CALLBACK (calendar_client_appointment_sources_changed),
			    client);
  g_signal_connect_swapped (client->priv->calendar_sources,
			    "task-sources-changed",
			    G_CALLBACK (calendar_client_task_sources_changed),
			    client);

  if (client->priv->calendar_settings != NULL)
    client->priv->zone_listener = g_signal_connect (client->priv->calendar_settings,
                                                    "changed::timezone",
                                                    G_CALLBACK (calendar_client_timezone_changed_cb),
                                                    client);

  client->priv->day = 0;
  client->priv->month = 0;
  client->priv->year = 0;
}

static void
calendar_client_finalize (GObject *object)
{
  CalendarClient *client = CALENDAR_CLIENT (object);
  GSList         *l;

  if (client->priv->zone_listener)
    {
      g_signal_handler_disconnect (client->priv->calendar_settings,
                                   client->priv->zone_listener);
      client->priv->zone_listener = 0;
    }

  if (client->priv->calendar_settings)
    g_object_unref (client->priv->calendar_settings);
  client->priv->calendar_settings = NULL;

  for (l = client->priv->appointment_sources; l; l = l->next)
    {
      calendar_client_source_finalize (l->data);
      g_free (l->data);
    }
  g_slist_free (client->priv->appointment_sources);
  client->priv->appointment_sources = NULL;

  for (l = client->priv->task_sources; l; l = l->next)
    {
      calendar_client_source_finalize (l->data);
      g_free (l->data);
    }
  g_slist_free (client->priv->task_sources);
  client->priv->task_sources = NULL;

  if (client->priv->calendar_sources)
    g_object_unref (client->priv->calendar_sources);
  client->priv->calendar_sources = NULL;

  G_OBJECT_CLASS (calendar_client_parent_class)->finalize (object);
}

static void
calendar_client_set_property (GObject      *object,
			      guint         prop_id,
			      const GValue *value,
			      GParamSpec   *pspec)
{
  CalendarClient *client = CALENDAR_CLIENT (object);

  switch (prop_id)
    {
    case PROP_DAY:
      calendar_client_select_day (client, g_value_get_uint (value));
      break;
    case PROP_MONTH:
      calendar_client_select_month (client,
				    g_value_get_uint (value),
				    client->priv->year);
      break;
    case PROP_YEAR:
      calendar_client_select_month (client,
				    client->priv->month,
				    g_value_get_uint (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
calendar_client_get_property (GObject    *object,
			      guint       prop_id,
			      GValue     *value,
			      GParamSpec *pspec)
{
  CalendarClient *client = CALENDAR_CLIENT (object);

  switch (prop_id)
    {
    case PROP_DAY:
      g_value_set_uint (value, client->priv->day);
      break;
    case PROP_MONTH:
      g_value_set_uint (value, client->priv->month);
      break;
    case PROP_YEAR:
      g_value_set_uint (value, client->priv->year);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

CalendarClient *
calendar_client_new (void)
{
  return g_object_new (CALENDAR_TYPE_CLIENT, NULL);
}

/* @day and @month can happily be out of range as
 * mktime() will normalize them correctly. From mktime(3):
 *
 * "If structure members are outside their legal interval,
 *  they will be normalized (so that, e.g., 40 October is
 *  changed into 9 November)."
 *
 * "What?", you say, "Something useful in libc?"
 */
static inline time_t
make_time_for_day_begin (int day,
			 int month,
			 int year)
{
  struct tm localtime_tm = { 0, };

  localtime_tm.tm_mday  = day;
  localtime_tm.tm_mon   = month;
  localtime_tm.tm_year  = year - 1900;
  localtime_tm.tm_isdst = -1;

  return mktime (&localtime_tm);
}

static inline char *
make_isodate_for_day_begin (int day,
			    int month,
			    int year)
{
  time_t utctime;

  utctime = make_time_for_day_begin (day, month, year);

  return utctime != -1 ? isodate_from_time_t (utctime) : NULL;
}

static time_t
get_time_from_property (ICalComponent    *icomp,
                        ICalPropertyKind  prop_kind,
                        ICalTime         * (* get_prop_func) (ICalProperty *prop),
                        ICalTimezone     *default_zone)
{
  ICalProperty *prop;
  ICalTime *ical_time;
  ICalParameter *param;
  ICalTimezone *timezone;
  time_t retval;

  prop = i_cal_component_get_first_property (icomp, prop_kind);
  if (!prop)
    return 0;

  param = i_cal_property_get_first_parameter (prop, I_CAL_TZID_PARAMETER);
  ical_time = get_prop_func (prop);
  g_object_unref (prop);

  if (param)
    {
      const char *tzid;

      tzid = i_cal_parameter_get_tzid (param);
      timezone = i_cal_timezone_get_builtin_timezone_from_tzid (tzid);
      g_object_unref (param);
    }
  else if (i_cal_time_is_utc (ical_time))
    {
      timezone = i_cal_timezone_get_utc_timezone ();
    }
  else
    {
      timezone = default_zone;
    }

  retval = i_cal_time_as_timet_with_zone (ical_time, timezone);
  g_object_unref (ical_time);

  return retval;
}

static char *
get_component_uid (ICalComponent *component)
{
  return g_strdup (i_cal_component_get_uid (component));
}

static char *
get_component_rid (ICalComponent *component)
{
  ICalProperty *prop;
  ICalTime *time;
  char *rid;

  prop = i_cal_component_get_first_property (component, I_CAL_RECURRENCEID_PROPERTY);
  if (!prop)
    return NULL;

  time = i_cal_property_get_recurrenceid (prop);
  g_object_unref (prop);

  if (!i_cal_time_is_valid_time (time) || i_cal_time_is_null_time (time))
    {
      g_object_unref (time);
      return NULL;
    }

  rid = g_strdup (i_cal_time_as_ical_string (time));
  g_object_unref (time);

  return rid;
}

static char *
get_component_summary (ICalComponent *component)
{
  ICalProperty *prop;
  char *summary;

  prop = i_cal_component_get_first_property (component, I_CAL_SUMMARY_PROPERTY);
  if (!prop)
    return NULL;

  summary = g_strdup (i_cal_property_get_summary (prop));
  g_object_unref (prop);

  return summary;
}

static char *
get_component_description (ICalComponent *component)
{
  ICalProperty *prop;
  char *description;

  prop = i_cal_component_get_first_property (component, I_CAL_DESCRIPTION_PROPERTY);
  if (!prop)
    return NULL;

  description = g_strdup (i_cal_property_get_description (prop));
  g_object_unref (prop);

  return description;
}

static inline time_t
get_component_start_time (ICalComponent *component,
                          ICalTimezone  *default_zone)
{
  return get_time_from_property (component,
                                 I_CAL_DTSTART_PROPERTY,
                                 i_cal_property_get_dtstart,
                                 default_zone);
}

static inline time_t
get_component_end_time (ICalComponent *component,
                        ICalTimezone  *default_zone)
{
  return get_time_from_property (component,
                                 I_CAL_DTEND_PROPERTY,
                                 i_cal_property_get_dtend,
                                 default_zone);
}

static gboolean
get_component_is_all_day (ICalComponent *component,
                          time_t         start_time,
                          ICalTimezone  *default_zone)
{
  ICalTime *dtstart;
  struct tm *start_tm;
  time_t end_time;
  ICalProperty *prop;
  ICalDuration *duration;
  gboolean is_all_day;

  dtstart = i_cal_component_get_dtstart (component);

  if (dtstart && i_cal_time_is_date (dtstart))
    {
      g_object_unref (dtstart);
      return TRUE;
    }

  g_object_unref (dtstart);

  start_tm = gmtime (&start_time);
  if (start_tm->tm_sec  != 0 ||
      start_tm->tm_min  != 0 ||
      start_tm->tm_hour != 0)
    return FALSE;

  if ((end_time = get_component_end_time (component, default_zone)))
    return (end_time - start_time) % 86400 == 0;

  prop = i_cal_component_get_first_property (component, I_CAL_DURATION_PROPERTY);
  if (!prop)
    return FALSE;

  duration = i_cal_property_get_duration (prop);
  g_object_unref (prop);

  is_all_day = i_cal_duration_as_int (duration) % 86400 == 0;
  g_object_unref (duration);

  return is_all_day;
}

static inline time_t
get_component_due_time (ICalComponent *component,
                        ICalTimezone  *default_zone)
{
  return get_time_from_property (component,
                                 I_CAL_DUE_PROPERTY,
                                 i_cal_property_get_due,
                                 default_zone);
}

static guint
get_component_percent_complete (ICalComponent *component)
{
  ICalPropertyStatus status;
  ICalProperty *prop;
  int percent_complete;

  status = i_cal_component_get_status (component);
  if (status == I_CAL_STATUS_COMPLETED)
    return 100;

  prop = i_cal_component_get_first_property (component, I_CAL_COMPLETED_PROPERTY);

  if (prop)
    {
      g_object_unref (prop);
      return 100;
    }

  prop = i_cal_component_get_first_property (component, I_CAL_PERCENTCOMPLETE_PROPERTY);
  if (!prop)
    return 0;

  percent_complete = i_cal_property_get_percentcomplete (prop);
  g_object_unref (prop);

  return CLAMP (percent_complete, 0, 100);
}

static inline time_t
get_component_completed_time (ICalComponent *component,
                              ICalTimezone  *default_zone)
{
  return get_time_from_property (component,
                                 I_CAL_COMPLETED_PROPERTY,
                                 i_cal_property_get_completed,
                                 default_zone);
}

static int
get_component_priority (ICalComponent *component)
{
  ICalProperty *prop;
  int priority;

  prop = i_cal_component_get_first_property (component, I_CAL_PRIORITY_PROPERTY);
  if (!prop)
    return -1;

  priority = i_cal_property_get_priority (prop);
  g_object_unref (prop);

  return priority;
}

static char *
get_source_color (ECalClient *esource)
{
  ESource *source;
  ECalClientSourceType source_type;
  ESourceSelectable *extension;
  const gchar *extension_name;

  g_return_val_if_fail (E_IS_CAL_CLIENT (esource), NULL);

  source = e_client_get_source (E_CLIENT (esource));
  source_type = e_cal_client_get_source_type (esource);

  switch (source_type)
    {
      case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
        extension_name = E_SOURCE_EXTENSION_CALENDAR;
        break;
      case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
        extension_name = E_SOURCE_EXTENSION_TASK_LIST;
        break;
      case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
      case E_CAL_CLIENT_SOURCE_TYPE_LAST:
      default:
        g_return_val_if_reached (NULL);
    }

  extension = e_source_get_extension (source, extension_name);

  return e_source_selectable_dup_color (extension);
}

static gchar *
get_source_backend_name (ECalClient *esource)
{
  ESource *source;
  ECalClientSourceType source_type;
  ESourceBackend *extension;
  const gchar *extension_name;

  g_return_val_if_fail (E_IS_CAL_CLIENT (esource), NULL);

  source = e_client_get_source (E_CLIENT (esource));
  source_type = e_cal_client_get_source_type (esource);

  switch (source_type)
    {
      case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
        extension_name = E_SOURCE_EXTENSION_CALENDAR;
        break;
      case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
        extension_name = E_SOURCE_EXTENSION_TASK_LIST;
        break;
      case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
      case E_CAL_CLIENT_SOURCE_TYPE_LAST:
      default:
        g_return_val_if_reached (NULL);
    }

  extension = e_source_get_extension (source, extension_name);

  return e_source_backend_dup_backend_name (extension);
}

static inline gboolean
calendar_appointment_equal (CalendarAppointment *a,
			    CalendarAppointment *b)
{
  GSList *la, *lb;

  if (g_slist_length (a->occurrences) != g_slist_length (b->occurrences))
      return FALSE;

  for (la = a->occurrences, lb = b->occurrences; la && lb; la = la->next, lb = lb->next)
    {
      CalendarOccurrence *oa = la->data;
      CalendarOccurrence *ob = lb->data;

      if (oa->start_time != ob->start_time ||
	  oa->end_time   != ob->end_time)
	return FALSE;
    }

  return
    g_strcmp0 (a->uid, b->uid) == 0 &&
    g_strcmp0 (a->backend_name, b->backend_name) == 0 &&
    g_strcmp0 (a->summary, b->summary) == 0 &&
    g_strcmp0 (a->description, b->description) == 0 &&
    g_strcmp0 (a->color_string, b->color_string) == 0 &&
    a->start_time == b->start_time &&
    a->end_time == b->end_time &&
    a->is_all_day == b->is_all_day;
}

static void
calendar_appointment_copy (CalendarAppointment *appointment,
			   CalendarAppointment *appointment_copy)
{
  GSList *l;

  g_assert (appointment != NULL);
  g_assert (appointment_copy != NULL);

  appointment_copy->occurrences = g_slist_copy (appointment->occurrences);
  for (l = appointment_copy->occurrences; l; l = l->next)
    {
      CalendarOccurrence *occurrence = l->data;
      CalendarOccurrence *occurrence_copy;

      occurrence_copy             = g_new0 (CalendarOccurrence, 1);
      occurrence_copy->start_time = occurrence->start_time;
      occurrence_copy->end_time   = occurrence->end_time;

      l->data = occurrence_copy;
    }

  appointment_copy->uid          = g_strdup (appointment->uid);
  appointment_copy->backend_name = g_strdup (appointment->backend_name);
  appointment_copy->summary      = g_strdup (appointment->summary);
  appointment_copy->description  = g_strdup (appointment->description);
  appointment_copy->color_string = g_strdup (appointment->color_string);
  appointment_copy->start_time   = appointment->start_time;
  appointment_copy->end_time     = appointment->end_time;
  appointment_copy->is_all_day   = appointment->is_all_day;
}

static void
calendar_appointment_finalize (CalendarAppointment *appointment)
{
  GSList *l;

  for (l = appointment->occurrences; l; l = l->next)
    g_free (l->data);
  g_slist_free (appointment->occurrences);
  appointment->occurrences = NULL;

  g_free (appointment->uid);
  appointment->uid = NULL;

  g_free (appointment->rid);
  appointment->rid = NULL;

  g_free (appointment->backend_name);
  appointment->backend_name = NULL;

  g_free (appointment->summary);
  appointment->summary = NULL;

  g_free (appointment->description);
  appointment->description = NULL;

  g_free (appointment->color_string);
  appointment->color_string = NULL;

  appointment->start_time = 0;
  appointment->is_all_day = FALSE;
}

static void
calendar_appointment_init (CalendarAppointment  *appointment,
                           ICalComponent        *component,
                           CalendarClientSource *source,
                           ICalTimezone         *default_zone)
{
  appointment->uid = get_component_uid (component);
  appointment->rid = get_component_rid (component);
  appointment->backend_name = get_source_backend_name (source->source);
  appointment->summary = get_component_summary (component);
  appointment->description = get_component_description (component);
  appointment->color_string = get_source_color (source->source);
  appointment->start_time = get_component_start_time (component, default_zone);
  appointment->end_time = get_component_end_time (component, default_zone);
  appointment->is_all_day = get_component_is_all_day (component,
                                                      appointment->start_time,
                                                      default_zone);
}

static ICalTimezone *
resolve_timezone_id (const char    *tzid,
                     gpointer       user_data,
                     GCancellable  *cancellable,
                     GError       **error)
{
  ECalClient *client;
  ICalTimezone *retval;

  client = E_CAL_CLIENT (user_data);
  retval = i_cal_timezone_get_builtin_timezone_from_tzid (tzid);

  if (!retval)
    e_cal_client_get_timezone_sync (client, tzid, &retval, NULL, NULL);

  return retval;
}

static gboolean
calendar_appointment_collect_occurrence (ICalComponent  *component,
                                         ICalTime       *occurrence_start,
                                         ICalTime       *occurrence_end,
                                         gpointer        user_data,
                                         GCancellable   *cancellable,
                                         GError        **error)
{
  time_t start;
  time_t end;
  CalendarOccurrence *occurrence;
  GSList **collect_loc = user_data;

  start = i_cal_time_as_timet (occurrence_start);
  end = i_cal_time_as_timet (occurrence_end);

  occurrence = g_new0 (CalendarOccurrence, 1);
  occurrence->start_time = start;
  occurrence->end_time = end;

  *collect_loc = g_slist_prepend (*collect_loc, occurrence);

  return TRUE;
}

static void
calendar_appointment_generate_ocurrences (CalendarAppointment *appointment,
                                          ICalComponent       *component,
                                          ECalClient          *source,
                                          time_t               start,
                                          time_t               end,
                                          ICalTimezone        *default_zone)
{
  ICalTime *start_time;
  ICalTime *end_time;

  g_assert (appointment->occurrences == NULL);

  start_time = i_cal_time_new_from_timet_with_zone (start, FALSE, NULL);
  end_time = i_cal_time_new_from_timet_with_zone (end, FALSE, NULL);

  e_cal_recur_generate_instances_sync (component,
                                       start_time,
                                       end_time,
                                       calendar_appointment_collect_occurrence,
                                       &appointment->occurrences,
                                       resolve_timezone_id,
                                       source,
                                       default_zone,
                                       NULL,
                                       NULL);

  g_object_unref (start_time);
 g_object_unref (end_time);

  appointment->occurrences = g_slist_reverse (appointment->occurrences);
}

static inline gboolean
calendar_task_equal (CalendarTask *a,
		     CalendarTask *b)
{
  return
    g_strcmp0 (a->uid, b->uid) == 0 &&
    g_strcmp0 (a->summary, b->summary) == 0 &&
    g_strcmp0 (a->description, b->description) == 0 &&
    g_strcmp0 (a->color_string, b->color_string) == 0 &&
    a->start_time == b->start_time &&
    a->due_time == b->due_time &&
    a->percent_complete == b->percent_complete &&
    a->completed_time == b->completed_time &&
    a->priority == b->priority;
}

static void
calendar_task_copy (CalendarTask *task,
		    CalendarTask *task_copy)
{
  g_assert (task != NULL);
  g_assert (task_copy != NULL);

  task_copy->uid              = g_strdup (task->uid);
  task_copy->summary          = g_strdup (task->summary);
  task_copy->description      = g_strdup (task->description);
  task_copy->color_string     = g_strdup (task->color_string);
  task_copy->start_time       = task->start_time;
  task_copy->due_time         = task->due_time;
  task_copy->percent_complete = task->percent_complete;
  task_copy->completed_time   = task->completed_time;
  task_copy->priority         = task->priority;
}

static void
calendar_task_finalize (CalendarTask *task)
{
  g_free (task->uid);
  task->uid = NULL;

  g_free (task->summary);
  task->summary = NULL;

  g_free (task->description);
  task->description = NULL;

  g_free (task->color_string);
  task->color_string = NULL;

  task->percent_complete = 0;
}

static void
calendar_task_init (CalendarTask         *task,
                    ICalComponent        *component,
                    CalendarClientSource *source,
                    ICalTimezone         *default_zone)
{
  task->uid = get_component_uid (component);
  task->summary = get_component_summary (component);
  task->description = get_component_description (component);
  task->color_string = get_source_color (source->source);
  task->start_time = get_component_start_time (component, default_zone);
  task->due_time = get_component_due_time (component, default_zone);
  task->percent_complete = get_component_percent_complete (component);
  task->completed_time = get_component_completed_time (component, default_zone);
  task->priority = get_component_priority (component);
}

void
calendar_event_free (CalendarEvent *event)
{
  switch (event->type)
    {
    case CALENDAR_EVENT_APPOINTMENT:
      calendar_appointment_finalize (CALENDAR_APPOINTMENT (event));
      break;
    case CALENDAR_EVENT_TASK:
      calendar_task_finalize (CALENDAR_TASK (event));
      break;
    case CALENDAR_EVENT_ALL:
    default:
      g_assert_not_reached ();
      break;
    }

  g_free (event);
}

static CalendarEvent *
calendar_event_new (ICalComponent        *component,
                    CalendarClientSource *source,
                    ICalTimezone         *default_zone)
{
  CalendarEvent *event;
  ICalComponentKind component_kind;

  event = g_new0 (CalendarEvent, 1);
  component_kind = i_cal_component_isa (component);

  if (component_kind == I_CAL_VEVENT_COMPONENT)
    {
      event->type = CALENDAR_EVENT_APPOINTMENT;
      calendar_appointment_init (CALENDAR_APPOINTMENT (event),
                                 component, source, default_zone);
    }
  else if (component_kind == I_CAL_VTODO_COMPONENT)
    {
      event->type = CALENDAR_EVENT_TASK;
      calendar_task_init (CALENDAR_TASK (event),
                          component, source, default_zone);
    }
  else
    {
      g_warning ("Unknown calendar component type: %d\n", component_kind);
      g_free (event);

      return NULL;
    }

  return event;
}

static CalendarEvent *
calendar_event_copy (CalendarEvent *event)
{
  CalendarEvent *retval;

  if (!event)
    return NULL;

  retval = g_new0 (CalendarEvent, 1);

  retval->type = event->type;

  switch (event->type)
    {
    case CALENDAR_EVENT_APPOINTMENT:
      calendar_appointment_copy (CALENDAR_APPOINTMENT (event),
				 CALENDAR_APPOINTMENT (retval));
      break;
    case CALENDAR_EVENT_TASK:
      calendar_task_copy (CALENDAR_TASK (event),
			  CALENDAR_TASK (retval));
      break;
    case CALENDAR_EVENT_ALL:
    default:
      g_assert_not_reached ();
      break;
    }

  return retval;
}

static char *
calendar_event_get_uid (CalendarEvent *event)
{
  switch (event->type)
    {
    case CALENDAR_EVENT_APPOINTMENT:
      return g_strdup_printf ("%s%s", CALENDAR_APPOINTMENT (event)->uid, CALENDAR_APPOINTMENT (event)->rid ? CALENDAR_APPOINTMENT (event)->rid : ""); 
      break;
    case CALENDAR_EVENT_TASK:
      return g_strdup (CALENDAR_TASK (event)->uid);
      break;
    case CALENDAR_EVENT_ALL:
    default:
      g_assert_not_reached ();
      break;
    }

  return NULL;
}

static gboolean
calendar_event_equal (CalendarEvent *a,
		      CalendarEvent *b)
{
  if (!a && !b)
    return TRUE;

  if ((a && !b) || (!a && b))
    return FALSE;

  if (a->type != b->type)
    return FALSE;

  switch (a->type)
    {
    case CALENDAR_EVENT_APPOINTMENT:
      return calendar_appointment_equal (CALENDAR_APPOINTMENT (a),
					 CALENDAR_APPOINTMENT (b));
    case CALENDAR_EVENT_TASK:
      return calendar_task_equal (CALENDAR_TASK (a),
				  CALENDAR_TASK (b));
    case CALENDAR_EVENT_ALL:
    default:
      break;
    }
 
  g_assert_not_reached ();

  return FALSE;
}

static void
calendar_event_generate_ocurrences (CalendarEvent *event,
                                    ICalComponent *component,
                                    ECalClient    *source,
                                    time_t         start,
                                    time_t         end,
                                    ICalTimezone  *default_zone)
{
  if (event->type != CALENDAR_EVENT_APPOINTMENT)
    return;

  calendar_appointment_generate_ocurrences (CALENDAR_APPOINTMENT (event),
                                            component,
                                            source,
                                            start,
                                            end,
                                            default_zone);
}

static inline void
calendar_event_debug_dump (CalendarEvent *event)
{
#ifdef CALENDAR_ENABLE_DEBUG
  switch (event->type)
    {
    case CALENDAR_EVENT_APPOINTMENT:
      {
	char   *start_str;
	char   *end_str;
	GSList *l;

	start_str = CALENDAR_APPOINTMENT (event)->start_time ?
	                    isodate_from_time_t (CALENDAR_APPOINTMENT (event)->start_time) :
	                    g_strdup ("(undefined)");
	end_str = CALENDAR_APPOINTMENT (event)->end_time ?
	                    isodate_from_time_t (CALENDAR_APPOINTMENT (event)->end_time) :
	                    g_strdup ("(undefined)");
	  
	dprintf ("Appointment: uid '%s', summary '%s', description '%s', "
		 "start_time '%s', end_time '%s', is_all_day %s\n",
		 CALENDAR_APPOINTMENT (event)->uid,
		 CALENDAR_APPOINTMENT (event)->summary,
		 CALENDAR_APPOINTMENT (event)->description,
		 start_str,
		 end_str,
		 CALENDAR_APPOINTMENT (event)->is_all_day ? "(true)" : "(false)");

	g_free (start_str);
	g_free (end_str);

	dprintf ("  Occurrences:\n");
	for (l = CALENDAR_APPOINTMENT (event)->occurrences; l; l = l->next)
	  {
	    CalendarOccurrence *occurrence = l->data;

	    start_str = occurrence->start_time ?
	      isodate_from_time_t (occurrence->start_time) :
	      g_strdup ("(undefined)");
	    
	    end_str = occurrence->end_time ?
	      isodate_from_time_t (occurrence->end_time) :
	      g_strdup ("(undefined)");

	    dprintf ("    start_time '%s', end_time '%s'\n",
		     start_str, end_str);

	    g_free (start_str);
	    g_free (end_str);
	  }
      }
      break;
    case CALENDAR_EVENT_TASK:
      {
	char *start_str;
	char *due_str;
	char *completed_str;

	start_str = CALENDAR_TASK (event)->start_time ?
	                    isodate_from_time_t (CALENDAR_TASK (event)->start_time) :
	                    g_strdup ("(undefined)");
	due_str = CALENDAR_TASK (event)->due_time ?
	                    isodate_from_time_t (CALENDAR_TASK (event)->due_time) :
	                    g_strdup ("(undefined)");
	completed_str = CALENDAR_TASK (event)->completed_time ?
	                    isodate_from_time_t (CALENDAR_TASK (event)->completed_time) :
	                    g_strdup ("(undefined)");

	dprintf ("Task: uid '%s', summary '%s', description '%s', "
		 "start_time '%s', due_time '%s', percent_complete %d, completed_time '%s'\n",
		 CALENDAR_TASK (event)->uid,
		 CALENDAR_TASK (event)->summary,
		 CALENDAR_TASK (event)->description,
		 start_str,
		 due_str,
		 CALENDAR_TASK (event)->percent_complete,
		 completed_str);

	g_free (completed_str);
      }
      break;
    default:
      g_assert_not_reached ();
      break;
    }
#endif
}

static inline CalendarClientQuery *
goddamn_this_is_crack (CalendarClientSource *source,
                       ECalClientView       *view,
                       gboolean             *emit_signal)
{
  g_assert (view != NULL);

  if (source->completed_query.view == view)
    {
      if (emit_signal)
	*emit_signal = TRUE;
      return &source->completed_query;
    }
  else if (source->in_progress_query.view == view)
    {
      if (emit_signal)
	*emit_signal = FALSE;
      return &source->in_progress_query;
    }

  g_assert_not_reached ();

  return NULL;
}

static void
calendar_client_handle_query_completed (CalendarClientSource *source,
                                        GError               *error,
                                        ECalClientView       *view)
{
  CalendarClientQuery *query;

  query = goddamn_this_is_crack (source, view, NULL);
  
  dprintf ("Query %p completed", query);

  if (error != NULL)
    {
      g_warning ("Calendar query failed: %s", error->message);
      calendar_client_stop_query (source->client, source, query);
      return;
    }

  g_assert (source->query_in_progress != FALSE);
  g_assert (query == &source->in_progress_query);

  calendar_client_query_finalize (&source->completed_query);

  source->completed_query = source->in_progress_query;
  source->query_completed = TRUE;

  source->query_in_progress        = FALSE;
  source->in_progress_query.view   = NULL;
  source->in_progress_query.events = NULL;

  g_signal_emit (source->client, source->changed_signal_id, 0);
}

static void
calendar_client_handle_query_result (CalendarClientSource *source,
                                     GList                *objects,
                                     ECalClientView       *view)
{
  CalendarClientQuery *query;
  CalendarClient      *client;
  gboolean             emit_signal;
  gboolean             events_changed;
  GList               *l;
  time_t               month_begin;
  time_t               month_end;

  client = source->client;

  query = goddamn_this_is_crack (source, view, &emit_signal);

  dprintf ("Query %p result: %d objects:\n",
	   query, g_list_length (objects));

  month_begin = make_time_for_day_begin (1,
					 client->priv->month,
					 client->priv->year);

  month_end = make_time_for_day_begin (1,
				       client->priv->month + 1,
				       client->priv->year);

  events_changed = FALSE;
  for (l = objects; l; l = l->next)
    {
      CalendarEvent *event;
      CalendarEvent *old_event;
      ICalComponent *component = l->data;
      char          *uid;
      
      event = calendar_event_new (component, source, client->priv->zone);
      if (!event)
	      continue;

      calendar_event_generate_ocurrences (event,
                                          component,
                                          source->source,
                                          month_begin,
                                          month_end,
                                          client->priv->zone);

      uid = calendar_event_get_uid (event);
      
      old_event = g_hash_table_lookup (query->events, uid);

      if (!calendar_event_equal (event, old_event))
	{
 	  dprintf ("Event %s: ", old_event ? "modified" : "added");

	  calendar_event_debug_dump (event);

	  g_hash_table_replace (query->events, uid, event);

	  events_changed = TRUE;
	}
      else
	{
	  g_free (uid);
	}		
    }

  if (emit_signal && events_changed)
    {
      g_signal_emit (source->client, source->changed_signal_id, 0);
    }
}

static gboolean
check_object_remove (gpointer key,
                     gpointer value,
                     gpointer data)
{
  char *uid;
  size_t len;

  uid = data;
  len = strlen (uid);
  
  if (len <= strlen (key) && strncmp (uid, key, len) == 0)
    {
      dprintf ("Event removed: ");

      calendar_event_debug_dump (value);

      return TRUE;
    }

  return FALSE;
}

static void
calendar_client_handle_objects_removed (CalendarClientSource *source,
                                        GList                *ids,
                                        ECalClientView       *view)
{
  CalendarClientQuery *query;
  gboolean             emit_signal;
  gboolean             events_changed;
  GList               *l;

  query = goddamn_this_is_crack (source, view, &emit_signal);

  events_changed = FALSE;
  for (l = ids; l; l = l->next)
    {
      CalendarEvent *event;
      ECalComponentId *id;
      const char *uid;
      const char *rid;
      char  *key;

      id = l->data;
      uid = e_cal_component_id_get_uid (id);
      rid = e_cal_component_id_get_rid (id);
      key = g_strdup_printf ("%s%s", uid, rid ? rid : "");

      if (!rid || !*rid)
        {
          guint size = g_hash_table_size (query->events);

          g_hash_table_foreach_remove (query->events, check_object_remove, (gpointer) uid);

          if (size != g_hash_table_size (query->events))
            events_changed = TRUE;
        }
      else if ((event = g_hash_table_lookup (query->events, key)))
        {
          dprintf ("Event removed: ");

          calendar_event_debug_dump (event);

          g_assert (g_hash_table_remove (query->events, key));

          events_changed = TRUE;
        }

      g_free (key);
    }

  if (emit_signal && events_changed)
    {
      g_signal_emit (source->client, source->changed_signal_id, 0);
    }
}

static void
calendar_client_query_finalize (CalendarClientQuery *query)
{
  if (query->view)
    g_object_unref (query->view);
  query->view = NULL;

  if (query->events)
    g_hash_table_destroy (query->events);
  query->events = NULL;
}

static void
calendar_client_stop_query (CalendarClient       *client,
			    CalendarClientSource *source,
			    CalendarClientQuery  *query)
{
  if (query == &source->in_progress_query)
    {
      dprintf ("Stopping in progress query %p\n", query);

      g_assert (source->query_in_progress != FALSE);

      source->query_in_progress = FALSE;
    }
  else if (query == &source->completed_query)
    {
      dprintf ("Stopping completed query %p\n", query);

      g_assert (source->query_completed != FALSE);

      source->query_completed = FALSE;
    }
  else
    g_assert_not_reached ();
  
  calendar_client_query_finalize (query);
}

static void
calendar_client_start_query (CalendarClient       *client,
			     CalendarClientSource *source,
			     const char           *query)
{
  ECalClientView *view = NULL;
  GError *error = NULL;

  if (!e_cal_client_get_view_sync (source->source, query, &view, NULL, &error))
    {
      g_warning ("Error preparing the query: '%s': %s",
                 query, error->message);

      g_error_free (error);
      return;
    }

  g_assert (view != NULL);

  if (source->query_in_progress)
    calendar_client_stop_query (client, source, &source->in_progress_query);
  
  dprintf ("Starting query %p: '%s'\n", &source->in_progress_query, query);

  source->query_in_progress        = TRUE;
  source->in_progress_query.view   = view;
  source->in_progress_query.events =
    g_hash_table_new_full (g_str_hash,
			   g_str_equal,
			   g_free,
			   (GDestroyNotify) calendar_event_free);

  g_signal_connect_swapped (view, "objects-added",
			    G_CALLBACK (calendar_client_handle_query_result),
			    source);
  g_signal_connect_swapped (view, "objects-modified",
			    G_CALLBACK (calendar_client_handle_query_result),
			    source);
  g_signal_connect_swapped (view, "objects-removed",
			    G_CALLBACK (calendar_client_handle_objects_removed),
			    source);
  g_signal_connect_swapped (view, "complete",
			    G_CALLBACK (calendar_client_handle_query_completed),
			    source);

  e_cal_client_view_start (view, NULL);
}

static void
calendar_client_update_appointments (CalendarClient *client)
{
  GSList *l;
  char   *query;
  char   *month_begin;
  char   *month_end;

  if (client->priv->month == 0 || client->priv->year == 0)
    return;

  month_begin = make_isodate_for_day_begin (1,
					    client->priv->month,
					    client->priv->year);

  month_end = make_isodate_for_day_begin (1,
					  client->priv->month + 1,
					  client->priv->year);

  query = g_strdup_printf ("occur-in-time-range? (make-time \"%s\") "
			                        "(make-time \"%s\")",
			   month_begin, month_end);

  for (l = client->priv->appointment_sources; l; l = l->next)
    {
      CalendarClientSource *cs = l->data;

      calendar_client_start_query (client, cs, query);
    }

  g_free (month_begin);
  g_free (month_end);
  g_free (query);
}

/* FIXME:
 * perhaps we should use evo's "hide_completed_tasks" pref?
 */
static void
calendar_client_update_tasks (CalendarClient *client)
{
  GSList *l;
  char   *query;

#ifdef FIX_BROKEN_TASKS_QUERY
  /* FIXME: this doesn't work for tasks without a start or
   *        due date
   *        Look at filter_task() to see the behaviour we
   *        want.
   */
  
  char   *day_begin;
  char   *day_end;

  if (client->priv->day == 0 ||
      client->priv->month == 0 ||
      client->priv->year == 0)
    return;

  day_begin = make_isodate_for_day_begin (client->priv->day,
					  client->priv->month,
					  client->priv->year);

  day_end = make_isodate_for_day_begin (client->priv->day + 1,
					client->priv->month,
					client->priv->year);
  if (!day_begin || !day_end)
    {
      g_warning ("Cannot run query with invalid date: %dd %dy %dm\n",
		 client->priv->day,
		 client->priv->month,
		 client->priv->year);
      g_free (day_begin);
      g_free (day_end);
      return;
    }
  
  query = g_strdup_printf ("(and (occur-in-time-range? (make-time \"%s\") "
                                                      "(make-time \"%s\")) "
                             "(or (not is-completed?) "
                               "(and (is-completed?) "
                                    "(not (completed-before? (make-time \"%s\"))))))",
			   day_begin, day_end, day_begin);
#else
  query = g_strdup ("#t");
#endif /* FIX_BROKEN_TASKS_QUERY */

  for (l = client->priv->task_sources; l; l = l->next)
    {
      CalendarClientSource *cs = l->data;

      calendar_client_start_query (client, cs, query);
    }

#ifdef FIX_BROKEN_TASKS_QUERY
  g_free (day_begin);
  g_free (day_end);
#endif
  g_free (query);
}

static void
calendar_client_source_finalize (CalendarClientSource *source)
{
  source->client = NULL;

  if (source->source) {
    g_object_unref (source->source);
  }
  source->source = NULL;

  calendar_client_query_finalize (&source->completed_query);
  calendar_client_query_finalize (&source->in_progress_query);
  
  source->query_completed   = FALSE;
  source->query_in_progress = FALSE;
}

static int
compare_calendar_sources (CalendarClientSource *s1,
			  CalendarClientSource *s2)
{
  return (s1->source == s2->source) ? 0 : 1;
}

static GSList *
calendar_client_update_sources_list (CalendarClient *client,
				     GSList         *sources,
				     GList          *esources,
				     guint           changed_signal_id)
{
  GList *link;
  GSList *retval, *l;

  retval = NULL;

  for (link = esources; link != NULL; link = g_list_next (link->next))
    {
      CalendarClientSource  dummy_source;
      CalendarClientSource *new_source;
      GSList               *s;
      ECalClient           *esource = link->data;

      dummy_source.source = esource;

      dprintf ("update_sources_list: adding client %s: ",
	       e_source_peek_uid (e_client_get_source (E_CLIENT (esource))));

      if ((s = g_slist_find_custom (sources,
				    &dummy_source,
				    (GCompareFunc) compare_calendar_sources)))
	{
	  dprintf ("already on list\n");
	  new_source = s->data;
	  sources = g_slist_delete_link (sources, s);
	}
      else
	{
	  dprintf ("added\n");
	  new_source                    = g_new0 (CalendarClientSource, 1);
	  new_source->client            = client;
	  new_source->source            = g_object_ref (esource);
	  new_source->changed_signal_id = changed_signal_id;
	}

      retval = g_slist_prepend (retval, new_source);
    }

  for (l = sources; l; l = l->next)
    {
      CalendarClientSource *source = l->data;

      dprintf ("Removing client %s from list\n",
	       e_source_peek_uid (e_client_get_source (E_CLIENT (source->source))));

      calendar_client_source_finalize (source);
      g_free (source);
    }
  g_slist_free (sources);

  return retval;
}

static void
calendar_client_appointment_sources_changed (CalendarClient  *client)
{
  GList *list;

  dprintf ("appointment_sources_changed: updating ...\n");

  list = calendar_sources_get_appointment_clients (client->priv->calendar_sources);

  client->priv->appointment_sources = 
    calendar_client_update_sources_list (client,
					 client->priv->appointment_sources,
					 list,
					 signals [APPOINTMENTS_CHANGED]);

  load_calendars (client, CALENDAR_EVENT_APPOINTMENT);
  calendar_client_update_appointments (client);

  g_list_free (list);
}

static void
calendar_client_task_sources_changed (CalendarClient  *client)
{
  GList *list;

  dprintf ("task_sources_changed: updating ...\n");

  list = calendar_sources_get_task_clients (client->priv->calendar_sources);

  client->priv->task_sources = 
    calendar_client_update_sources_list (client,
					 client->priv->task_sources,
					 list,
					 signals [TASKS_CHANGED]);

  load_calendars (client, CALENDAR_EVENT_TASK);
  calendar_client_update_tasks (client);

  g_list_free (list);
}

void
calendar_client_get_date (CalendarClient *client,
                          guint          *year,
                          guint          *month,
                          guint          *day)
{
  g_return_if_fail (CALENDAR_IS_CLIENT (client));

  if (year)
    *year = client->priv->year;

  if (month)
    *month = client->priv->month;

  if (day)
    *day = client->priv->day;
}

void
calendar_client_select_month (CalendarClient *client,
			      guint           month,
			      guint           year)
{
  g_return_if_fail (CALENDAR_IS_CLIENT (client));
  g_return_if_fail (month <= 11);

  if (client->priv->year != year || client->priv->month != month)
    {
      client->priv->month = month;
      client->priv->year  = year;

      calendar_client_update_appointments (client);
      calendar_client_update_tasks (client);

      g_object_freeze_notify (G_OBJECT (client));
      g_object_notify (G_OBJECT (client), "month");
      g_object_notify (G_OBJECT (client), "year");
      g_object_thaw_notify (G_OBJECT (client));
    }
}

void
calendar_client_select_day (CalendarClient *client,
			    guint           day)
{
  g_return_if_fail (CALENDAR_IS_CLIENT (client));
  g_return_if_fail (day <= 31);

  if (client->priv->day != day)
    {
      client->priv->day = day;

      /* don't need to update appointments unless
       * the selected month changes
       */
#ifdef FIX_BROKEN_TASKS_QUERY
      calendar_client_update_tasks (client);
#endif

      g_object_notify (G_OBJECT (client), "day");
    }
}

typedef struct
{
  CalendarClient *client;
  GSList         *events;
  time_t          start_time;
  time_t          end_time;
} FilterData;

typedef void (* CalendarEventFilterFunc) (const char    *uid,
					  CalendarEvent *event,
					  FilterData    *filter_data);

static void
filter_appointment (const char    *uid,
		    CalendarEvent *event,
		    FilterData    *filter_data)
{
  GSList *occurrences, *l;

  if (event->type != CALENDAR_EVENT_APPOINTMENT)
    return;

  occurrences = CALENDAR_APPOINTMENT (event)->occurrences;
  CALENDAR_APPOINTMENT (event)->occurrences = NULL;

  for (l = occurrences; l; l = l->next)
    {
      CalendarOccurrence *occurrence = l->data;
      time_t start_time = occurrence->start_time;
      time_t end_time   = occurrence->end_time;

      if ((start_time >= filter_data->start_time &&
           start_time < filter_data->end_time) ||
          (start_time <= filter_data->start_time &&
           (end_time - 1) > filter_data->start_time))
	{
	  CalendarEvent *new_event;

	  new_event = calendar_event_copy (event);
	      
	  CALENDAR_APPOINTMENT (new_event)->start_time = occurrence->start_time;
	  CALENDAR_APPOINTMENT (new_event)->end_time   = occurrence->end_time;
	      
	  filter_data->events = g_slist_prepend (filter_data->events, new_event);
	}
    }

  CALENDAR_APPOINTMENT (event)->occurrences = occurrences;
}

static void
filter_task (const char    *uid,
	     CalendarEvent *event,
	     FilterData    *filter_data)
{
#ifdef FIX_BROKEN_TASKS_QUERY
  CalendarTask *task;
#endif

  if (event->type != CALENDAR_EVENT_TASK)
    return;

#ifdef FIX_BROKEN_TASKS_QUERY
  task = CALENDAR_TASK (event);

  if (task->start_time && task->start_time > filter_data->start_time)
    return;

  if (task->completed_time && 
      (task->completed_time < filter_data->start_time ||
       task->completed_time > filter_data->end_time))
    return;
#endif /* FIX_BROKEN_TASKS_QUERY */

  filter_data->events = g_slist_prepend (filter_data->events,
					 calendar_event_copy (event));
}

static GSList *
calendar_client_filter_events (CalendarClient          *client,
			       GSList                  *sources,
			       CalendarEventFilterFunc  filter_func,
			       time_t                   start_time,
			       time_t                   end_time)
{
  FilterData  filter_data;
  GSList     *l;
  GSList     *retval;

  if (!sources)
    return NULL;

  filter_data.client     = client;
  filter_data.events     = NULL;
  filter_data.start_time = start_time;
  filter_data.end_time   = end_time;

  retval = NULL;
  for (l = sources; l; l = l->next)
    {
      CalendarClientSource *source = l->data;

      if (source->query_completed)
	{
	  filter_data.events = NULL;
	  g_hash_table_foreach (source->completed_query.events,
				(GHFunc) filter_func,
				&filter_data);

	  filter_data.events = g_slist_reverse (filter_data.events);

	  retval = g_slist_concat (retval, filter_data.events);
	}
    }

  return retval;
}

GSList *
calendar_client_get_events (CalendarClient    *client,
			    CalendarEventType  event_mask)
{
  GSList *appointments;
  GSList *tasks;
  time_t  day_begin;
  time_t  day_end;

  g_return_val_if_fail (CALENDAR_IS_CLIENT (client), NULL);
  g_return_val_if_fail (client->priv->day != 0, NULL);
  g_return_val_if_fail (client->priv->month != 0, NULL);
  g_return_val_if_fail (client->priv->year != 0, NULL);

  day_begin = make_time_for_day_begin (client->priv->day,
				       client->priv->month,
				       client->priv->year);
  day_end   = make_time_for_day_begin (client->priv->day + 1,
				       client->priv->month,
				       client->priv->year);

  appointments = NULL;
  if (event_mask & CALENDAR_EVENT_APPOINTMENT)
    {
      appointments = calendar_client_filter_events (client,
						    client->priv->appointment_sources,
						    filter_appointment,
						    day_begin,
						    day_end);
    }

  tasks = NULL;
  if (event_mask & CALENDAR_EVENT_TASK)
    {
      tasks = calendar_client_filter_events (client,
					     client->priv->task_sources,
					     filter_task,
					     day_begin,
					     day_end);
    }

  return g_slist_concat (appointments, tasks);
}

static inline int
day_from_time_t (time_t t)
{
  struct tm *tm = localtime (&t);

  g_assert (tm == NULL || (tm->tm_mday >=1 && tm->tm_mday <= 31));

  return tm ? tm->tm_mday : 0;
}

void
calendar_client_foreach_appointment_day (CalendarClient  *client,
					 CalendarDayIter  iter_func,
					 gpointer         user_data)
{
  GSList   *appointments, *l;
  gboolean  marked_days [32] = { FALSE, };
  time_t    month_begin;
  time_t    month_end;
  int       i;

  g_return_if_fail (CALENDAR_IS_CLIENT (client));
  g_return_if_fail (iter_func != NULL);
  g_return_if_fail (client->priv->month != 0);
  g_return_if_fail (client->priv->year != 0);

  month_begin = make_time_for_day_begin (1,
					 client->priv->month,
					 client->priv->year);
  month_end   = make_time_for_day_begin (1,
					 client->priv->month + 1,
					 client->priv->year);
  
  appointments = calendar_client_filter_events (client,
						client->priv->appointment_sources,
						filter_appointment,
						month_begin,
						month_end);
  for (l = appointments; l; l = l->next)
    {
      CalendarAppointment *appointment = l->data;

      if (appointment->start_time)
        {
          time_t day_time = appointment->start_time;

          if (day_time >= month_begin)
            marked_days [day_from_time_t (day_time)] = TRUE;
      
          if (appointment->end_time)
            {
              int day_offset;
              int duration = appointment->end_time - appointment->start_time;
	      /* mark the days for the appointment, no need to add an extra one when duration is a multiple of 86400 */
              for (day_offset = 1; day_offset <= duration / 86400 && duration != day_offset * 86400; day_offset++)
                {
                  time_t day_tm = appointment->start_time + day_offset * 86400;

                  if (day_tm > month_end)
                    break;
                  if (day_tm >= month_begin)
                    marked_days [day_from_time_t (day_tm)] = TRUE;
                }
            }
        }
      calendar_event_free (CALENDAR_EVENT (appointment));
    }

  g_slist_free (appointments);

  for (i = 1; i < 32; i++)
    {
      if (marked_days [i])
	iter_func (client, i, user_data);
    }
}

void
calendar_client_set_task_completed (CalendarClient *client,
				    char           *task_uid,
				    gboolean        task_completed,
				    guint           percent_complete)
{
  GSList *l;
  ECalClient *esource;
  ICalComponent *component;
  ICalProperty *prop;
  ICalPropertyStatus status;

  g_return_if_fail (CALENDAR_IS_CLIENT (client));
  g_return_if_fail (task_uid != NULL);
  g_return_if_fail (task_completed == FALSE || percent_complete == 100);

  component = NULL;
  esource = NULL;
  for (l = client->priv->task_sources; l; l = l->next)
    {
      CalendarClientSource *source = l->data;

      esource = source->source;
      e_cal_client_get_object_sync (esource, task_uid, NULL, &component, NULL, NULL);
      if (component)
        break;
    }

  if (!component)
    {
      g_warning ("Cannot locate task with uid = '%s'\n", task_uid);
      return;
    }

  g_assert (esource != NULL);

  /* Completed time */
  prop = i_cal_component_get_first_property (component, I_CAL_COMPLETED_PROPERTY);
  if (task_completed)
    {
      ICalTime *completed_time;

      completed_time = i_cal_time_new_current_with_zone (client->priv->zone);
      if (!prop)
        {
          i_cal_component_take_property (component,
                                         i_cal_property_new_completed (completed_time));
        }
      else
        {
          i_cal_property_set_completed (prop, completed_time);
        }
    }
  else if (prop)
    {
      i_cal_component_remove_property (component, prop);
    }
  g_clear_object (&prop);

  /* Percent complete */
  prop = i_cal_component_get_first_property (component, I_CAL_PERCENTCOMPLETE_PROPERTY);
  if (!prop)
    {
      i_cal_component_take_property (component,
                                    i_cal_property_new_percentcomplete (percent_complete));
    }
  else
    {
      i_cal_property_set_percentcomplete (prop, percent_complete);
    }
  g_clear_object (&prop);

  /* Status */
  status = task_completed ? I_CAL_STATUS_COMPLETED : I_CAL_STATUS_NEEDSACTION;
  prop = i_cal_component_get_first_property (component, I_CAL_STATUS_PROPERTY);
  if (prop)
    {
      i_cal_property_set_status (prop, status);
    }
  else
    {
      i_cal_component_take_property (component, i_cal_property_new_status (status));
    }
  g_clear_object (&prop);

  e_cal_client_modify_object_sync (esource,
                                   component,
                                   E_CAL_OBJ_MOD_ALL,
                                   0,
                                   NULL,
                                   NULL);
}
