/* updateiconcache.c

 * Copyright (C) 2004  Anders Carlsson <andersca@gnome.org>

 *

 * 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <locale.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#ifdef _MSC_VER

#include <io.h>

#include <sys/utime.h>

#else

#include <utime.h>

#endif

#include <glib.h>

#include <glib/gstdio.h>

#undef GDK_PIXBUF_DISABLE_DEPRECATED

#include <gdk-pixbuf/gdk-pixdata.h>

#include <glib/gi18n.h>

#include "gtkiconcachevalidator.h"

static gboolean force_update = FALSE;

static gboolean ignore_theme_index = FALSE;

static gboolean quiet = FALSE;

static gboolean index_only = TRUE;

static gboolean validate = FALSE;

static gchar *var_name = "-";

/* Quite ugly - if we just add the c file to the

 * list of sources in Makefile.am, libtool complains.

 */

#include "gtkiconcachevalidator.c"

#define CACHE_NAME "icon-theme.cache"

#define HAS_SUFFIX_XPM (1 << 0)

#define HAS_SUFFIX_SVG (1 << 1)

#define HAS_SUFFIX_PNG (1 << 2)

#define HAS_ICON_FILE  (1 << 3)

#define MAJOR_VERSION 1

#define MINOR_VERSION 0

#define HASH_OFFSET 12

#define ALIGN_VALUE(this, boundary) \

  (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))

#ifdef HAVE_FTW_H

#include <ftw.h>

static struct stat cache_stat;

static gboolean cache_up_to_date;

static int check_dir_mtime (const char        *dir, 

                            const struct stat *sb,

                            int                tf)

{

  if (tf != FTW_NS && sb->st_mtime > cache_stat.st_mtime)

    {

      cache_up_to_date = FALSE;

      /* stop tree walk */

      return 1;

    }

  return 0;

}

 gboolean

 is_cache_up_to_date (const gchar *path)

 {

  gchar *cache_path;

  gint retval;

  cache_path = g_build_filename (path, CACHE_NAME, NULL);

  retval = g_stat (cache_path, &cache_stat);

  g_free (cache_path);

  if (retval < 0)

    {

      /* Cache file not found */

      return FALSE;

    }

  cache_up_to_date = TRUE;

  ftw (path, check_dir_mtime, 20);

  return cache_up_to_date;

}

#else  /* !HAVE_FTW_H */

gboolean

is_cache_up_to_date (const gchar *path)

{

  struct stat path_stat, cache_stat;

  gchar *cache_path;

  int retval; 

  retval = g_stat (path, &path_stat);

  if (retval < 0) 

    {

      /* We can't stat the path,

       * assume we have a updated cache */

      return TRUE;

    }

  cache_path = g_build_filename (path, CACHE_NAME, NULL);

  retval = g_stat (cache_path, &cache_stat);

  g_free (cache_path);

  if (retval < 0)

    {

      /* Cache file not found */

      return FALSE;

    }

  /* Check mtime */

  return cache_stat.st_mtime >= path_stat.st_mtime;

}

#endif  /* !HAVE_FTW_H */

static gboolean

has_theme_index (const gchar *path)

{

  gboolean result;

  gchar *index_path;

  index_path = g_build_filename (path, "index.theme", NULL);

  result = g_file_test (index_path, G_FILE_TEST_IS_REGULAR);

  g_free (index_path);

  return result;

}

typedef struct 

{

  GdkPixdata pixdata;

  gboolean has_pixdata;

  guint32 offset;

  guint size;

} ImageData;

typedef struct 

{

  int has_embedded_rect;

  int x0, y0, x1, y1;

  int n_attach_points;

  int *attach_points;

  int n_display_names;

  char **display_names;

  guint32 offset;

  gint size;

} IconData;

static GHashTable *image_data_hash = NULL;

static GHashTable *icon_data_hash = NULL;

typedef struct

{

  int flags;

  int dir_index;

  ImageData *image_data;

  guint pixel_data_size;

  IconData *icon_data;

  guint icon_data_size;

} Image;

