/* GStreamer

 * Copyright (C) 2003 Erik Walthinsen <omega@cse.ogi.edu>

 *               2003 Joshua N Pritikin <jpritikin@pobox.com>

 *

 * 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 <gst/gst.h>

#include <unistd.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <errno.h>

#include <fcntl.h>

#include <string.h>

#define GST_TYPE_FILE_INDEX             \

  (gst_file_index_get_type ())

#define GST_FILE_INDEX(obj)             \

  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_FILE_INDEX, GstFileIndex))

#define GST_FILE_INDEX_CLASS(klass)     \

  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_FILE_INDEX, GstFileIndexClass))

#define GST_IS_FILE_INDEX(obj)          \

  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_FILE_INDEX))

#define GST_IS_FILE_INDEX_CLASS(klass)    \

  (GST_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_FILE_INDEX))

/*

 * Object model:

 *

 * We build an index to each entry for each id.

 *

 *

 *  fileindex

 *    -----------------------------...

 *    !                  !

 *   id1                 id2

 *    !

 *   GArray

 *

 * The fileindex creates a FileIndexId object for each writer id, a

 * Hashtable is kept to map the id to the FileIndexId

 *

 * The FileIndexId also keeps all the values in a sorted GArray.

 *

 * Finding a value for an id/format requires locating the correct GArray,

 * then do a binary search to get the required value.

 *

 * Unlike gstmemindex:  All formats are assumed to sort to the

 * same order.  All formats are assumed to be available from

 * any entry.

 */

/*

 * Each array element is (32bits flags, nformats * 64bits)

 */

typedef struct

{

  gint id;

  gchar *id_desc;

  gint nformats;

  GstFormat *format;

  GArray *array;

}

GstFileIndexId;

typedef struct _GstFileIndex GstFileIndex;

typedef struct _GstFileIndexClass GstFileIndexClass;

#define ARRAY_ROW_SIZE(_ii) \

  (sizeof (gint32) + (_ii)->nformats * sizeof (gint64))

#define ARRAY_TOTAL_SIZE(_ii) \

  (_ii->array->len * ARRAY_ROW_SIZE(_ii))

/* don't forget to convert to/from BE byte-order */

#define ARRAY_ROW_FLAGS(_row) \

  (*((gint32*) (_row)))

#define ARRAY_ROW_VALUE(_row,_vx) \

  (*(gint64*) (((gchar*)(_row)) + sizeof (gint32) + (_vx) * sizeof (gint64)))

GST_DEBUG_CATEGORY_STATIC (DC);

#define GST_CAT_DEFAULT DC

struct _GstFileIndex

{

  GstIndex parent;

  gchar *location;

  gboolean is_loaded;

  GSList *unresolved;

  gint next_id;

  GHashTable *id_index;

  GstIndexEntry *ret_entry;     /* hack to avoid leaking memory */

};

struct _GstFileIndexClass

{

  GstIndexClass parent_class;

};

enum

{

  ARG_0,

  ARG_LOCATION,

};

static void gst_file_index_class_init (GstFileIndexClass * klass);

static void gst_file_index_init (GstFileIndex * index);

static void gst_file_index_dispose (GObject * object);

static void

gst_file_index_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void

gst_file_index_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static gboolean

gst_file_index_get_writer_id (GstIndex * _index, gint * id,

    gchar * writer_string);

static void gst_file_index_commit (GstIndex * index, gint writer_id);

static void gst_file_index_add_entry (GstIndex * index, GstIndexEntry * entry);

static GstIndexEntry *gst_file_index_get_assoc_entry (GstIndex * index, gint id,

    GstIndexLookupMethod method,

    GstAssocFlags flags,

    GstFormat format, gint64 value, GCompareDataFunc func, gpointer user_data);

#define CLASS(file_index)  GST_FILE_INDEX_CLASS (G_OBJECT_GET_CLASS (file_index))

static GstIndex *parent_class = NULL;

static GType

gst_file_index_get_type (void)

