#include "copyright.h"

#include <stdio.h>
#include <ctype.h>

#include "db.h"
#include "config.h"

struct object *db = 0;
dbref db_top = 0;
#ifdef RECYCLE
dbref recyclable = NOTHING;
#endif

#ifdef TEST_MALLOC
int malloc_count = 0;
#endif /* TEST_MALLOC */

#ifndef DB_INITIAL_SIZE
#define DB_INITIAL_SIZE 10000
#endif /* DB_INITIAL_SIZE */

#ifdef DB_DOUBLING

dbref db_size = DB_INITIAL_SIZE;
#endif /* DB_DOUBLING */

const char *alloc_string (const char *string)
{
  char *s;

  /* NULL, "" -> NULL */
  if (string == 0 || *string == '\0')
    return 0;

  if ((s = (char *) malloc (strlen (string) + 1)) == 0) {
    abort ();
  }
  strcpy (s, string);
  return s;
}

#ifdef DB_DOUBLING

static void db_grow (dbref newtop)
{
  struct object *newdb;

  if (newtop > db_top) {
    db_top = newtop;
    if (!db) {
      /* make the initial one */
      db_size = DB_INITIAL_SIZE;
      if ((db = (struct object *)
          malloc (db_size * sizeof (struct object))) == 0) {
        abort ();
      }
    }

    /* maybe grow it */
    if (db_top > db_size) {
      /* make sure it's big enough */
      while (db_top > db_size)
        db_size *= 2;
      if ((newdb = (struct object *)
          realloc ((void *) db, db_size * sizeof (struct object))) == 0) {
        abort ();
      }
      db = newdb;
    }
  }
}

#else /* DB_DOUBLING */

static void db_grow (dbref newtop)
{
  struct object *newdb;

  if (newtop > db_top) {
    db_top = newtop;
    if (db) {
      if ((newdb = (struct object *)
          realloc ((void *) db, db_top * sizeof (struct object))) == 0) {
        abort ();
      }
      db = newdb;
    } else {
      /* make the initial one */
      if ((db = (struct object *)
          malloc (DB_INITIAL_SIZE * sizeof (struct object))) == 0) {
        abort ();
      }
    }
  }
}
#endif /* DB_DOUBLING */

dbref new_object (void)
{
  dbref newobj;
  struct object *o;

#ifdef RECYCLE
  if (recyclable != NOTHING) {
    newobj = recyclable;
    recyclable = db[newobj].next;
  } else
#endif
  {
    newobj = db_top;
    db_grow (db_top + 1);
  }

  /* clear it out */
  o = db + newobj;
  o->name = 0;
  o->description = 0;
  o->location = NOTHING;
  o->contents = NOTHING;
  o->exits = NOTHING;
  o->next = NOTHING;
  o->key = TRUE_BOOLEXP;
  o->fail_message = 0;
  o->succ_message = 0;
  o->ofail = 0;
  o->osuccess = 0;
  o->owner = NOTHING;
  o->pennies = 0;
  /* flags you must initialize yourself */
  o->password = 0;
#ifdef TIMESTAMPS
  /* Timestamp entries - Sep 1, 1990 by Fuzzy */
  o->created = time (0);
  o->lastused = 0;
  o->usecnt = 0;
#endif  /* TIMESTAMPS */

  return newobj;
}

#define DB_MSGLEN 512

void putref (FILE * f, dbref ref)
{
  fprintf (f, "%d\n", ref);
}

static void putstring (FILE * f, const char *s)
{
  if (s) {
    fputs (s, f);
  }
  putc ('\n', f);
}

static void putbool_subexp (FILE * f, struct boolexp *b)
{
  switch (b->type) {
  case BOOLEXP_AND:
    putc ('(', f);
    putbool_subexp (f, b->sub1);
    putc (AND_TOKEN, f);
    putbool_subexp (f, b->sub2);
    putc (')', f);
    break;
  case BOOLEXP_OR:
    putc ('(', f);
    putbool_subexp (f, b->sub1);
    putc (OR_TOKEN, f);
    putbool_subexp (f, b->sub2);
    putc (')', f);
    break;
  case BOOLEXP_NOT:
    putc ('(', f);
    putc (NOT_TOKEN, f);
    putbool_subexp (f, b->sub1);
    putc (')', f);
    break;
  case BOOLEXP_CONST:
    fprintf (f, "%d", b->thing);
    break;
  default:
    break;
  }
}