static gboolean

foreach_remove_func (gpointer key, gpointer value, gpointer user_data)

{

  Image *image = (Image *)value;

  GHashTable *files = user_data;

  GList *list;

  gboolean free_key = FALSE;  

  if (image->flags == HAS_ICON_FILE)

    {

      /* just a .icon file, throw away */

      g_free (key);

      g_free (image);

      return TRUE;

    }

  list = g_hash_table_lookup (files, key);

  if (list)

    free_key = TRUE;

  list = g_list_prepend (list, value);

  g_hash_table_insert (files, key, list);

  if (free_key)

    g_free (key);

  return TRUE;

}

static IconData *

load_icon_data (const char *path)

{

  GKeyFile *icon_file;

  char **split;

  gsize length;

  char *str;

  char *split_point;

  int i;

  gint *ivalues;

  GError *error = NULL;

  gchar **keys;

  gsize n_keys;

  IconData *data;

  icon_file = g_key_file_new ();

  g_key_file_set_list_separator (icon_file, ',');

  g_key_file_load_from_file (icon_file, path, G_KEY_FILE_KEEP_TRANSLATIONS, &error);

  if (error)

    {

      g_error_free (error);

      g_key_file_free (icon_file);

      return NULL;

    }

  data = g_new0 (IconData, 1);

  ivalues = g_key_file_get_integer_list (icon_file, 

					 "Icon Data", "EmbeddedTextRectangle",

					 &length, NULL);

  if (ivalues)

    {

      if (length == 4)

	{

	  data->has_embedded_rect = TRUE;

	  data->x0 = ivalues[0];

	  data->y0 = ivalues[1];

	  data->x1 = ivalues[2];

	  data->y1 = ivalues[3];

	}

      g_free (ivalues);

    }

  str = g_key_file_get_string (icon_file, "Icon Data", "AttachPoints", NULL);

  if (str)

    {

      split = g_strsplit (str, "|", -1);

      data->n_attach_points = g_strv_length (split);

      data->attach_points = g_new (int, 2 * data->n_attach_points);

      i = 0;

      while (split[i] != NULL && i < data->n_attach_points)

	{

	  split_point = strchr (split[i], ',');

	  if (split_point)

	    {

	      *split_point = 0;

	      split_point++;

	      data->attach_points[2 * i] = atoi (split[i]);

	      data->attach_points[2 * i + 1] = atoi (split_point);

	    }

	  i++;

	}

      g_strfreev (split);

      g_free (str);

    }

  keys = g_key_file_get_keys (icon_file, "Icon Data", &n_keys, &error);

  data->display_names = g_new0 (gchar *, 2 * n_keys + 1); 

  data->n_display_names = 0;

  for (i = 0; i < n_keys; i++)

    {

      gchar *lang, *name;

      if (g_str_has_prefix (keys[i], "DisplayName"))

	{

	  gchar *open, *close = NULL;

	  open = strchr (keys[i], '[');

	  if (open)

	    close = strchr (open, ']');

	  if (open && close)

	    {

	      lang = g_strndup (open + 1, close - open - 1);

	      name = g_key_file_get_locale_string (icon_file, 

						   "Icon Data", "DisplayName",

						   lang, NULL);

	    }

	  else

	    {

	      lang = g_strdup ("C");

	      name = g_key_file_get_string (icon_file, 

					    "Icon Data", "DisplayName",

					    NULL);

	    }

	  data->display_names[2 * data->n_display_names] = lang;

	  data->display_names[2 * data->n_display_names + 1] = name;

	  data->n_display_names++;

	}

    }

  g_strfreev (keys);

  g_key_file_free (icon_file);

  /* -1 means not computed yet, the real value depends

   * on string pool state, and will be computed 

   * later 

   */

  data->size = -1;

  return data;

}

/*

 * This function was copied from gtkfilesystemunix.c, it should

 * probably go to GLib

 */

static void

canonicalize_filename (gchar *filename)

