#include "copyright.h"

#include <stdio.h>
#include <ctype.h>
#include <sys/param.h>

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

#ifndef MUDNAME
#define MUDNAME "Islandia"
#endif

static int include_all = 0;     /* include everything unless specified */
static int keep_players = 0;    /* keep all players */
static int safe_below = 1;      /* Keep everything <= safe_below */
static int safe_above = 2e9;    /* Keep everything >= safe_above */
static int reachable = 0;       /* Only keep rooms reachable from #0 */
static int norecycle = 0;       /* Exclude things in recycling center */
static int inbuild = 0;         /* True when in main nuild_trans loop */
static int recycling_center = 0;        /* Room number home("Recycler") */

# define REACH_FLAG 0x40000000
# define REACHABLE(X) (db[X].flags & REACH_FLAG)
# define SET_REACHABLE(X) (db[X].flags |= REACH_FLAG)

static dbref included[NCARGS + 1];
static dbref excluded[NCARGS + 1];

static dbref *trans;            /* translation vector */

#define DEFAULT_LOCATION (0)
#define DEFAULT_OWNER (1)

static int isok (dbref);
char *OIF_ID (int);
void OIFboolexp (FILE *, struct boolexp *);
char *ofix (const char *);

/* returns 1 if object is specifically excluded */
static int is_excluded (dbref x)
{
  int i;

  if (x == NOTHING)
    return 0;                   /* Don't exclude nothing */

  /* check that it isn't excluded */
  for (i = 0; excluded[i] != NOTHING; i++) {
    if (excluded[i] == x)
      return 1;                 /* always exclude specifics */
    if (excluded[i] == db[x].owner)
      return 1;
  }

  return (0);
}

/* returns 1 if it is not excluded */
static int not_excluded (dbref x)
{
  int i;

  if (x == NOTHING)
    return 1;                   /* Don't exclude nothing */

  /* check that it isn't excluded */
  for (i = 0; excluded[i] != NOTHING; i++) {
    if (excluded[i] == x)
      return 0;                 /* always exclude specifics */
    if (excluded[i] == db[x].owner)
      return 0;
  }

  /* if it's an exit, check that its destination is ok */
  if (Typeof (x) == TYPE_EXIT && db[x].location >= 0) {
    return isok (db[x].location);
  } else {
    return 1;
  }
}

/* returns 1 if it should be included in translation vector */
static int isok (dbref x)
{
  int i;

  if (x == DEFAULT_OWNER || x == DEFAULT_LOCATION)
    return 1;
  if (x == NOTHING)
    return 1;

  for (i = 0; included[i] != NOTHING; i++) {
    if (included[i] == x)
      return 1;                 /* always get specific ones */

    if (reachable && Typeof (x) == TYPE_ROOM && !REACHABLE (x)) {
# ifdef DEBUG
      if (inbuild)
        fprintf (stderr, "Excluding %s(%dR), not reachable\n", db[x].name, x);
# endif
      return 0;
    }
#ifdef	RECYCLER
    if (norecycle && db[x].location == recycling_center)
      return 0;
#endif

    if (included[i] == db[x].owner || (x <= safe_below || x >= safe_above)
      || keep_players && Typeof (x) == TYPE_PLAYER) {
      return not_excluded (x);
    }
  }

#if	0
  /* This is an UnterMUD converter. UnterMUDs don't have carried
     exits, so DROP such. Notez Bien: relies on the new source field. */
  if (Typeof (i) == TYPE_EXIT && db[i].source == NOTHING)
    return 0;
#endif

  /* not in the list, can only get it if include_all is on */
  /* or it's owned by DEFAULT_OWNER */
  return (include_all && not_excluded (x));
}

static void build_trans (void)
{
  dbref i;
  dbref val;

  if ((trans = (dbref *) malloc (sizeof (dbref) * db_top)) == 0) {
    abort ();
  }

  inbuild++;

  val = 0;
  for (i = 0; i < db_top; i++) {
    if (isok (i)) {
      trans[i] = val++;
    } else {
      trans[i] = NOTHING;
    }
  }

  inbuild--;
}

