/* This software is Copyright 1989, 1990, 1992, 1993 by various individuals.
   Please see the accompanying file COPYRIGHT for details. */

/* Predicates for testing various conditions */

#include <stdarg.h>

#include "db.h"
#include "defs.h"
#include "ctype.h"
#include "config.h"
#include "params.h"
#include "externs.h"
#include "strings.h"
#include "interface.h"

int can_link_to(dbref who, object_flag_type what_type, dbref where)
{
 if (where == HOME) return(1);
 if (where == BUILTIN) return(1);
 if ((where < 0) || (where > db_top)) return(0);
 switch (what_type)
  { case TYPE_EXIT:
       return(controls(who,where)||(FLAGS(where)&LINK_OK));
       break;
    case TYPE_PLAYER:
       return( (Typeof(where) == TYPE_ROOM) &&
	       (controls(who,where)||Linkable(where)) );
       break;
    case TYPE_ROOM:
       return( ( (Typeof(where) == TYPE_ROOM) ||
		 (Typeof(where) == TYPE_PLAYER) ||
		 (Typeof(where) == TYPE_PROGRAM) ) &&
	       ( controls(who,where) ||
		 Linkable(where) ) );
       break;
    case TYPE_THING:
       return ( ( (Typeof(where) == TYPE_ROOM) ||
		  (Typeof(where) == TYPE_PLAYER) ) &&
		( controls(who,where) ||
		  Linkable(where) ) );
       break;
    case NOTYPE:
       return( controls(who,where) ||
	       (FLAGS(where) & LINK_OK) ||
	       ( (Typeof(where) != TYPE_PLAYER) &&
		 (FLAGS(where) & ABODE) ) );
       break;
  }
 return(0);
}

int can_link(dbref who, dbref what)
{
 return(controls(who,what));
}

int could_doit(dbref player, dbref thing)
{
 if ((Typeof(thing) == TYPE_EXIT) && (DBFETCH(thing)->sp.exit.ndest == 0))
  { return(0);
  }
 return(eval_boolexp(player,player,DBFETCH(thing)->key,thing));
}

int can_doit(dbref player, dbref thing, const char *default_fail_msg)
{
 dbref loc;
 char buf[BUFFER_LEN];

 loc = getloc(player);
 if (loc == NOTHING) return(0);
 if (! could_doit(player,thing))
  { /* can't do it */
    if (DBFETCH(thing)->fail_message != NOSTR)
     { SERIAL thingser;
       SERIAL playser;
       thingser = DBFETCH(thing)->serial;
       playser = DBFETCH(player)->serial;
       exec_or_notify_str(player,thing,DBFETCH(thing)->fail_message);
       if ( (DBFETCH(thing)->serial != thingser) ||
	    (DBFETCH(player)->serial != playser) ) return(0);
     }
    else if (default_fail_msg)
     { notify(player,default_fail_msg);
     }
    if (! Dark(player))
     { if (DBFETCH(thing)->ofail != NOSTR)
	{ sprintf(buf,"%s %s",NAME(player),pronoun_substitute_str(player,DBFETCH(thing)->ofail));
	  notify_except(player,loc,player,buf);
	}
       else
	{ const char *def;
	  def = find_default_msg(0,thing,"ofail");
	  if (def)
	   { sprintf(buf,"%s %s",NAME(player),pronoun_substitute(player,def));
	     cfree(def);
	     notify_except(player,loc,player,buf);
	   }
	}
     }
    return(0);
  }
 else
  { /* can do it */
    if (DBFETCH(thing)->succ_message != NOSTR)
     { SERIAL thingser;
       SERIAL playser;
       thingser = DBFETCH(thing)->serial;
       playser = DBFETCH(player)->serial;
       exec_or_notify_str(player,thing,DBFETCH(thing)->succ_message);
       if ( (DBFETCH(thing)->serial != thingser) ||
	    (DBFETCH(player)->serial != playser) ) return(0);
     }
    else
     { const char *def;
       def = find_default_msg(0,thing,"succ");
       if (def)
	{ SERIAL thingser;
	  SERIAL playser;
	  thingser = DBFETCH(thing)->serial;
	  playser = DBFETCH(player)->serial;
	  exec_or_notify(player,thing,def);
	  cfree(def);
	  if ( (DBFETCH(thing)->serial != thingser) ||
	       (DBFETCH(player)->serial != playser) ) return(0);
	}
     }
    if ((DBFETCH(thing)->osuccess != NOSTR) && !Dark(player))
     { sprintf(buf,"%s %s",NAME(player),pronoun_substitute_str(player,DBFETCH(thing)->osuccess));
       notify_except(player,loc,player,buf);
     }
    return(1);
  }
}

int can_see(dbref player, dbref thing, int can_see_loc)
{
 if ( (player == thing) ||
      (Typeof(thing) == TYPE_EXIT) ||
      ( (Typeof(thing) == TYPE_ROOM) &&
	!(FLAGS(thing) & INCONTENTS) ) ) return(0);
 if (can_see_loc)
  { switch (Typeof(thing))
     { case TYPE_PROGRAM:
       case TYPE_DAEMON:
	  return((FLAGS(thing) & LINK_OK) || controls(player,thing));
	  break;
       case TYPE_ROOM:
	  return(1);
	  break;
       default:
	  return(!Dark(thing) || controls(player,thing));
	  break;
     }
  }
 else
  { /* can't see loc */
#ifndef SILENT_PLAYERS
    return(controls(player,thing));
#else  /* SILENT_PLAYERS */
    return((FLAGS(player)&SILENT)?0:controls(player,thing));
#endif
  }
}