{

  gchar *p, *q;

  gboolean last_was_slash = FALSE;

  p = filename;

  q = filename;

  while (*p)

    {

      if (*p == G_DIR_SEPARATOR)

	{

	  if (!last_was_slash)

	    *q++ = G_DIR_SEPARATOR;

	  last_was_slash = TRUE;

	}

      else

	{

	  if (last_was_slash && *p == '.')

	    {

	      if (*(p + 1) == G_DIR_SEPARATOR ||

		  *(p + 1) == '\0')

		{

		  if (*(p + 1) == '\0')

		    break;

		  p += 1;

		}

	      else if (*(p + 1) == '.' &&

		       (*(p + 2) == G_DIR_SEPARATOR ||

			*(p + 2) == '\0'))

		{

		  if (q > filename + 1)

		    {

		      q--;

		      while (q > filename + 1 &&

			     *(q - 1) != G_DIR_SEPARATOR)

			q--;

		    }

		  if (*(p + 2) == '\0')

		    break;

		  p += 2;

		}

	      else

		{

		  *q++ = *p;

		  last_was_slash = FALSE;

		}

	    }

	  else

	    {

	      *q++ = *p;

	      last_was_slash = FALSE;

	    }

	}

      p++;

    }

  if (q > filename + 1 && *(q - 1) == G_DIR_SEPARATOR)

    q--;

  *q = '\0';

}

static gchar *

follow_links (const gchar *path)

{

  gchar *target;

  gchar *d, *s;

  gchar *path2 = NULL;

  path2 = g_strdup (path);

  while (g_file_test (path2, G_FILE_TEST_IS_SYMLINK))

    {

      target = g_file_read_link (path2, NULL);

      if (target)

	{

	  if (g_path_is_absolute (target))

	    path2 = target;

	  else

	    {

	      d = g_path_get_dirname (path2);

	      s = g_build_filename (d, target, NULL);

	      g_free (d);

	      g_free (target);

	      g_free (path2);

	      path2 = s;

	    }

	}

      else

	break;

    }

  if (strcmp (path, path2) == 0)

    {

      g_free (path2);

      path2 = NULL;

    }

  return path2;

}

static void

maybe_cache_image_data (Image       *image, 

			const gchar *path)

{

  if (!index_only && !image->image_data && 

      (g_str_has_suffix (path, ".png") || g_str_has_suffix (path, ".xpm")))

    {

      GdkPixbuf *pixbuf;

      ImageData *idata;

      gchar *path2;

      idata = g_hash_table_lookup (image_data_hash, path);

      path2 = follow_links (path);

      if (path2)

	{

	  ImageData *idata2;

	  canonicalize_filename (path2);

	  idata2 = g_hash_table_lookup (image_data_hash, path2);

	  if (idata && idata2 && idata != idata2)

	    g_error (_("different idatas found for symlinked '%s' and '%s'\n"),

		     path, path2);

	  if (idata && !idata2)

	    g_hash_table_insert (image_data_hash, g_strdup (path2), idata);

	  if (!idata && idata2)

	    {

	      g_hash_table_insert (image_data_hash, g_strdup (path), idata2);

	      idata = idata2;

	    }

	}

      if (!idata)

	{

	  idata = g_new0 (ImageData, 1);

	  g_hash_table_insert (image_data_hash, g_strdup (path), idata);

	  if (path2)

	    g_hash_table_insert (image_data_hash, g_strdup (path2), idata);  

	}

      if (!idata->has_pixdata)

	{

	  pixbuf = gdk_pixbuf_new_from_file (path, NULL);

	  if (pixbuf) 

	    {

	      gdk_pixdata_from_pixbuf (&idata->pixdata, pixbuf, FALSE);

	      idata->size = idata->pixdata.length + 8;

	      idata->has_pixdata = TRUE;

	    }

	}

      image->image_data = idata;

      g_free (path2);

    }

}

static void

maybe_cache_icon_data (Image       *image,

                       const gchar *path)

