/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 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 Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

/*
 * shstr.C
 */

#include <cstring>
#include <cstdlib>
#include <glib.h>
#include <tr1/unordered_set>

#include "global.h"

size_t shstr_alloc;

typedef std::tr1::unordered_set <const char *, str_hash, str_equal, slice_allocator<const char *> > HT;

static HT ht;
static int next_gc;

#define NUM_INT 3

static const char *
makevec (const char *s)
{
  int len = strlen (s);
  int alloc = sizeof (uint32_t) * NUM_INT + len + 1;

  shstr_alloc += alloc;
  char *v = (char *)g_slice_alloc (alloc);
  v += sizeof (uint32_t) * NUM_INT;

  shstr::hash   (v) = strhsh (s);
  shstr::length (v) = len;
  shstr::refcnt (v) = 1;

  memcpy (v, s, len + 1);

  return v;
}

shstr_vec<sizeof "(null)"> shstr_tmp::nullvec = { STRHSH_NULL, 0, 0xffffffff, "(null)" };

const char *
shstr::find (const char *s)
{
  if (!s)
    return s;

  auto (i, ht.find (s));

  return i != ht.end ()? *i : 0;
}

const char *
shstr::intern (const char *s)
{
  if (!s)
    return null ();

  if (const char *found = find (s))
    {
      ++refcnt (found);
      return found;
    }

  --next_gc;
  s = makevec (s);
  ht.insert (s);
  return s;
}

// periodically test refcounts == 0 for a few strings
// this is the ONLY thing that erases stuff from ht. keep it that way.
void
shstr::gc ()
{
  if (expect_true (next_gc > 0))
    return;

  static const char *curpos;

  auto (i, curpos ? ht.find (curpos) : ht.begin ());

  if (i == ht.end ())
    i = ht.begin ();

  int n = ht.size () / 256 + 16;
  next_gc += n >> 1;

  for (;;)
    {
      if (i == ht.end ())
        {
          curpos = 0;
          return;
        }
      else if (!--n)
        break;
      else if (!refcnt (*i))
        {
          auto (o, i++);
          const char *s = *o;

          ht.erase (o);

          //printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
          int alloc = sizeof (uint32_t) * NUM_INT + length (s) + 1;
          shstr_alloc -= alloc;
          g_slice_free1 (alloc, (void *)(s - sizeof (uint32_t) * NUM_INT));
        }
      else
        ++i;
    }

  curpos = *i;
}

// declare these here to get correct initialisation order
#define def2(id,str) const shstr id (str);
#define def(id)      def2(shstr_ ## id, # id)
# include "shstrinc.h"
#undef def
#undef def2

shstr skill_names[NUM_SKILLS];
materialtype_t material_null;