int controls(dbref who, dbref what)
{
  if (what < 0 || what >= db_top) return 0;
  if (Typeof(what) == TYPE_GARBAGE) return 0;
  if (Royalty(who)) return 1;
  return (who == OWNER(what));
}

/* implements @set restrictions */
int restricted(dbref player, dbref thing, object_flag_type flag)
{
 switch (flag)
  { case DARK:
       return(!PERMIT_SETDARK(player,thing));
       /*NOTREACHED*/
       break;
#ifndef MUCKER_ALL
    case MUCKER:
       return (!PERMIT_SETMUCKER(player,thing));
       /*NOTREACHED*/
       break;
#endif /* MUCKER_ALL */
#ifdef RESTRICTED_BUILDING
    case BUILDER:
       return (!PERMIT_SETBUILDER(player,thing));
       /*NOTREACHED*/
       break;
#endif /* RESTRICTED_BUILDING */
    case ROYALTY:
       return(!PERMIT_SETROYAL(player,thing));
       /*NOTREACHED*/
       break;
    case WIZARD:
       return(!PERMIT_SETWIZARD(player,thing));
       /*NOTREACHED*/
       break;
    case QUELL:
       return(!PERMIT_SETQUELL(player,thing));
       /*NOTREACHED*/
       break;
    case UNSEEN:
       return(!PERMIT_SETUNSEEN(player,thing));
       /*NOTREACHED*/
       break;
    case GOD:
       return(!PERMIT_SETGOD(player,thing));
       /*NOTREACHED*/
       break;
    case TAP:
       return(!PERMIT_SETTAP(player,thing));
       /*NOTREACHED*/
       break;
    case INTERACTIVE:
       switch (Typeof(thing))
	{ case TYPE_ROOM: case TYPE_EXIT: break;
	  default: return(1); break;
	}
       break;
    case FFLAG:
       return(!PERMIT_SETFBIT(player,thing));
       break;
    case KFLAG:
       return(!Wizard(player));
       break;
    case EFLAG: case PFLAG:
       return( !Wizard(player) &&
	       (Typeof(thing) != TYPE_EXIT) );
       break;
    case CFLAG: case XFLAG: case YFLAG: case ZFLAG:
       return(!Wizard(player));
       break;
  }
 return(0);
}

int payfor(dbref who, int cost, const char *fmt, ...)
{
 va_list ap;

 if (Wizard(who) || (cost < 1))
  { return(1);
  }
 else if (DBFETCH(who)->sp.player.pennies >= cost)
  { char buf[256];
    DBFETCH(who)->sp.player.pennies -= cost;
    DBDIRTY(who);
    va_start(ap,fmt);
    vsprintf(&buf[0],fmt,ap);
    va_end(ap);
    log_money("%d %d [%s]",(int)who,-cost,&buf[0]);
    return(1);
  }
 else
  { return(0);
  }
}

void add_pennies(dbref who, int amt, const char *fmt, ...)
{
 va_list ap;
 char buf[256];

 if (amt == 0) return;
 DBFETCH(who)->sp.player.pennies += amt;
 DBDIRTY(who);
 va_start(ap,fmt);
 vsprintf(&buf[0],fmt,ap);
 va_end(ap);
 log_money("%d %d [%s]",(int)who,amt,&buf[0]);
}

static int word_start (const char *str, const char let)
{
  int chk;

  for (chk = 1; *str; str++) {
    if (chk && *str == let) return 1;
    chk = *str == ' ';
  }
  return 0;
}

int ok_name(const char *name)
{
  return (name
          && *name
          && *name != LOOKUP_TOKEN
          && *name != NUMBER_TOKEN
          && !index(name, ARG_DELIMITER)
          && !index(name, AND_TOKEN)
          && !index(name, OR_TOKEN)
          && !word_start(name, NOT_TOKEN)
          && string_compare(name, "me")
          && string_compare(name, "here"));
}

int ok_player_name(const char *name)
{
  const char *scan;

  if(!ok_name(name) || strlen(name) > PLAYER_NAME_LIMIT) return 0;

  for(scan = name; *scan; scan++) {
    if(!(Cisprint(*scan) && !Cisspace(*scan))) { /* was isgraph(*scan) */
      return 0;
    }
  }

  /* lookup name to avoid conflicts */
  return (lookup_player(name) == NOTHING);
}

int ok_password(const char *password)
{
 const char *scan;

 if (*password == '\0') return(0);
 for (scan=password;*scan;scan++)
  { if (! (Cisprint(*scan) && !Cisspace(*scan))) return(0);
  }
 return(1);
}

int ok_prop_name(const char *pn)
{
 if (index(pn,PROP_DELIMITER)) return(0);
 return(1);
}