static dbref translate (dbref x)
{
  if (x == NOTHING || x == HOME) {
    return (x);
  } else {
    return (trans[x]);
  }
}

/* TRUE_BOOLEXP means throw this argument out */
/* even on OR; it's effectively a null boolexp */
/* NOTE: this doesn't free anything, it just munges it up */
static struct boolexp *translate_boolexp (struct boolexp *exp)
{
  struct boolexp *s1;
  struct boolexp *s2;

  if (exp == TRUE_BOOLEXP) {
    return TRUE_BOOLEXP;
  } else {
    switch (exp->type) {
    case BOOLEXP_NOT:
      s1 = translate_boolexp (exp->sub1);
      if (s1 == TRUE_BOOLEXP) {
        return TRUE_BOOLEXP;
      } else {
        exp->sub1 = s1;
        return exp;
      }
      /* break; */
    case BOOLEXP_AND:
    case BOOLEXP_OR:
      s1 = translate_boolexp (exp->sub1);
      s2 = translate_boolexp (exp->sub2);
      if (s1 == TRUE_BOOLEXP && s2 == TRUE_BOOLEXP) {
        /* nothing left */
        return TRUE_BOOLEXP;
      } else if (s1 == TRUE_BOOLEXP && s2 != TRUE_BOOLEXP) {
        /* s2 is all that is left */
        return s2;
      } else if (s1 != TRUE_BOOLEXP && s2 == TRUE_BOOLEXP) {
        /* s1 is all that is left */
        return s1;
      } else {
        exp->sub1 = s1;
        exp->sub2 = s2;
        return exp;
      }
      /* break; */
    case BOOLEXP_CONST:
      exp->thing = translate (exp->thing);
      if (exp->thing == NOTHING) {
        return TRUE_BOOLEXP;
      } else {
        return exp;
      }
      /* break; */
    default:
      abort ();                 /* bad boolexp type, we lose */
      return TRUE_BOOLEXP;
    }
  }
}

static int ok (dbref x)
{
  if (x == NOTHING || x == HOME) {
    return 1;
  }
  /* This is an UnterMUD converter. UnterMUDs don't have carried
     exits, so DROP such. Notez Bien: relies on the new source field. */
  if (Typeof (x) == TYPE_EXIT && db[x].source == NOTHING)
    return 0;                   /* Put here to avoid things getting renumbered. */
#ifdef	TYPE_GARBAGE
  if (Typeof (x) == TYPE_GARBAGE)
    return 0;
#endif
  return trans[x] != NOTHING;
}

static void check_bad_exits (dbref x)
{
  dbref e;

  if (Typeof (x) == TYPE_ROOM && !isok (x)) {
    /* mark all exits as excluded */
    DOLIST (e, db[x].exits) {
      trans[e] = NOTHING;
    }
  }
}

static void check_owner (dbref x)
{
  if (ok (x) && !ok (db[x].owner)) {
    db[x].owner = DEFAULT_OWNER;
  }
}

static void check_location (dbref x)
{
  dbref loc;
  dbref newloc;

  if (ok (x) && (Typeof (x) == TYPE_THING || Typeof (x) == TYPE_PLAYER)
    && !ok (loc = db[x].location)) {
    /* move it to home or DEFAULT_LOCATION */
    if (ok (db[x].exits)) {
      newloc = db[x].exits;     /* home */
    } else {
      newloc = DEFAULT_LOCATION;
    }
    db[loc].contents = remove_first (db[loc].contents, x);
    PUSH (x, db[newloc].contents);
    db[x].location = newloc;
  }
}

static void check_next (dbref x)
{
  dbref next;

  if (ok (x)) {
    while (!ok (next = db[x].next))
      db[x].next = db[next].next;
  }
}

static void check_contents (dbref x)
{
  dbref c;

  if (ok (x)) {
    while (!ok (c = db[x].contents))
      db[x].contents = db[c].next;
  }
}