{

  if (g_str_has_suffix (path, ".icon"))

    {

      IconData *idata = NULL;

      gchar *path2 = NULL;

      idata = g_hash_table_lookup (icon_data_hash, path);

      path2 = follow_links (path);

      if (path2)

	{

	  IconData *idata2;

	  canonicalize_filename (path2);

	  idata2 = g_hash_table_lookup (icon_data_hash, path2);

	  if (idata && idata2 && idata != idata2)

	    g_error (_("different idatas found for symlinked '%s' and '%s'\n"),

		     path, path2);

	  if (idata && !idata2)

	    g_hash_table_insert (icon_data_hash, g_strdup (path2), idata);

	  if (!idata && idata2)

	    {

	      g_hash_table_insert (icon_data_hash, g_strdup (path), idata2);

	      idata = idata2;

	    }

	}

      if (!idata)

	{

	  idata = load_icon_data (path);

	  g_hash_table_insert (icon_data_hash, g_strdup (path), idata);

	  if (path2)

	    g_hash_table_insert (icon_data_hash, g_strdup (path2), idata);  

        }

      image->icon_data = idata;

      g_free (path2);

    }

}

/**

 * Finds all dir separators and replaces them with '/'.

 * This makes sure that only /-separated paths are written in cache files,

 * maintaining compatibility with theme index files that use slashes as

 * directory separators on all platforms.

 */

static void

replace_backslashes_with_slashes (gchar *path)

{

  size_t i;

  if (path == NULL)

    return;

  for (i = 0; path[i]; i++)

    if (G_IS_DIR_SEPARATOR (path[i]))

      path[i] = '/';

}

static GList *

scan_directory (const gchar *base_path, 

		const gchar *subdir, 

		GHashTable  *files, 

		GList       *directories,

		gint         depth)

{

  GHashTable *dir_hash;

  GDir *dir;

  const gchar *name;

  gchar *dir_path;

  gboolean dir_added = FALSE;

  guint dir_index = 0xffff;

  dir_path = g_build_path ("/", base_path, subdir, NULL);

  /* FIXME: Use the gerror */

  dir = g_dir_open (dir_path, 0, NULL);

  if (!dir)

    return directories;

  dir_hash = g_hash_table_new (g_str_hash, g_str_equal);

  while ((name = g_dir_read_name (dir)))

    {

      gchar *path;

      gboolean retval;

      int flags = 0;

      Image *image;

      gchar *basename, *dot;

      path = g_build_filename (dir_path, name, NULL);

      retval = g_file_test (path, G_FILE_TEST_IS_DIR);

      if (retval)

	{

	  gchar *subsubdir;

	  if (subdir)

	    subsubdir = g_build_path ("/", subdir, name, NULL);

	  else

	    subsubdir = g_strdup (name);

	  directories = scan_directory (base_path, subsubdir, files, 

					directories, depth + 1);

	  g_free (subsubdir);

	  continue;

	}

      /* ignore images in the toplevel directory */

      if (subdir == NULL)

        continue;

      retval = g_file_test (path, G_FILE_TEST_IS_REGULAR);

      if (retval)

	{

	  if (g_str_has_suffix (name, ".png"))

	    flags |= HAS_SUFFIX_PNG;

	  else if (g_str_has_suffix (name, ".svg"))

	    flags |= HAS_SUFFIX_SVG;

	  else if (g_str_has_suffix (name, ".xpm"))

	    flags |= HAS_SUFFIX_XPM;

	  else if (g_str_has_suffix (name, ".icon"))

	    flags |= HAS_ICON_FILE;

	  if (flags == 0)

	    continue;

	  basename = g_strdup (name);

	  dot = strrchr (basename, '.');

	  *dot = '\0';

	  image = g_hash_table_lookup (dir_hash, basename);

	  if (!image)

	    {

	      if (!dir_added) 

		{

		  dir_added = TRUE;

		  if (subdir)

		    {

		      dir_index = g_list_length (directories);

		      directories = g_list_append (directories, g_strdup (subdir));

		    }

		  else

		    dir_index = 0xffff;

		}

	      image = g_new0 (Image, 1);

	      image->dir_index = dir_index;

	      g_hash_table_insert (dir_hash, g_strdup (basename), image);

	    }

	  image->flags |= flags;

	  maybe_cache_image_data (image, path);

          maybe_cache_icon_data (image, path);

	  g_free (basename);

	}

      g_free (path);

    }

  g_dir_close (dir);

  /* Move dir into the big file hash */

  g_hash_table_foreach_remove (dir_hash, foreach_remove_func, files);

  g_hash_table_destroy (dir_hash);

  return directories;

}