void putboolexp (FILE * f, struct boolexp *b)
{
  if (b != TRUE_BOOLEXP) {
    putbool_subexp (f, b);
  }
  putc ('\n', f);
}

int db_write_object (FILE * f, dbref i)
{
  struct object *o;

  o = db + i;
  putstring (f, o->name);
  putstring (f, o->description);
  putref (f, o->location);
  putref (f, o->contents);
  putref (f, o->exits);
  putref (f, o->next);
  putboolexp (f, o->key);
  putstring (f, o->fail_message);
  putstring (f, o->succ_message);
  putstring (f, o->ofail);
  putstring (f, o->osuccess);
  putref (f, o->owner);
  putref (f, o->pennies);
  putref (f, (o->flags));
  putstring (f, o->password);
#ifdef TIMESTAMPS
  putref (f, o->created);
  putref (f, o->lastused);
  putref (f, o->usecnt);
#endif  /* TIMESTAMPS */

  return 0;
}

dbref db_write (FILE * f)
{
  dbref i;

  for (i = 0; i < db_top; i++) {
    fprintf (f, "#%d\n", i);
    db_write_object (f, i);
  }
  fputs ("***END OF DUMP***\n", f);
  fflush (f);
  return (db_top);
}

dbref parse_dbref (const char *s)
{
  const char *p;
  long x;

  x = atol (s);
  if (x > 0) {
    return x;
  } else if (x == 0) {
    /* check for 0 */
    for (p = s; *p; p++) {
      if (*p == '0')
        return 0;
      if (!isspace (*p))
        break;
    }
  }

  /* else x < 0 or s != 0 */
  return NOTHING;
}

static int do_peek (FILE * f)
{
  int peekch;

  ungetc ((peekch = getc (f)), f);

  return (peekch);
}

dbref getref (FILE * f)
{
  static char buf[DB_MSGLEN];
  int peekch;

  /* Compiled in with or without timestamps, Sep 1, 1990 by Fuzzy */
  if ((peekch = do_peek (f)) == '#' || peekch == '*') {
    return (0);
  }

  fgets (buf, sizeof (buf), f);
  return (atol (buf));
}

static const char *getstring_noalloc (FILE * f)
{
  static char buf[DB_MSGLEN];
  char *p;

  fgets (buf, sizeof (buf), f);
  for (p = buf; *p; p++) {
    if (*p == '\n') {
      *p = '\0';
      break;
    }
  }

  return buf;
}

#define getstring(x) alloc_string(getstring_noalloc(x))

#ifdef COMPRESS
extern const char *compress (const char *);
#define getstring_compress(x) alloc_string(compress(getstring_noalloc(x)));
#else
#define getstring_compress(x) getstring(x)
#endif /* COMPRESS */

static struct boolexp *negate_boolexp (struct boolexp *b)
{
  struct boolexp *n;

  /* Obscure fact: !NOTHING == NOTHING in old-format databases! */
  if (b == TRUE_BOOLEXP)
    return TRUE_BOOLEXP;

  n = (struct boolexp *) malloc (sizeof (struct boolexp));
  n->type = BOOLEXP_NOT;
  n->sub1 = b;

  return n;
}

static struct boolexp *getboolexp1 (FILE * f)
{
  struct boolexp *b;
  int c;

  c = getc (f);
  switch (c) {
  case '\n':
    ungetc (c, f);
    return TRUE_BOOLEXP;
    /* break; */
  case EOF:
    abort ();                   /* unexpected EOF in boolexp */
    break;
  case '(':
    b = (struct boolexp *) malloc (sizeof (struct boolexp));
    if ((c = getc (f)) == '!') {
      b->type = BOOLEXP_NOT;
      b->sub1 = getboolexp1 (f);
      if (getc (f) != ')')
        goto error;
      return b;
    } else {
      ungetc (c, f);
      b->sub1 = getboolexp1 (f);
      switch (c = getc (f)) {
      case AND_TOKEN:
        b->type = BOOLEXP_AND;
        break;
      case OR_TOKEN:
        b->type = BOOLEXP_OR;
        break;
      default:
        goto error;
        /* break */
      }
      b->sub2 = getboolexp1 (f);
      if (getc (f) != ')')
        goto error;
      return b;
    }
    /* break; */
  case '-':
    /* obsolete NOTHING key */
    /* eat it */
    while ((c = getc (f)) != '\n')
      if (c == EOF)
        abort ();               /* unexp EOF */
    ungetc (c, f);
    return TRUE_BOOLEXP;
    /* break */
  default:
    /* better be a dbref */
    ungetc (c, f);
    b = (struct boolexp *) malloc (sizeof (struct boolexp));
    b->type = BOOLEXP_CONST;
    b->thing = 0;

    /* NOTE possibly non-portable code */
    /* Will need to be changed if putref/getref change */
    while (isdigit (c = getc (f))) {
      b->thing = b->thing * 10 + c - '0';
    }
    ungetc (c, f);
    return b;
  }

error:
  abort ();                     /* bomb out */
  return TRUE_BOOLEXP;
}

