#include "move_failures.h"
inherit "/std/object";
#ifdef 0
  inherit "/std/basic/cute_look";
#else
  string number_as_string(int n)
{
  string ret;

  if (!n) return "zero";
  if (n<20 && n>9) return ({ "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" })[n-10];
  ret = ({ "", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"})[n/10];
  if ((n = n%10)&&(ret!="")) ret += " ";
  return ret + ({ "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"})[n];
}

mixed query_inventory(object *obs)
/*
 * returns an array of the form:
 * ({
 *   ({
 *     "foo",
 *     "bing",
 *   }),
 *   ({
 *     ({ <list of living objects with short "foo"> }),
 *     ({ <ditto for short "bing"> }),
 *   }),
 *   ({
 *     "s1",
 *     "s2",
 *   }),
 *   ({
 *     ({ <list of pointers to objects that have a short of "s1"> }),
 *     ({ <ditto for objects with a short of "s2"> }),
 *   }),
 *   ({ <pointers to invisible objects> }),
 * })
 * The first two arrays contain living objects, the second two contain
 * the rest, the last contains the pointers to invisible objects.
 * NB: this_player() is _not_ included in the array if (s)he is present.
 */
{
  mixed inv;
  object ob;
  mixed desc;
  int i,j,z;

  inv = ({ ({ }), ({ }), ({ }), ({ }), ({ }), });
  if (!obs) obs = all_inventory(this_object());
  for (z = sizeof(obs)-1; z >= 0;z--)
  {
    ob = obs[z];
    if (!(desc = (string)ob->pretty_short()) || (desc == ""))
    {
      inv[4] += ({ ob });
      continue;
    }
    if (pointerp(desc))
    {
      if (living(ob))
      {
        if (ob == this_player()) continue;
        for (j=0;j<sizeof(desc);j++)
          if ((i = member_array(desc[j], inv[0])) >=0)
            inv[1][i] += ({ ob });
          else
          {
            inv[0] += ({ desc[j] });
            inv[1] += ({ ({ ob }), });
          }
        continue;
      }
      for (j=0;j<sizeof(desc);j++)
        if ((i = member_array(desc[j], inv[2])) >= 0)
          inv[3][i] += ({ ob });
        else
        {
          inv[2] += ({ desc[j] });
          inv[3] += ({ ({ ob }) });
        }
      continue;
    }
    if (living(ob))
    {
      if (ob == this_player()) continue;
      if ((i = member_array(desc, inv[0])) >= 0)
      {
        inv[1][i] += ({ ob });
        continue;
      }
      inv[0] += ({ desc });
      inv[1] += ({ ({ ob }), });
      continue;
    } 
    if ((i = member_array(desc, inv[2])) >= 0)
    {
      inv[3][i] += ({ ob });
      continue;
    }
    inv[2] += ({ desc });
    inv[3] += ({ ({ ob }), });
  }
  return inv;
}

string query_num(int n, int limit)
{
  string ret;
  int i;

  if (limit && n>limit) return "many";
  if (n < 0) return "many"; /* for integer wraps... */
  if (n > 99999) return "many"; /* hard limit */
  ret = 0;
  if ((i = n/1000))
  {
    n = n%1000;
    if (!n) return number_as_string(i) + " thousand";
    ret = number_as_string(i) + " thousand";
  }
  if ((i = n/100))
  {
    n = n%100;
    if (ret)
    {
      if (!n) return ret + " " + number_as_string(i) + " hundred";
      ret += ", " + number_as_string(i) + " hundred";
    }
    else
    {
      if (!n) return number_as_string(i) + " hundred";
      ret = number_as_string(i) + " hundred";
    }
  }
  if (ret) return ret + " and " + number_as_string(n);
  return number_as_string(n);
}

varargs string query_contents(string str, object *obs)
{
  int i, j;
  mixed inv;
  string ret;

  ret = "";
  inv = query_inventory(obs);
  if (!sizeof(inv[0]) && !sizeof(inv[2])) return ret;
  if (str) ret += str;
  str = " is";
  if (sizeof(inv[0]) > 1) str = " are";
  for (i=sizeof(inv[0])-1; i >= 0; i--)
  {
    if (inv[0][i][0] < '0' && inv[0][i][0] > '9')
         j = sizeof(inv[1][i]);
    if (j > 1)
    {
      ret += capitalize(query_num(j, 0)) + " " +
             inv[1][i][0]->pretty_plural(inv[0][i]);
      str = " are";
    }
    else
      ret += capitalize(inv[0][i]);
    if (!i)
    {
      ret += str + " here.\n";
      break;
    } 
    if (i == 1)
    {
      ret += " and ";
      continue;
    }
    ret += ", ";
  }
  for (i=sizeof(inv[2])-1; i>=0; i--)
  {
      j = sizeof(inv[3][i]);
    if (j > 1)
    {
      ret += capitalize(query_num(j,20)) + " " +
             capitalize((string)inv[3][i][0]->pretty_plural(inv[2][i])) + ".\n";
      continue;
    }
    ret += capitalize(inv[2][i]) + ".\n";
  }
  return ret;
}

void list_contents(string str) { write(query_contents(str)); }
#endif

#define MAX_INVENT 40
#define C_CLOSED 1
#define C_TRANS 2
#define C_OPAQUE 1

static int max_weight;
static int loc_weight;
static int prevent_insert;

void create()
{
#ifdef 0
  object::create();
#else
  ::create();
#endif
}

void set_max_weight(int arg) { max_weight = arg; }
int query_max_weight() { return max_weight; }
int query_loc_weight() { return loc_weight; }

int add_weight(int n) {
  int old, new;

  if (::add_weight(n)) return 1;
  if (!max_weight) return 1;
  if (n + loc_weight > max_weight) return 0;
  loc_weight += n;
  return 1;
} /* add_weight() */

int transfer_all_to(object dest) {
  object *ob;
  int i;
 
  ob = all_inventory(this_object());
  for (i=0;i<sizeof(ob);i++)
    ob[i]->move(dest);
  if (first_inventory(this_object())) return 0;
  return 1;
} /* transfer_all_to() */

/* ok modifyed back to using writes... */
string long(string str, int dark) {
  string ret;

  ret = ::long(str);
  ret += calc_extra_look();
  if(this_object()->query_corpse())
    ret += (string)this_object()->query_living_contents(0);
  else
    ret += query_contents(short(dark)+" contains:\n", all_inventory() - 
                          query_labels());
  return ret;
} /* long() */

int test_remove(object ob, int flag) { return 1; }
int test_add(object ob, int flag) { return 1; }
int set_prevent_insert() { prevent_insert = 1; }
int reset_prevent_insert() { prevent_insert = 0; }
int query_prevent_insert() { return prevent_insert; }

varargs int move(mixed dest, mixed messin, mixed messout) {
  if (prevent_insert && loc_weight && !living(dest) && environment(dest))
    return MOVE_INVALID_DEST;
  return (int)::move(dest, messin, messout);
}

object *find_inv_match(string str) {
  return all_inventory(this_object());
} /* find_inv_match() */

mixed stats()
{
  return ::stats() + ({
    ({ "loc_weight", query_loc_weight(), }),
    ({ "max_weight", query_max_weight(), }),
  });
} /* stats() */

mixed *query_init_data()
{
  return ::query_init_data() + ({
         "max weight", max_weight, "set_max_weight",
         "prevent insert", prevent_insert, "set_prevent_insert",
         });
} /* query_init_data() */

mapping int_query_static_auto_load()
{
  int tmp;

  tmp = ::int_query_static_auto_load();
  return ([ "::" : tmp, "max weight" : max_weight,
            "prevent insert" : prevent_insert,
    ]);
} /* int_query_static_auto_load() */

mapping query_dynamic_auto_load() {
  return ([ "::" : ::query_dynamic_auto_load(),
            "inv" : 
         "/global/player"->create_auto_load(all_inventory(this_object())-labels),
         ]);
} /* query_dynamic_auto_load() */

void init_dynamic_arg(mapping bing) {
  if (bing["::"])
    ::init_dynamic_arg(bing["::"]);
  if (bing["inv"])
    "/global/player"->load_auto_load(bing["inv"], this_object());
} /* init_dynamic_arg() */

void init_static_arg(mapping bing) {
  if (bing["::"])
     ::init_static_arg(bing["::"]);
  if (!undefinedp(bing["max weight"]))
    max_weight = bing["max weight"];
  if (!undefinedp(bing["prevent insert"]))
    prevent_insert = bing["prevent insert"];
} /* init_static_arg() */

mixed query_static_auto_load() {
  if (file_name(this_object())[0..13] == "/std/container")
    return int_query_static_auto_load();
  return ([ ]);
} /* query_static_auto_load() */

void dest_me() {
  object *obs;
  int i;

  obs = deep_inventory(this_object());
  for (i=0;i<sizeof(obs);i++)
    obs[i]->dest_me();
  ::dest_me();
} /* dest_me() */