/* also updates home */
/* MUST BE CALLED AFTER check_owner! */
static void check_exits (dbref x)
{
  dbref e;

  if (ok (x) && !ok (e = db[x].exits)) {
    switch (Typeof (x)) {
    case TYPE_ROOM:
      while (!ok (e = db[x].exits))
        db[x].exits = db[e].next;
      break;
    case TYPE_PLAYER:
    case TYPE_THING:
      if (ok (db[db[x].owner].exits)) {
        /* set it to owner's home */
        db[x].exits = db[db[x].owner].exits;    /* home */
      } else {
        /* set it to DEFAULT_LOCATION */
        db[x].exits = DEFAULT_LOCATION; /* home */
      }
      break;
    }
  }
}

void exitsources ()
{
  dbref i;
  dbref e;

  /* Make sure all sources have something recognizable. */
  for (i = 0; i < db_top; i++)
    db[i].source = NOTHING;
  for (i = 0; i < db_top; i++) {
    if (Typeof (i) == TYPE_ROOM) {
      DOLIST (e, db[i].exits) {
        db[e].source = i;
      }
    }
  }
}


char buf[BUFSIZ];

static void do_OIF_write (void)
{
  dbref i;
  dbref kludge;

  for (i = 0, kludge = 0; i < db_top; i++) {
    if (trans[i] != NOTHING)
      trans[i] = kludge++;
  }

  printf
    ("object sysobj\nint _objcnt=%d\nint newsarticle=0\nstr nam=The System Object (all mighty data point)\nobj _syslimbo=0\nlst own=wizard\nlst _wizards=wizard\nendobj\n",
    db_top - 1);
  strcpy (buf, "wizard");
  rot_init (buf);
  rot_encode ("potrzebie", buf);
  printf
    ("object wizard\nflg _wz=\nflg _pl=\nstr nam=UnterWiz\nobj home=0@%s\nstr pass=%s\nobj loc=0\nlst own=wizard\nendobj\n",
    MUDNAME, buf);

  for (i = 0; i < db_top; i++)
    if (ok (i)) {
      printf ("object %s\n", OIF_ID (i));
      printf ("str nam=%s\n", db[i].name);
      if (db[i].description)
        printf ("str desc=%s\n", db[i].description);
      if (db[i].contents) {
        printf ("lst con=");
        for (kludge = db[i].contents; kludge != NOTHING;
          kludge = db[kludge].next)
          if (Typeof (kludge) != TYPE_PLAYER)
            printf ("%s;", OIF_ID (kludge));
        printf ("\n");
      }
      if (db[i].key && !(Typeof (i) == TYPE_EXIT &&
          db[i].location == NOTHING)) {
        printf ("boo lok=");
        OIFboolexp (stdout, translate_boolexp (db[i].key));
      } else if (Typeof (i) == TYPE_EXIT && db[i].location == NOTHING)
        printf ("boo lok=F\n"); /* People can't walk through unlinked exits. */
      else
        printf ("boo lok=T\n");
      if (db[i].fail_message)
        printf ("str fail=%s\n", db[i].fail_message);
      if (db[i].ofail)
        printf ("str ofail=%s\n", ofix (db[i].ofail));
      if (db[i].succ_message)
        printf ("str succ=%s\n", db[i].succ_message);
      if (db[i].osuccess)
        printf ("str osucc=%s\n", ofix (db[i].osuccess));
      printf ("lst own=%s\n", OIF_ID (db[i].owner));
      if (db[i].flags & LINK_OK)
        printf ("boo lnk=T\n");
      if (db[i].flags & DARK)
        printf ("flg dark=\n");
      switch (Typeof (i)) {
      case TYPE_PLAYER:
        printf ("flg _pl=\n");
        if (Wizard (i))
          printf ("flg _wz=\n");
        printf ("obj loc=%s\n", OIF_ID (db[i].location));
        printf ("obj home=%d@%s\n", translate (db[i].exits), MUDNAME);
        if (Genderof (i) == GENDER_MALE) {
          printf ("str subv=he\n");
          printf ("str objv=him\n");
          printf ("str posv=his\n");
        } else if (Genderof (i) == GENDER_FEMALE) {
          printf ("str subv=she\n");
          printf ("str objv=her\n");
          printf ("str posv=her\n");
        } else if (Genderof (i) == GENDER_NEUTER) {
          printf ("str subv=it\n");
          printf ("str objv=it\n");
          printf ("str posv=its\n");
        } else {
          printf ("str subv=%s\n", db[i].name);
          printf ("str objv=%s\n", db[i].name);
          printf ("str posv=%s's\n", db[i].name);
        }
        OIF_ID (i);
        if (db[i].password) {
          rot_init (buf);
          rot_encode (db[i].password, buf);
        } else {
          buf[0] = 0;
        }
        printf ("str pass=%s\n", buf);
        break;
      case TYPE_THING:
        printf ("obj loc=%s\n", OIF_ID (db[i].location));
        printf ("obj home=%d@%s\n", translate (db[i].exits), MUDNAME);
        if (db[i].flags & STICKY)
          printf ("cmd drop=tel $me home;_echo Dropped.\n");
        break;
      case TYPE_ROOM:
        printf ("flg _rm=\n");
        if (translate (db[i].location) != NOTHING)
          printf ("obj drpto=%s\n", OIF_ID (db[i].location));
        printf ("lst xit=");
        for (kludge = db[i].exits; kludge != NOTHING;
          kludge = db[kludge].next)
          printf ("%s;", OIF_ID (kludge));
        printf ("\n");
        printf ("lst ply=");
        for (kludge = db[i].contents; kludge != NOTHING;
          kludge = db[kludge].next)
          if (Typeof (kludge) == TYPE_PLAYER)
            printf ("%s;", OIF_ID (kludge));
        printf ("\n");
        break;
      case TYPE_EXIT:
        /* Unlinked exit? Make it actually linked to home. */
        if (db[i].location == NOTHING)
          printf ("obj dst=home\n");
        else
          printf ("obj dst=%s\n", OIF_ID (db[i].location));
        /* Yes, this is NEW. */
        printf ("obj loc=%s\n", OIF_ID (db[i].source));
        break;
      default:                 /* Do something sensible for stuff we don't
                                   understand. */
        fprintf (stderr, "Can't handle type %d\n", Typeof (i));
        abort ();
       /*NOTREACHED*/}
      printf ("endobj\n");
    }
}

