/* -*- indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* LD_PRELOAD functions to make libgconf read defaults out of local schemas
 * Copyright (C) 2009 Red Hat Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
#define _GNU_SOURCE /* for RTLD_NEXT */
#include <dlfcn.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "gconf-defaults-hack.h"

gboolean
gconf_defaults_hack_verbose (void)
{
  static int verbose = -1;

  if (verbose < 0)
    {
      const char *str = g_getenv ("GCONF_DEFAULTS_VERBOSE");
      verbose = (str && str[0]);
    }

  return verbose;
}

GConfValueType
gconf_defaults_hack_value_type_from_string (const char *str)
{
  if (str == NULL)
    return GCONF_VALUE_INVALID;

  switch (str[0])
    {
    case 'b':
      if (strcmp (str, "bool") == 0)
        return GCONF_VALUE_BOOL;
      break;
    case 'f':
      if (strcmp (str, "float") == 0)
        return GCONF_VALUE_FLOAT;
      break;
    case 'i':
      if (strcmp (str, "int") == 0)
        return GCONF_VALUE_INT;
      break;
    case 'l':
      if (strcmp (str, "list") == 0)
        return GCONF_VALUE_LIST;
      break;
    case 'p':
      if (strcmp (str, "pair") == 0)
        return GCONF_VALUE_PAIR;
      break;
    case 's':
      if (strcmp (str, "string") == 0)
        return GCONF_VALUE_STRING;
      break;
    }

  return GCONF_VALUE_INVALID;
}

static time_t
get_mtime (const char *filename)
{
  struct stat st;

  if (stat (filename, &st) == 0)
    {
      return st.st_mtime;
    }
  else
    return (time_t)-1;
}

static time_t
get_dir_mtime (const char *dir_filename)
{
  GDir *dir = NULL;
  GError *error = NULL;
  time_t mtime;

  dir = g_dir_open (dir_filename, 0, &error);
  if (!dir)
    {
      g_error_free (error);
      return (time_t)-1;
    }

  mtime = get_mtime (dir_filename);

  while (TRUE)
    {
      char *filename;
      const char *name = g_dir_read_name (dir);
      time_t file_mtime;
      if (!name)
        break;

      if (!g_str_has_suffix (name, ".schemas"))
        continue;

      filename = g_build_filename (dir_filename, name, NULL);
      file_mtime = get_mtime (filename);
      if (file_mtime != (time_t)-1 && file_mtime > mtime)
        mtime = file_mtime;

      g_free (filename);
    }

  g_dir_close (dir);

  return mtime;
}

static GConfDefaultsHackDatabase *
open_database (void)
{
  GConfDefaultsHackDatabase *database = NULL;
  const char *schemas_dir;
  gboolean schemas_dir_writable;
  char *db_file;
  time_t db_mtime;
  time_t dir_mtime;

  schemas_dir = g_getenv ("GCONF_DEFAULTS_SCHEMAS_DIR");
  if (schemas_dir == NULL)
    schemas_dir = SYSCONFDIR "/gconf/schemas";

  schemas_dir_writable = access (schemas_dir, W_OK) == 0;
  if (schemas_dir_writable)
    {
      db_file = g_build_filename (schemas_dir, ".gconfdefaults.sqlite", NULL);
    }
  else
    {
      GString *tmp = g_string_new (".gconfdefaults.");
      const char *p;
      gboolean last_was_slash = FALSE;

      for (p = schemas_dir; *p; p++)
        {
          if (*p == '/')
            {
              if (!last_was_slash)
                g_string_append_c (tmp, '_');
              last_was_slash = TRUE;
            }
          else
            {
              if (*p == '_')
                g_string_append (tmp, "__");
              else
                g_string_append_c (tmp, *p);
              last_was_slash = FALSE;
            }
        }
      g_string_append (tmp, ".sqlite");

      db_file = g_build_filename (g_get_home_dir(), tmp->str, NULL);
      g_string_free (tmp, TRUE);
    }

  if (gconf_defaults_hack_verbose ())
    {
      g_printerr("gconf-defaults-hack: schemas_dir=%s, db_file=%s\n",
                 schemas_dir, db_file);
    }

  db_mtime = get_mtime (db_file);
  dir_mtime = get_dir_mtime (schemas_dir);

  if (dir_mtime != (time_t)-1)
    {
      database = gconf_defaults_hack_database_open (db_file);

      if (database &&
          (db_mtime == (time_t)-1 || db_mtime < dir_mtime))
        {
          if (gconf_defaults_hack_verbose ())
            g_printerr ("Rebuilding database: db_mtime=%ld, dir_mtime=%ld\n",
                        (long)db_mtime, (long)dir_mtime);

          gconf_defaults_hack_rebuild_database (database, schemas_dir);
        }
    }

  g_free (db_file);

  return database;
}

static GConfDefaultsHackDatabase *
get_database (void)
{
  static GConfDefaultsHackDatabase *database;
  static gboolean initialized = FALSE;

  if (!initialized)
    {
      initialized = TRUE;
      database = open_database ();
    }

  return database;
}