struct boolexp *getboolexp (FILE * f)
{
  struct boolexp *b;

  b = getboolexp1 (f);
  if (getc (f) != '\n')
    abort ();                   /* parse error, we lose */
  return b;
}

void free_boolexp (struct boolexp *b)
{
  if (b != TRUE_BOOLEXP) {
    switch (b->type) {
    case BOOLEXP_AND:
    case BOOLEXP_OR:
      free_boolexp (b->sub1);
      free_boolexp (b->sub2);
      free ((void *) b);
      break;
    case BOOLEXP_NOT:
      free_boolexp (b->sub1);
      free ((void *) b);
      break;
    case BOOLEXP_CONST:
      free ((void *) b);
      break;
    }
  }
}

void db_free (void)
{
  dbref i;
  struct object *o;

  if (db) {
    for (i = 0; i < db_top; i++) {
      o = &db[i];
      if (o->name)
        free ((void *) o->name);
      if (o->description)
        free ((void *) o->description);
      if (o->succ_message)
        free ((void *) o->succ_message);
      if (o->fail_message)
        free ((void *) o->fail_message);
      if (o->ofail)
        free ((void *) o->ofail);
      if (o->osuccess)
        free ((void *) o->osuccess);
      if (o->password)
        free ((void *) o->password);
      if (o->key)
        free_boolexp (o->key);
    }
    free ((void *) db);
    db = 0;
    db_top = 0;
#ifdef RECYCLE
    recyclable = NOTHING;
#endif
  }
}

dbref db_read (FILE * f)
{
  dbref i;
  struct object *o;
  const char *end;
  static char buf[DB_MSGLEN];
  int peekch;

#ifdef PLAYER_LIST
  clear_players ();
#endif

  db_free ();
  for (i = 0;; i++) {
    switch (getc (f)) {
    case '#':
      /* another entry, yawn */
      if (i != getref (f)) {
        /* we blew it */
        return -1;
      }
      /* make space */
      db_grow (i + 1);

      /* read it in */
      o = db + i;
      o->name = getstring (f);
      o->description = getstring_compress (f);
      o->location = getref (f);
      o->contents = getref (f);
      o->exits = getref (f);
      o->next = getref (f);
      o->key = getboolexp (f);
      o->fail_message = getstring_compress (f);
      o->succ_message = getstring_compress (f);
      o->ofail = getstring_compress (f);
      o->osuccess = getstring_compress (f);
      o->owner = getref (f);
      o->pennies = getref (f);
      o->flags = getref (f);
      o->password = getstring (f);
#ifdef TIMESTAMPS
      o->created = getref (f);
      o->lastused = getref (f);
      o->usecnt = getref (f);
#endif  /* TIMESTAMPS */

      /* Ignore extra input to next '#' or '*' */
      while ((peekch = do_peek (f)) != EOF && peekch != '#' && peekch != '*') {
        fgets (buf, sizeof (buf), f);
      }

      /* For downward compatibility with databases using the */
      /* obsolete ANTILOCK flag. */
      if (o->flags & ANTILOCK) {
        o->key = negate_boolexp (o->key);
        o->flags &= ~ANTILOCK;
      }
#ifdef PLAYER_LIST
      if (Typeof (i) == TYPE_PLAYER) {
        add_player (i);
      }
#endif  /* PLAYER_LIST */
#ifdef RECYCLE
      if (Typeof (i) == TYPE_GARBAGE) {
        o->owner = NOTHING;
        o->next = recyclable;
        recyclable = i;
        free ((void *) o->name);
        free ((void *) o->description);
        o->name = "<garbage>";
        o->description = "<recyclable>";
      }
#endif
      break;
    case '*':
      end = getstring (f);
      if (strcmp (end, "**END OF DUMP***")) {
        free ((void *) end);
        return -1;
      } else {
        free ((void *) end);
        return db_top;
      }
    default:
      return -1;
      /* break; */
    }
  }
}