typedef struct _HashNode HashNode;

struct _HashNode

{

  HashNode *next;

  gchar *name;

  GList *image_list;

  gint offset;

};

static guint

icon_name_hash (gconstpointer key)

{

  const signed char *p = key;

  guint32 h = *p;

  if (h)

    for (p += 1; *p != '\0'; p++)

      h = (h << 5) - h + *p;

  return h;

}

typedef struct {

  gint size;

  HashNode **nodes;

} HashContext;

static gboolean

convert_to_hash (gpointer key, gpointer value, gpointer user_data)

{

  HashContext *context = user_data;

  guint hash;

  HashNode *node;

  hash = icon_name_hash (key) % context->size;

  node = g_new0 (HashNode, 1);

  node->next = NULL;

  node->name = key;

  node->image_list = value;

  if (context->nodes[hash] != NULL)

    node->next = context->nodes[hash];

  context->nodes[hash] = node;

  return TRUE;

}

static GHashTable *string_pool = NULL;

static int

find_string (const gchar *n)

{

  return GPOINTER_TO_INT (g_hash_table_lookup (string_pool, n));

}

static void

add_string (const gchar *n, int offset)

{

  g_hash_table_insert (string_pool, (gpointer) n, GINT_TO_POINTER (offset));

}

static gboolean

write_string (FILE *cache, const gchar *n)

{

  gchar *s;

  int i, l;

  l = ALIGN_VALUE (strlen (n) + 1, 4);

  s = g_malloc0 (l);

  strcpy (s, n);

  i = fwrite (s, l, 1, cache);

  g_free (s);

  return i == 1;

}

static gboolean

write_card16 (FILE *cache, guint16 n)

{

  int i;

  n = GUINT16_TO_BE (n);

  i = fwrite ((char *)&n, 2, 1, cache);

  return i == 1;

}

static gboolean

write_card32 (FILE *cache, guint32 n)

{

  int i;

  n = GUINT32_TO_BE (n);

  i = fwrite ((char *)&n, 4, 1, cache);

  return i == 1;

}

static gboolean

write_image_data (FILE *cache, ImageData *image_data, int offset)

{

  guint8 *s;

  guint len;

  gint i;

  GdkPixdata *pixdata = &image_data->pixdata;

  /* Type 0 is GdkPixdata */

  if (!write_card32 (cache, 0))

    return FALSE;

  s = gdk_pixdata_serialize (pixdata, &len;;

  if (!write_card32 (cache, len))

    {

      g_free (s);

      return FALSE;

    }

  i = fwrite (s, len, 1, cache);

  g_free (s);

  return i == 1;

}

static gboolean

write_icon_data (FILE *cache, IconData *icon_data, int offset)

{

  int ofs = offset + 12;

  int j;

  int tmp, tmp2;

  if (icon_data->has_embedded_rect)

    {

      if (!write_card32 (cache, ofs))

        return FALSE;

       ofs += 8;

    }	      

  else

    {

      if (!write_card32 (cache, 0))

        return FALSE;

    }

  if (icon_data->n_attach_points > 0)

    {

      if (!write_card32 (cache, ofs))

        return FALSE;

      ofs += 4 + 4 * icon_data->n_attach_points;

    }

  else

    {

      if (!write_card32 (cache, 0))

        return FALSE;

    }

  if (icon_data->n_display_names > 0)

    {