{

  static GType file_index_type = 0;

  if (!file_index_type) {

    static const GTypeInfo file_index_info = {

      sizeof (GstFileIndexClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_file_index_class_init,

      NULL,

      NULL,

      sizeof (GstFileIndex),

      1,

      (GInstanceInitFunc) gst_file_index_init,

      NULL

    };

    file_index_type =

        g_type_register_static (GST_TYPE_INDEX, "GstFileIndex",

        &file_index_info, 0);

  }

  return file_index_type;

}

static void

gst_file_index_class_init (GstFileIndexClass * klass)

{

  GObjectClass *gobject_class;

  GstIndexClass *gstindex_class;

  gobject_class = (GObjectClass *) klass;

  gstindex_class = (GstIndexClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->dispose = gst_file_index_dispose;

  gobject_class->set_property = gst_file_index_set_property;

  gobject_class->get_property = gst_file_index_get_property;

  gstindex_class->add_entry = gst_file_index_add_entry;

  gstindex_class->get_assoc_entry = gst_file_index_get_assoc_entry;

  gstindex_class->commit = gst_file_index_commit;

  gstindex_class->get_writer_id = gst_file_index_get_writer_id;

  g_object_class_install_property (gobject_class, ARG_LOCATION,

      g_param_spec_string ("location", "File Location",

}

static void

gst_file_index_init (GstFileIndex * index)

{

  GST_DEBUG ("created new file index");

  index->id_index = g_hash_table_new (g_int_hash, g_int_equal);

}

static void

_file_index_id_free (GstFileIndexId * index_id, gboolean is_mmapped)

{

  if (index_id->id_desc)

    g_free (index_id->id_desc);

  if (index_id->format)

    g_free (index_id->format);

  if (index_id->array) {

    if (is_mmapped)

      munmap (index_id->array->data, ARRAY_TOTAL_SIZE (index_id));

    g_array_free (index_id->array, !is_mmapped);

  }

}

static gboolean

_id_index_free_helper (gpointer _key, GstFileIndexId * index_id,

    GstFileIndex * index)

{

  _file_index_id_free (index_id, index->is_loaded);

  return TRUE;

}

static void

gst_file_index_dispose (GObject * object)

{

  GstFileIndex *index = GST_FILE_INDEX (object);

  if (index->location) {

    g_free (index->location);

    index->location = NULL;

  }

  {

    GSList *elem;

    for (elem = index->unresolved; elem; elem = g_slist_next (elem))

      _file_index_id_free (elem->data, index->is_loaded);

    g_slist_free (index->unresolved);

    index->unresolved = NULL;

  }

  g_hash_table_foreach_steal (index->id_index,

      (GHRFunc) _id_index_free_helper, index);

  g_hash_table_destroy (index->id_index);

  index->id_index = NULL;

  gst_index_entry_free (index->ret_entry);      /* hack */

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

struct fi_find_writer_context

{

  const gchar *writer_string;

  GstFileIndexId *ii;

};

static void

_fi_find_writer (gpointer key, gpointer val, gpointer data)

{

  struct fi_find_writer_context *cx = data;

  GstFileIndexId *ii = val;

  if (strcmp (ii->id_desc, cx->writer_string) == 0)

    cx->ii = ii;

}

static gboolean

gst_file_index_get_writer_id (GstIndex * _index,

    gint * id, gchar * writer_string)

{

  GstFileIndex *index = GST_FILE_INDEX (_index);

  GSList *pending = index->unresolved;

  gboolean match = FALSE;

  GSList *elem;

  if (!index->is_loaded)

    return FALSE;

  g_return_val_if_fail (id, FALSE);

  g_return_val_if_fail (writer_string, FALSE);

  index->unresolved = NULL;

  for (elem = pending; elem; elem = g_slist_next (elem)) {

    GstFileIndexId *ii = elem->data;

    if (strcmp (ii->id_desc, writer_string) != 0) {

      index->unresolved = g_slist_prepend (index->unresolved, ii);

      continue;

    }

    if (match) {

      GST_WARNING_OBJECT (index, "Duplicate matches for writer '%s'",

          writer_string);

      continue;

    }

    ii->id = *id = ++index->next_id;

    g_hash_table_insert (index->id_index, &ii->id, ii);

    match = TRUE;

  }

  g_slist_free (pending);

  if (!match) {

    struct fi_find_writer_context cx;

    cx.writer_string = writer_string;

    cx.ii = NULL;

    g_hash_table_foreach (index->id_index, _fi_find_writer, &cx);

    if (cx.ii) {

      match = TRUE;

      GST_DEBUG_OBJECT (index, "Resolved writer '%s' again", writer_string);

    } else

      GST_WARNING_OBJECT (index, "Can't resolve writer '%s'", writer_string);

  }

  return match;

}

static void

_fc_alloc_array (GstFileIndexId * id_index)

{

  g_assert (!id_index->array);

  id_index->array =

      g_array_sized_new (FALSE, FALSE, ARRAY_ROW_SIZE (id_index), 0);

}

static void

gst_file_index_load (GstFileIndex * index)

{

  xmlDocPtr doc;

  xmlNodePtr root, part;

  xmlChar *val;

  g_assert (index->location);

  g_return_if_fail (!index->is_loaded);

  {

    gchar *path = g_strdup_printf ("%s/gstindex.xml", index->location);

    GError *err = NULL;

    gchar *buf;

    gsize len;

    g_file_get_contents (path, &buf, &len, &err);

    g_free (path);

    if (err) {

      GST_ERROR_OBJECT (index, "%s", err->message);

      return;

    }

    doc = xmlParseMemory (buf, len);

    g_free (buf);

  }

  //xmlDocFormatDump (stderr, doc, TRUE);

        #ifdef __SYMBIAN32__

   root = doc->children;

  #else

   root = doc->xmlRootNode;

  #endif

  if (strcmp ((char *) root->name, "gstfileindex") != 0) {

    GST_ERROR_OBJECT (index, "root node isn't a gstfileindex");

    return;

  }

  val = xmlGetProp (root, (xmlChar *) "version");

  if (!val || atoi ((char *) val) != 1) {

    GST_ERROR_OBJECT (index, "version != 1");

    return;

  }

  free (val);

  for (part = root->children; part; part = part->next) {

    if (strcmp ((char *) part->name, "writers") == 0) {

      xmlNodePtr writer;

      for (writer = part->children; writer; writer = writer->next) {

        xmlChar *datafile = xmlGetProp (writer, (xmlChar *) "datafile");

        gchar *path = g_strdup_printf ("%s/%s", index->location, datafile);

        int fd;

        GstFileIndexId *id_index;

        xmlNodePtr wpart;

        xmlChar *entries_str;

        gpointer array_data;

        free (datafile);

        fd = open (path, O_RDONLY);

        g_free (path);

        if (fd < 0) {

          GST_ERROR_OBJECT (index,

              "Can't open '%s': %s", path, g_strerror (errno));

          continue;

        }

        id_index->id_desc = (char *) xmlGetProp (writer, (xmlChar *) "id");

        for (wpart = writer->children; wpart; wpart = wpart->next) {

          if (strcmp ((char *) wpart->name, "formats") == 0) {

            xmlChar *count_str = xmlGetProp (wpart, (xmlChar *) "count");

            gint fx = 0;

            xmlNodePtr format;

            id_index->nformats = atoi ((char *) count_str);

            free (count_str);

            id_index->format = g_new (GstFormat, id_index->nformats);

            for (format = wpart->children; format; format = format->next) {

              xmlChar *nick = xmlGetProp (format, (xmlChar *) "nick");

              GstFormat fmt = gst_format_get_by_nick ((gchar *) nick);

              if (fmt == GST_FORMAT_UNDEFINED)

                GST_ERROR_OBJECT (index, "format '%s' undefined", nick);

              g_assert (fx < id_index->nformats);

              id_index->format[fx++] = fmt;

              free (nick);

            }

          } else

            GST_INFO_OBJECT (index, "unknown wpart '%s'", wpart->name);

        }

        g_assert (id_index->nformats > 0);

        _fc_alloc_array (id_index);

        g_assert (id_index->array->data == NULL);       /* little bit risky */

        entries_str = xmlGetProp (writer, (xmlChar *) "entries");

        id_index->array->len = atoi ((char *) entries_str);

        free (entries_str);

        array_data =

            mmap (NULL, ARRAY_TOTAL_SIZE (id_index), PROT_READ, MAP_SHARED, fd,

            0);

        close (fd);

        if (array_data == MAP_FAILED) {

          GST_ERROR_OBJECT (index,

              "mmap %s failed: %s", path, g_strerror (errno));

          continue;

        }

        id_index->array->data = array_data;

        index->unresolved = g_slist_prepend (index->unresolved, id_index);

      }

    } else

      GST_INFO_OBJECT (index, "unknown part '%s'", part->name);

  }

  xmlFreeDoc (doc);

  GST_OBJECT_FLAG_UNSET (index, GST_INDEX_WRITABLE);

  index->is_loaded = TRUE;

  GST_LOG_OBJECT (index, "index %s loaded OK", index->location);

}

static void

gst_file_index_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec)

{

  GstFileIndex *index = GST_FILE_INDEX (object);

  switch (prop_id) {

    case ARG_LOCATION:

      if (index->location)

        g_free (index->location);

      index->location = g_value_dup_string (value);

      if (index->location && !g_hash_table_size (index->id_index))

        gst_file_index_load (index);

      break;

  }

}

static void

gst_file_index_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec)

{

  GstFileIndex *index = GST_FILE_INDEX (object);

  switch (prop_id) {

    case ARG_LOCATION:

      g_value_set_string (value, index->location);

      break;

  }

}

static void

_file_index_id_save_xml (gpointer _key, GstFileIndexId * ii, xmlNodePtr writers)

{

  const gint bufsize = 16;

  gchar buf[16];

  xmlNodePtr writer;

  xmlNodePtr formats;

  gint xx;

  if (!ii->array) {

    GST_INFO ("Index for %s is empty", ii->id_desc);

    return;

  }

  writer = xmlNewChild (writers, NULL, (xmlChar *) "writer", NULL);

  xmlSetProp (writer, (xmlChar *) "id", (xmlChar *) ii->id_desc);

  g_snprintf (buf, bufsize, "%d", ii->array->len);

  xmlSetProp (writer, (xmlChar *) "entries", (xmlChar *) buf);

  g_snprintf (buf, bufsize, "%d", ii->id);      /* any unique number is OK */

  xmlSetProp (writer, (xmlChar *) "datafile", (xmlChar *) buf);

  formats = xmlNewChild (writer, NULL, (xmlChar *) "formats", NULL);

  g_snprintf (buf, bufsize, "%d", ii->nformats);

  xmlSetProp (formats, (xmlChar *) "count", (xmlChar *) buf);

  for (xx = 0; xx < ii->nformats; xx++) {

    xmlNodePtr format = xmlNewChild (formats, NULL, (xmlChar *) "format", NULL);

    const GstFormatDefinition *def = gst_format_get_details (ii->format[xx]);