/* Shared index for cserve2.
 * EXPERIMENTAL WORK.
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "evas_cserve2.h"
#include "evas_cs2_utils.h"

#include <stdint.h>

typedef struct _Data_Shm Data_Shm;
typedef struct _Block Block;
typedef struct _Shared_Index Shared_Index;

static int _instances = 0;

// Static memory pool used for storing strings
static Shared_Mempool *_string_mempool = NULL;

// Map const char* --> buffer id (valid in _string_mempool)
static Eina_Hash *_string_entries = NULL;

struct _Data_Shm
{
   Shm_Handle *shm;
   char *data;
};

struct _Shared_Array
{
   Data_Shm *ds;
   Shared_Array_Header *header;
};

struct _Shared_Index
{
   // Random buffer index
   Shared_Array *sa;
   int32_t lastid;
};

struct _Shared_Mempool
{
   Data_Shm *ds;
   Shared_Index *index;
   int empty_size;
   Block *empty_blocks;
};

// Used for empty blocks. RB tree ordered by length.
struct _Block
{
   EINA_RBTREE;
   int32_t length;
   int32_t offset;
   int32_t shmid;
};


// Data blocks will be aligned to blocks of DATA_BLOCKSIZE bytes to reduce
// fragmentation (after del). 16 is convenient for debugging with hd :)
#define DATA_BLOCKSIZE 8

// Recommended minimum size for arrays and mempools
#define ARRAY_MINSIZE (32 * 1024)

static inline int
_data_blocksize_roundup(int len)
{
   return ((len + DATA_BLOCKSIZE - 1) / DATA_BLOCKSIZE) * DATA_BLOCKSIZE;
}

static Eina_Rbtree_Direction
_block_rbtree_cmp(const Eina_Rbtree *l, const Eina_Rbtree *r,
                  void *data EINA_UNUSED)
{
   const Block *left  = (Block *) l;
   const Block *right = (Block *) r;

   if (!left)
     return EINA_RBTREE_RIGHT;

   if (!right)
     return EINA_RBTREE_LEFT;

   if (left->length <= right->length)
     return EINA_RBTREE_LEFT;
   else
     return EINA_RBTREE_RIGHT;
}

static inline int
_block_rbtree_empty_spot_find(const Block *node, const void *key,
                              int key_length EINA_UNUSED,
                              void *data EINA_UNUSED)
{
   int32_t length = (int32_t) (intptr_t) key;

   // Found best spot
   if (node->length == length)
     return 0;

   // We're good, can we find better?
   if (node->length > length)
     {
        Block *lson = (Block *) node->__rbtree.son[0];

        if (lson && lson->length >= length)
          return -1;

        // This is the best we can do...
        return 0;
     }

   // Keep calm and carry on
   return 1;
}

static inline int
_block_rbtree_block_find(const Block *node, const void *key,
                         int key_length EINA_UNUSED,
                         void *data EINA_UNUSED)
{
   const Index_Entry *ie = key;

   // Found best spot
   if ((node->length == ie->length)
       && (node->offset == ie->offset)
       && (node->shmid == ie->shmid))
     return 0;

   // We're good, can we find better?
   if (node->length > ie->length)
     {
        Block *lson = (Block *) node->__rbtree.son[0];

        if (lson && lson->length >= ie->length)
          return -1;

        // This is the best we can do...
        return 0;
     }

   // Keep calm and carry on
   return 1;
}


// Data shm

static Data_Shm *
_shared_data_shm_new(const char *infix, int size)
{
   Data_Shm *ds;
   size_t mapping_size;

   if (size <= 0)
     return NULL;

   ds = calloc(1, sizeof(Data_Shm));
   if (!ds) return NULL;

   mapping_size = cserve2_shm_size_normalize((size_t) size, 0);

   ds->shm = cserve2_shm_request(infix, mapping_size);
   if (!ds->shm)
     {
        ERR("Could not create shm of size %u", (unsigned) mapping_size);
        free(ds);
        return NULL;
     }

   ds->data = cserve2_shm_map(ds->shm);
   if (!ds->data)
     {
        ERR("Could not map shm of size %u", (unsigned) mapping_size);
        cserve2_shm_unref(ds->shm);
        free(ds);
        return NULL;
     }

   DBG("Created data shm of size %d: %d", size, cserve2_shm_id_get(ds->shm));
   return ds;
}

static void
_shared_data_shm_del(Data_Shm *ds)
{
   if (!ds) return;
   cserve2_shm_unref(ds->shm);
   free(ds);
}

static int
_shared_data_shm_resize(Data_Shm *ds, size_t newsize)
{
   Shm_Handle *shm;
   size_t mapping_size;

   if (newsize <= 0)
     return -1;

   mapping_size = cserve2_shm_size_normalize(newsize, ARRAY_MINSIZE);
   cserve2_shm_unmap(ds->shm);
   ds->data = NULL;

   shm = cserve2_shm_resize(ds->shm, mapping_size);
   if (!shm)
     {
        ERR("Could not resize shm %d to %u",
            cserve2_shm_id_get(ds->shm), (unsigned) newsize);
        return -1;
     }

   ds->shm = shm;
   ds->data = cserve2_shm_map(ds->shm);
   if (!ds->data)
     {
        ERR("Failed to remap shm %d after resizing to %u bytes",
            cserve2_shm_id_get(ds->shm), (unsigned) mapping_size);
        return -1;
     }

   return mapping_size;
}


// Arrays

Shared_Array *
cserve2_shared_array_new(int tag, int generation_id, int elemsize, int initcount)
{
   Shared_Array *sa;
   Data_Shm *ds;
   int mapping_size;

   if (elemsize <= 0 || initcount < 0)
     return NULL;

   sa = calloc(1, sizeof(Shared_Array));
   if (!sa) return NULL;

   if (!initcount) initcount = 1;
   mapping_size = cserve2_shm_size_normalize(elemsize * initcount
                                             + sizeof(Shared_Array_Header),
                                             ARRAY_MINSIZE);
   ds = _shared_data_shm_new("array", mapping_size);
   if (!ds)
     {
        free(sa);
        return NULL;
     }

   sa->ds = ds;
   sa->header = (Shared_Array_Header *) ds->data;
   sa->header->count = (mapping_size - sizeof(Shared_Array_Header)) / elemsize;
   sa->header->elemsize = elemsize;
   sa->header->generation_id = generation_id;
   sa->header->emptyidx = 0;
   sa->header->sortedidx = 0;
   sa->header->tag = tag;
   memset(&sa->header->_reserved1, 0, sizeof(int32_t) * 2);

   return sa;
}

const char *
cserve2_shared_array_name_get(Shared_Array *sa)
{
   if (!sa) return NULL;
   return cserve2_shm_name_get(sa->ds->shm);
}

void
cserve2_shared_array_del(Shared_Array *sa)
{
   if (!sa) return;
   _shared_data_shm_del(sa->ds);
   free(sa);
}

int
cserve2_shared_array_size_get(Shared_Array *sa)
{
   if (!sa) return -1;
   return sa->header->count;
}

int
cserve2_shared_array_count_get(Shared_Array *sa)
{
   if (!sa) return -1;
   return sa->header->emptyidx;
}

int
cserve2_shared_array_map_size_get(Shared_Array *sa)
{
   if (!sa || !sa->ds) return 0;
   return cserve2_shm_map_size_get(sa->ds->shm);
}

int
cserve2_shared_array_item_size_get(Shared_Array *sa)
{
   if (!sa) return -1;
   return sa->header->elemsize;
}

int
cserve2_shared_array_generation_id_get(Shared_Array *sa)
{
   if (!sa) return -1;
   return sa->header->generation_id;
}

int cserve2_shared_array_generation_id_set(Shared_Array *sa, int generation_id)
{
   if (!sa) return -1;
   if (sa->header->generation_id == generation_id)
     return 0;

   sa->header->generation_id = generation_id;
   return 1;
}

int
cserve2_shared_array_size_set(Shared_Array *sa, int newcount)
{
   int mapping_size;

   if (!sa) return -1;
   mapping_size = cserve2_shm_size_normalize(sa->header->elemsize * newcount
                                             + sizeof(Shared_Array_Header),
                                             ARRAY_MINSIZE);
   if (_shared_data_shm_resize(sa->ds, mapping_size) < 0)
     {
        sa->header = NULL;
        return -1;
     }
   sa->header = (Shared_Array_Header *) sa->ds->data;
   sa->header->count = (mapping_size - sizeof(Shared_Array_Header))
         / sa->header->elemsize;

   return sa->header->count;
}

int
cserve2_shared_array_item_new(Shared_Array *sa)
{
   if (!sa) return -1;
   if (sa->header->emptyidx >= sa->header->count)
     {
        int newcount = cserve2_shared_array_size_set(sa, sa->header->count + 1);
        if (newcount < 0) return -1;
     }

   return sa->header->emptyidx++;
}

const void *
cserve2_shared_array_item_data(Shared_Array *sa)
{
   return cserve2_shared_array_item_data_get(sa, 0);
}

void *
cserve2_shared_array_item_data_get(Shared_Array *sa, int elemid)
{
   char *ptr;

   if (!sa) return NULL;
   if (elemid < 0 || elemid >= sa->header->count)
     return NULL;

   ptr  = (char *) sa->header;
   ptr += sizeof(Shared_Array_Header);
   ptr += elemid * sa->header->elemsize;

   return ptr;
}

int
cserve2_shared_array_foreach(Shared_Array *sa, Eina_Each_Cb cb, void *data)
{
   char *ptr;
   int k;

   if (!sa || !cb) return -1;
   ptr = sa->ds->data + sizeof(Shared_Array_Header);

   for (k = 0; k < sa->header->emptyidx; k++)
     {
        if (!cb(sa, ptr, data))
          break;
        ptr += sa->header->elemsize;
     }

   return k;
}

Shared_Array *
cserve2_shared_array_repack(Shared_Array *sa, int generation_id,
                            Shared_Array_Repack_Skip_Cb skip,
                            Eina_Compare_Cb cmp,
                            void *user_data)
{
   Eina_List *l = NULL;
   Shared_Array *sa2;
   const char *srcdata;
   char *dstdata;
   int k, elemsize, newcount = 0;

   if (!sa || !skip || !cmp) return NULL;
   srcdata = sa->ds->data + sizeof(Shared_Array_Header);
   elemsize = sa->header->elemsize;

   // Build ordered list of pointers
   for (k = 0; k < sa->header->emptyidx; k++)
     {
        const char *data = srcdata + k * elemsize;
        if (skip(sa, data, user_data)) continue;
        l = eina_list_sorted_insert(l, cmp, data);
        newcount++;
     }

   // Create new array
   sa2 = cserve2_shared_array_new(sa->header->tag, generation_id, elemsize, newcount);
   if (!sa)
     {
        ERR("Can not repack array: failed to create new array");
        return NULL;
     }

   // Write data
   dstdata = sa2->ds->data + sizeof(Shared_Array_Header);
   while (l)
     {
        const char *data = eina_list_data_get(l);
        l = eina_list_remove_list(l, l);
        memcpy(dstdata, data, elemsize);
        dstdata += elemsize;
     }

   // Finalize & return
   sa2->header->emptyidx = newcount;
   sa2->header->sortedidx = newcount;
   sa2->header->tag = sa->header->tag;
   return sa2;
}

int
cserve2_shared_array_item_find(Shared_Array *sa, void *data,
                               Eina_Compare_Cb cmp)
{
   int k;
   const char *ptr;

   if (!sa || !cmp) return -1;

   // Binary search
   if (sa->header->sortedidx > 0)
     {
        int low = 0;
        int high = sa->header->sortedidx;
        int prev = -1;
        int r;
        k = high / 2;
        while (prev != k)
          {
             ptr = cserve2_shared_array_item_data_get(sa, k);
             r = cmp(ptr, data);
             if (!r)
               return k;
             else if (r > 0)
               high = k;
             else
               low = k;
             prev = k;
             k = low + (high - low) / 2;
          }
     }

   // Linear search O(n)
   k = sa->header->sortedidx;
   ptr = sa->ds->data + sizeof(Shared_Array_Header) + k * sa->header->elemsize;
   for (; k < sa->header->emptyidx; k++)
     {
        if (!cmp(ptr, data))
          return k;
        ptr += sa->header->elemsize;
     }

   return -1;
}

void *
cserve2_shared_array_item_data_find(Shared_Array *sa, void *data,
                                    Eina_Compare_Cb cmp)
{
   int elemid;

   elemid = cserve2_shared_array_item_find(sa, data, cmp);
   if (elemid < 0)
     return NULL;

   return cserve2_shared_array_item_data_get(sa, elemid);
}


// Shared index (used by the random mempool)

static Index_Entry *
_shared_index_entry_new(Shared_Index *si)
{
   Index_Entry *ie;
   int id;

   if (!si) return NULL;

   id = cserve2_shared_array_item_new(si->sa);
   if (id < 0) return NULL;

   ie = cserve2_shared_array_item_data_get(si->sa, id);
   ie->id = si->lastid++;
   return ie;
}

static Index_Entry *
_shared_index_entry_get_by_id(Shared_Index *si, unsigned int id)
{
   Index_Entry *obj;
   const char *base;
   int low = 0, high, start_high, elemsize;
   int cur;

   if (!si || !si->sa || !id)
     return NULL;

   // FIXME: HACK (consider all arrays always sorted by id)
   high = si->sa->header->emptyidx; // Should be si->sa->header->sortedidx

   if (high > si->sa->header->count)
     high = si->sa->header->count;

   base = si->sa->ds->data + sizeof(Shared_Array_Header);
   elemsize = si->sa->header->elemsize;

   // Direct access, works for non-repacked arrays
   if ((int) id < high)
     {
        obj = (Index_Entry *) (base + (elemsize * id));
        if (obj->id == id)
          return obj;
        if (obj->id < id)
          low = id + 1;
        else
          high = id;
     }

   // Binary search
   start_high = high;
   while(high > low)
     {
        cur = low + ((high - low) / 2);
        obj = (Index_Entry *) (base + (elemsize * cur));
        if (!obj)
          return NULL;
        if (obj->id == id)
          return obj;
        if (obj->id < id)
          low = cur + 1;
        else
          high = cur;
     }

   // Linear search
   for (cur = start_high; cur < si->sa->header->count; cur++)
     {
        obj = (Index_Entry *) (base + (elemsize * cur));
        if (!obj->id)
          return NULL;
        if (obj->id == id)
          return obj;
     }

   return NULL;
}

static Shared_Index *
_shared_index_new(int tag, int index_elemsize, int generation_id)
{
   Shared_Index *si;
   Index_Entry *ie;

   EINA_SAFETY_ON_FALSE_RETURN_VAL(index_elemsize >= 0, NULL);

   si = calloc(1, sizeof(Shared_Index));
   if (!si) return NULL;

   if (!index_elemsize)
     index_elemsize = sizeof(Index_Entry);

   si->sa = cserve2_shared_array_new(tag, generation_id, index_elemsize, 0);
   if (!si->sa)
     {
        free(si);
        return NULL;
     }

   si->lastid = 0;
   ie = _shared_index_entry_new(si);
   if (!ie)
     {
        cserve2_shared_array_del(si->sa);
        free(si);
        return NULL;
     }

   return si;
}

void
_shared_index_del(Shared_Index *si)
{
   if (!si) return;
   cserve2_shared_array_del(si->sa);
   free(si);
}


// Shared memory pool

Shared_Mempool *
cserve2_shared_mempool_new(int indextag, int index_elemsize,
                           int generation_id, int initsize)
{
   Shared_Mempool *sm;
   size_t mapping_size;

   EINA_SAFETY_ON_FALSE_RETURN_VAL(initsize >= 0, NULL);
   EINA_SAFETY_ON_FALSE_RETURN_VAL(index_elemsize >= 0, NULL);

   sm = calloc(1, sizeof(Shared_Mempool));
   if (!sm) return NULL;

   if (!initsize) initsize = 1;
   mapping_size = cserve2_shm_size_normalize((size_t) initsize, ARRAY_MINSIZE);

   sm->ds = _shared_data_shm_new("mempool", mapping_size);
   if (!sm->ds)
     {
        free(sm);
        return NULL;
     }

   sm->index = _shared_index_new(indextag, index_elemsize, generation_id);
   if (!sm->index)
     {
        _shared_data_shm_del(sm->ds);
        free(sm);
        return NULL;
     }

   sm->empty_size = mapping_size;
   return sm;
}

Shared_Array *
cserve2_shared_mempool_index_get(Shared_Mempool *sm)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(sm, NULL);
   return sm->index->sa;
}

static void
_shared_mempool_block_del(Eina_Rbtree *node, void *data EINA_UNUSED)
{
   Block *blk = (Block *) node;
   free(blk);
}

void
cserve2_shared_mempool_del(Shared_Mempool *sm)
{
   if (!sm) return;
   eina_rbtree_delete(EINA_RBTREE_GET(sm->empty_blocks),
                      EINA_RBTREE_FREE_CB(_shared_mempool_block_del), sm);
   _shared_data_shm_del(sm->ds);
   _shared_index_del(sm->index);
   free(sm);
}

static Index_Entry *
_shared_mempool_buffer_new(Shared_Mempool *sm, int size)
{

   Index_Entry *ie;
   Block *blk;
   int mapping_size, new_mapping_size;
   int rsize = _data_blocksize_roundup(size);

   if (!sm) return NULL;
   if (size <= 0) return NULL;

   mapping_size = cserve2_shm_map_size_get(sm->ds->shm);

   ie = _shared_index_entry_new(sm->index);
   if (!ie) return NULL;

   // Append if possible
   if (rsize <= sm->empty_size)
     {
        ie->length = rsize;
        ie->offset = mapping_size - sm->empty_size;
        ie->shmid = cserve2_shm_id_get(sm->ds->shm);
        ie->refcount = 1;
        sm->empty_size -= rsize;
        return ie;
     }

   // Find empty spot
   blk = (Block *) eina_rbtree_inline_lookup(
            EINA_RBTREE_GET(sm->empty_blocks), (void *) (intptr_t) rsize, 0,
            EINA_RBTREE_CMP_KEY_CB(_block_rbtree_empty_spot_find), NULL);
   if (blk && blk->length >= rsize)
     {
        ie->length = blk->length;
        ie->offset = blk->offset;
        ie->shmid = cserve2_shm_id_get(sm->ds->shm);
        ie->refcount = 1;

        sm->empty_blocks = (Block *) eina_rbtree_inline_remove(
                 EINA_RBTREE_GET(sm->empty_blocks), EINA_RBTREE_GET(blk),
                 EINA_RBTREE_CMP_NODE_CB(_block_rbtree_cmp), NULL);
        if (blk->length == rsize)
          free(blk);
        else
          {
             blk->length -= rsize;
             blk->offset += rsize;
             sm->empty_blocks = (Block *) eina_rbtree_inline_insert(
                      EINA_RBTREE_GET(sm->empty_blocks),  EINA_RBTREE_GET(blk),
                      EINA_RBTREE_CMP_NODE_CB(_block_rbtree_cmp), NULL);
          }

        return ie;
     }

   // Grow mempool
   new_mapping_size = _shared_data_shm_resize(
            sm->ds, mapping_size + rsize - sm->empty_size);
   if (new_mapping_size < 0)
     {
        memset(ie, 0, sizeof(Index_Entry));
        return NULL;
     }
   ie->length = rsize;
   ie->offset = mapping_size - sm->empty_size;
   ie->shmid = cserve2_shm_id_get(sm->ds->shm);
   ie->refcount = 1;
   sm->empty_size += (new_mapping_size - mapping_size) - rsize;
   return ie;
}

int
cserve2_shared_mempool_buffer_new(Shared_Mempool *sm, int size)
{
   Index_Entry *ie;

   ie = _shared_mempool_buffer_new(sm, size);
   if (!ie) return -1;

   return ie->id;
}

int
cserve2_shared_mempool_buffer_ref(Shared_Mempool *sm, int bufferid)
{
   Index_Entry *ie;

   if (!sm) return -1;
   ie = _shared_index_entry_get_by_id(sm->index, bufferid);
   if (!ie) return -1;

   if (!ie->refcount)
     {
        Block *blk = (Block *)
              eina_rbtree_inline_lookup(EINA_RBTREE_GET(sm->empty_blocks),
                                        ie, sizeof(Index_Entry),
                                        EINA_RBTREE_CMP_KEY_CB(
                                           _block_rbtree_block_find),
                                        sm);
        if (blk && (blk->length == ie->length)
            && (blk->offset == ie->offset)
            && (blk->shmid == ie->shmid))
          {
             sm->empty_blocks = (Block *) eina_rbtree_inline_remove(
                      EINA_RBTREE_GET(sm->empty_blocks), EINA_RBTREE_GET(blk),
                      EINA_RBTREE_CMP_NODE_CB(_block_rbtree_cmp), NULL);
             free(blk);
          }
     }

   ie->refcount++;
   return ie->id;
}

static const void *
_shared_mempool_buffer_del(Shared_Mempool *sm, int bufferid)
{
   Index_Entry *ie;
   const char *data;

   if (!sm || !bufferid) return NULL;

   ie = _shared_index_entry_get_by_id(sm->index, bufferid);
   if (!ie || ie->refcount <= 0)
     {
        CRIT("Tried to delete invalid buffer or with refcount 0");
        return NULL;
     }

   ie->refcount--;
   if (!ie->refcount)
     {
        Block *newblk = calloc(1, sizeof(Block));
        newblk->length = ie->length;
        newblk->offset = ie->offset;
        newblk->shmid = ie->shmid;
        sm->empty_blocks = (Block *) eina_rbtree_inline_insert(
                 EINA_RBTREE_GET(sm->empty_blocks), EINA_RBTREE_GET(newblk),
                 EINA_RBTREE_CMP_NODE_CB(_block_rbtree_cmp), NULL);
        data = sm->ds->data + ie->offset;
        return data;
     }

   return NULL;
}

void
cserve2_shared_mempool_buffer_del(Shared_Mempool *sm, int bufferid)
{
   _shared_mempool_buffer_del(sm, bufferid);
}

void *
cserve2_shared_mempool_buffer_get(Shared_Mempool *sm, int bufferid)
{
   Index_Entry *ie;
   char *data;

   if (!sm) return NULL;
   ie = _shared_index_entry_get_by_id(sm->index, bufferid);
   if (!ie || ie->refcount <= 0)
     {
        CRIT("Tried to access invalid buffer or with refcount 0");
        return NULL;
     }

   data = sm->ds->data + ie->offset;
   return data;
}

int
cserve2_shared_mempool_buffer_offset_get(Shared_Mempool *sm, int bufferid)
{
   Index_Entry *ie;

   if (!sm) return -1;
   ie = _shared_index_entry_get_by_id(sm->index, bufferid);
   if (!ie || ie->refcount <= 0)
     {
        CRIT("Tried to access invalid buffer or with refcount 0");
        return -1;
     }

   return ie->offset;
}

size_t
cserve2_shared_mempool_size_get(Shared_Mempool *sm)
{
   if (!sm) return 0;
   return cserve2_shm_map_size_get(sm->ds->shm)
         + cserve2_shared_array_map_size_get(sm->index->sa);
}

const char *
cserve2_shared_mempool_name_get(Shared_Mempool *sm)
{
   if (!sm) return NULL;
   return cserve2_shm_name_get(sm->ds->shm);
}

int
cserve2_shared_mempool_generation_id_get(Shared_Mempool *sm)
{
   if (!sm) return -1;
   return sm->index->sa->header->generation_id;
}

int
cserve2_shared_mempool_generation_id_set(Shared_Mempool *sm, int generation_id)
{
   if (!sm) return -1;
   if (sm->index->sa->header->generation_id == generation_id)
     return 0;

   sm->index->sa->header->generation_id = generation_id;
   return 1;
}


// Shared strings

static int _shared_strings_unref_items = 0;

const char *
cserve2_shared_strings_table_name_get()
{
   if (!_string_mempool)
     return NULL;

   return cserve2_shm_name_get(_string_mempool->ds->shm);
}

const char *
cserve2_shared_strings_index_name_get()
{
   if (!_string_mempool)
     return NULL;

   return cserve2_shared_array_name_get(_string_mempool->index->sa);
}

int
cserve2_shared_string_add(const char *str)
{
   Index_Entry *ie;
   char *data;
   int len, id;

   if (!str) return 0;

   // Find in known strings
   id = (int) (intptr_t) eina_hash_find(_string_entries, str);
   if (id > 0)
     {
        ie = _shared_index_entry_get_by_id(_string_mempool->index, id);
        if (!ie || ie->refcount <= 0)
          {
             ERR("String found in hash but not in mempool!");
             eina_hash_del(_string_entries, str, (void *) (intptr_t) id);
             goto new_entry;
          }
        ie->refcount++;
        return ie->id;
     }

   // Add new entry
new_entry:
   len = strlen(str) + 1;
   ie = _shared_mempool_buffer_new(_string_mempool, len);
   if (!ie)
     {
        ERR("Could not store new string in shm");
        return 0;
     }

   data = _string_mempool->ds->data + ie->offset;
   memcpy(data, str, len);
   eina_hash_add(_string_entries, data, (void *) (intptr_t) ie->id);
   return ie->id;
}

int
cserve2_shared_string_ref(int id)
{
   Index_Entry *ie;
   if (id <= 0) return 0;
   ie = _shared_index_entry_get_by_id(_string_mempool->index, id);
   if (!ie) return 0;
   if (!ie->refcount)
     _string_mempool--;
   return cserve2_shared_mempool_buffer_ref(_string_mempool, id);
}

void
cserve2_shared_string_del(int id)
{
   const char *data;

   if (id <= 0) return;
   if ((data = _shared_mempool_buffer_del(_string_mempool, id)) != NULL)
     {
        if (!eina_hash_del_by_key(_string_entries, data))
          {
             if (!eina_hash_del_by_data(_string_entries, (void *) (intptr_t) id))
               CRIT("Invalid free");
          }
     }
   _shared_strings_unref_items++;
}

const char *
cserve2_shared_string_get(int id)
{
   if (id <= 0) return NULL;
   return cserve2_shared_mempool_buffer_get(_string_mempool, id);
}

int
cserve2_shared_strings_repack(Shared_Array_Repack_Skip_Cb skip,
                              Eina_Compare_Cb cmp)
{
   int count;

   if (!_string_mempool->index) return -1;
   count = _string_mempool->index->lastid;
   if (!count) return -1;
   if (_shared_strings_unref_items * 100 / count >= 25
       && _shared_strings_unref_items > 100)
     {
        Shared_Array *sa;
        int genid;

        genid = _string_mempool->index->sa->header->generation_id + 1;
        sa = cserve2_shared_array_repack(_string_mempool->index->sa, genid,
                                         skip, cmp, NULL);
        if (!sa) return -1;

        cserve2_shared_array_del(_string_mempool->index->sa);
        _string_mempool->index->sa = sa;
        _shared_strings_unref_items = 0;
        return 1;
     }

   return 0;
}



// Init/destroy

void
cserve2_shared_index_init(void)
{
   if (!_instances)
     {
        char faketag[5] = {0};
        int ifaketag = STRING_MEMPOOL_FAKETAG;

        DBG("Initializing shared index");
        _string_mempool = cserve2_shared_mempool_new(STRING_INDEX_ARRAY_TAG, 0, 0, 0);
        _string_entries = eina_hash_string_djb2_new(NULL);

        memcpy(faketag, &ifaketag, sizeof(int));
        cserve2_shared_string_add(faketag);
        _shared_strings_unref_items = 0;
     }
   _instances++;
}

void
cserve2_shared_index_shutdown(void)
{
   _instances--;
   if (!_instances)
     {
        DBG("Destroying shared index");
        cserve2_shared_mempool_del(_string_mempool);
        eina_hash_free(_string_entries);

        _string_mempool = NULL;
        _string_entries = NULL;
     }
}