static GConfValueType
validate_element_type (const char *str,
		       GError    **error)
{
  GConfValueType type;

  if (str == NULL)
    {
      g_set_error (error, GCONF_ERROR, GCONF_ERROR_CORRUPT,
                   "Missing element type in defaults database");
      return GCONF_VALUE_INVALID;
    }

  type = gconf_defaults_hack_value_type_from_string (str);
  if (type == GCONF_VALUE_INVALID ||
      type == GCONF_VALUE_LIST ||
      type == GCONF_VALUE_PAIR)
    {
      g_set_error (error, GCONF_ERROR, GCONF_ERROR_CORRUPT,
		   "Bad element type '%s' in defaults database", str);
      return GCONF_VALUE_INVALID;
    }

  return type;
}

static GConfValue *
get_default_from_database (const char *key,
                           GError    **error)
{
  GConfDefaultsHackDatabase *database = get_database ();
  GConfDefaultsHackEntry *entry;
  GConfValue *value = NULL;
  GConfValueType type;

  if (database == NULL)
    goto out;

  entry = gconf_defaults_hack_database_get (database, key);
  if (!entry)
    goto out;

  if (entry->default_value == NULL)
    {
      g_set_error (error, GCONF_ERROR, GCONF_ERROR_CORRUPT,
		   "Defaults database entry is missing a value");
      goto out;
    }

  type = gconf_defaults_hack_value_type_from_string (entry->type);
  switch (type)
    {
    case GCONF_VALUE_INVALID:
    case GCONF_VALUE_SCHEMA:
      g_set_error (error, GCONF_ERROR, GCONF_ERROR_CORRUPT,
                   "Bad type '%s' in defaults database",
                   entry->type ? entry->type : "<none>");
      break;
    case GCONF_VALUE_STRING:
    case GCONF_VALUE_INT:
    case GCONF_VALUE_FLOAT:
    case GCONF_VALUE_BOOL:
      value = gconf_value_new_from_string (type, entry->default_value, error);
      break;
    case GCONF_VALUE_LIST:
      {
	GConfValueType list_type;

	list_type = validate_element_type (entry->list_type, error);
	if (list_type == GCONF_VALUE_INVALID)
	  break;

	value = gconf_defaults_hack_value_new_list_from_string (list_type,
								entry->default_value,
								error);
      }
    case GCONF_VALUE_PAIR:
      {
	GConfValueType car_type;
	GConfValueType cdr_type;

	car_type = validate_element_type (entry->car_type, error);
	if (car_type == GCONF_VALUE_INVALID)
	  break;

	cdr_type = validate_element_type (entry->cdr_type, error);
	if (cdr_type == GCONF_VALUE_INVALID)
	  break;

	value = gconf_defaults_hack_value_new_pair_from_string (car_type, cdr_type,
								entry->default_value,
								error);
      }
    }

 out:
  if (entry)
    gconf_defaults_hack_entry_free (entry);

  return value;
}

GConfValue *
gconf_engine_get_fuller (GConfEngine *conf,
                         const gchar *key,
                         const gchar *locale,
                         gboolean     use_schema_default,
                         gboolean    *is_default_p,
                         gboolean    *is_writable_p,
                         gchar      **schema_name_p,
                         GError     **err)
{
  static GConfValue * (*next) (GConfEngine *conf,
                               const gchar *key,
                               const gchar *locale,
                               gboolean     use_schema_default,
                               gboolean    *is_default_p,
                               gboolean    *is_writable_p,
                               gchar      **schema_name_p,
                               GError     **err);
  GConfValue *result;

  if (next == NULL)
    next = dlsym (RTLD_NEXT, "gconf_engine_get_fuller");

  result = (*next) (conf, key, locale, use_schema_default,
                    is_default_p, is_writable_p, schema_name_p, err);

  if (result != NULL ||
      !use_schema_default ||
      conf != gconf_engine_get_default ())
    return result;

  g_clear_error (err);

  result = get_default_from_database (key, err);
  if (result)
    {
      if (is_default_p)
        *is_default_p = TRUE;
      if (is_writable_p)
        *is_writable_p = TRUE; /* A guess */
      if (schema_name_p)
        *schema_name_p = g_strconcat ("/schemas/", key, NULL); /* probably right... */
    }

  return result;
}

GConfValue*
gconf_engine_get_default_from_schema (GConfEngine* conf,
                                      const gchar* key,
                                      GError**     err)
{
  static GConfValue* (*next) (GConfEngine* conf,
                              const gchar* key,
                              GError**     err);
  GConfValue *result;

  if (next == NULL)
    next = dlsym (RTLD_NEXT, "gconf_engine_get_default_from_schema");

  result = (*next) (conf, key, err);

  if (result != NULL ||
      conf != gconf_engine_get_default ())
    return result;

  g_clear_error (err);

  return get_default_from_database (key, err);
}