char *OIF_ID (dbref i)
{
  if (i == HOME)
    sprintf (buf, "home");
  else if (Typeof (i) == TYPE_PLAYER || Typeof (i) == TYPE_THING)
    sprintf (buf, "%d@%s", translate (i), MUDNAME);
  else
    sprintf (buf, "%d", translate (i));
  return (buf);
}


int reach_lvl = 0;

void make_reachable (dbref x)
{
  dbref e, r;
#ifdef DEBUG
  int i;
#endif

  if (Typeof (x) != TYPE_ROOM || is_excluded (x))
    return;

  reach_lvl++;

  SET_REACHABLE (x);

#ifdef DEBUG
  for (i = 0; i < reach_lvl; i++)
    fputc (' ', stderr);
  fprintf (stderr, "Set %s(%dR) reachable.\n", db[x].name, x);
#endif

  DOLIST (e, db[x].exits) {
    r = db[e].location;

    if (r < 0)
      continue;
    if (is_excluded (r))
      continue;
    if (is_excluded (e))
      continue;
    if (!REACHABLE (r))
      make_reachable (r);
  }

  reach_lvl--;
}

void main (int argc, char **argv)
{
  dbref i;
  int top_in;
  int top_ex;
  char *arg0;

  top_in = 0;
  top_ex = 0;

  /* Load database */
  if (db_read (stdin) < 0) {
    fputs ("Database load failed!\n", stderr);
    exit (1);
  }

  fputs ("Done loading database...\n", stderr);


  /* now parse args */
  arg0 = *argv;
  for (argv++, argc--; argc > 0; argv++, argc--) {
    if (isdigit (**argv) || **argv == '-' && isdigit ((*argv)[1])) {
      i = atol (*argv);
    } else if (**argv == '+' && isdigit ((*argv)[1])) {
      i = atol (*argv + 1);
    } else if (**argv == 'b' && isdigit ((*argv)[1])) {
      safe_below = atol (*argv + 1);
      fprintf (stderr, "Including all objects %d and below\n", safe_below);
    } else if (**argv == 'a' && isdigit ((*argv)[1])) {
      safe_above = atol (*argv + 1);
      fprintf (stderr, "Including all objects %d and above\n", safe_above);
    } else if (!strcmp (*argv, "all")) {
      include_all = 1;
    } else if (!strcmp (*argv, "reachable")) {
      reachable = 1;
    } else if (!strcmp (*argv, "players")) {
      keep_players = 1;
    } else if (!strcmp (*argv, "norecycle")) {
      norecycle = 1;
    } else if (**argv == '-' && (i = lookup_player (*argv + 1)) != 0) {
      fprintf (stderr, "Excluding player %s(%d)\n", db[i].name, i);
      i = -i;
    } else if (**argv != '-' && (i = lookup_player (*argv)) != NOTHING) {
      fprintf (stderr, "Including player %s(%d)\n", db[i].name, i);
    } else {
      fprintf (stderr, "%s: bogus argument %s\n", arg0, *argv);
      continue;
    }

    if (i < 0) {
      excluded[top_ex++] = -i;
    } else {
      included[top_in++] = i;
    }
  }

  /* Terminate */
  included[top_in++] = NOTHING;
  excluded[top_ex++] = NOTHING;

  /* Check for reachability from DEFAULT_LOCATION */
  if (reachable) {
    make_reachable (DEFAULT_LOCATION);
    fputs ("Done marking reachability...\n", stderr);
  }

  /* Gives all exits sources -- this becomes important later on. */
  exitsources ();

#ifdef	RECYCLER
  /* Find recycler */
  if (norecycle && ((i = lookup_player (RECYCLER)) != NOTHING)) {
    recycling_center = db[i].exits;
/*      if (recycling_center == DEFAULT_LOCATION) norecycle = 0;
      else */
    {
      fprintf (stderr, "Excluding all players in %s(%d)\n",
        db[recycling_center].name, recycling_center);
    }
  }
#endif

  /* Build translation table */
  build_trans ();
  fputs ("Done building translation table...\n", stderr);

  /* Scan everything */
  for (i = 0; i < db_top; i++)
    check_bad_exits (i);
  fputs ("Done checking bad exits...\n", stderr);

  for (i = 0; i < db_top; i++)
    check_owner (i);
  fputs ("Done checking owners...\n", stderr);

  for (i = 0; i < db_top; i++)
    check_location (i);
  fputs ("Done checking locations...\n", stderr);

  for (i = 0; i < db_top; i++)
    check_next (i);
  fputs ("Done checking next pointers...\n", stderr);

  for (i = 0; i < db_top; i++)
    check_contents (i);
  fputs ("Done checking contents...\n", stderr);

  for (i = 0; i < db_top; i++)
    check_exits (i);
  fputs ("Done checking homes and exits...\n", stderr);

/*    do_write();   */
  do_OIF_write ();
  fputs ("Done.\n", stderr);

  exit (0);
}

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

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

char *ofix (const char *ins)
{
  char foo[BUFSIZ];
  char *bar, *baz;

  strcpy (foo, ins);
  strcpy (buf, "");
  bar = foo;
  while ((baz = (char *) index (bar, '%')) != NULL) {
    *baz++ = '\0';
    strcat (buf, bar);
    switch (*baz) {
    case 's':
      strcat (buf, "$subv");
      break;
    case 'o':
      strcat (buf, "$objv");
      break;
    case 'p':
      strcat (buf, "$posv");
      break;
    case 'n':
      strcat (buf, "$nam");
    }
    bar = baz + 1;
  }
  strcat (buf, bar);
  return (buf);
}