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

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

static hash_tab player_list[PLAYER_HASH_SIZE];

dbref lookup_player(const char *name)
{
  hash_data *hd;

  if ((hd = find_hash(name, player_list, PLAYER_HASH_SIZE)) == NULL)
    return NOTHING;
  else
    return (hd -> dbval);
}

dbref connect_player(const char *name, const char *password)
{
  dbref player;

  if((player = lookup_player(name)) == NOTHING) return NOTHING;
  if(DBFETCH(player)->sp.player.password
     && *DBFETCH(player)->sp.player.password
/*     && strcmp(DBFETCH(player)->sp.player.password, password)) return NOTHING;
 */
     && check_password(password, player)) return NOTHING;
  return player;
}

dbref create_player(const char *name, const char *password)
{
 dbref player;
 struct object *p;

 if (!ok_player_name(name) || !ok_password(password)) return(NOTHING);
 player = new_object(TYPE_PLAYER);
 p = DBFETCH(player);
 p->name = dup_string(name);
 p->location = PLAYER_START;
 p->nextowned = NOTHING;
 FLAGS(player) = TYPE_PLAYER;
#ifdef WIZARD_ALL
 FLAGS(player) |= WIZARD;
#endif
 p->owner = player;
 p->sp.player.home = PLAYER_START;
 p->sp.player.actions = NOTHING;
 p->sp.player.pennies = INITIAL_MONEY;
 p->sp.player.password = dup_string(password);
 p->sp.player.password = make_password(p->sp.player.password);
 p->sp.player.curr_prog = NOTHING;
 p->sp.player.insert_mode = 0;
 p->sp.player.proglocks = 0;
 p->sp.player.proglock_type = 0;
 p->sp.player.run = 0;
 p->sp.player.daemons = 0;
 p->sp.player.dbrefs_owned = 1;
 add_backlink(player,PLAYER_START);
 PUSH(player,DBFETCH(PLAYER_START)->contents);
 add_player(player);
 DBDIRTY(player);
 DBDIRTY(PLAYER_START);
 return(player);
}

void set_last(dbref player, const char *cmd)
{
 struct propref *pr;

 pr = lookup_property(player,".last",0);
 if (pr)
  { propref_set_type_and_value(pr,PTYPE_STRING,cmd);
    propref_done(pr);
  }
}

void do_password(dbref player, const char *old, const char *newobj)
{
 set_last(player,"@password");
 if (!DBFETCH(player)->sp.player.password || check_password(old,player))
  { int i;
    i = strlen(old);
    if ((i > 2) && (old[0] == '<') && (old[i-1] == '>'))
     { char *t;
       t = malloc(i-2+1);
       bcopy(old+1,t,i-2);
       t[i-2] = '\0';
       i = check_password(t,player);
       free(t);
       if (! i)
	{ notify(player,"No, without the < >.");
	  return;
	}
     }
    notify(player,"Sorry");
  }
 else if (!ok_password(newobj) || index(newobj,'='))
  { notify(player,"Bad new password.");
  }
 else
  { free(DBFETCH(player)->sp.player.password);
    DBSTORE(player,sp.player.password,dup_string(newobj));
    DBFETCH(player)->sp.player.password = make_password(DBFETCH(player)->sp.player.password);
    notify(player,"Password changed.");
  }
}

void clear_players(void)
{
 kill_hash(player_list,PLAYER_HASH_SIZE);
}

void delete_player(dbref who)
{
 free_hash(NAME(who),player_list,PLAYER_HASH_SIZE);
}

void add_player(dbref who)
{
 hash_data hd;

 hd.dbval = who;
 if (! add_hash(NAME(who),hd,player_list,PLAYER_HASH_SIZE)) panic("Out of memory");
}

int awake_count(dbref player)
{
 struct descriptor_data *d;
 int retval;

 retval = 0;
 for (d=descriptor_list;d;d=d->flink) if (d->connected && (d->player == player)) retval ++;
 return(retval);
}

void do_player_setuid(dbref player, const char *name, const char *pass)
{
 struct descriptor_data *d;
 dbref i;
 dbref new_player;
 char buf[BUFFER_LEN];

 set_last(player,"@user");
 new_player = lookup_player(name);
 if (new_player == NOTHING)
  { notify(player,"Invalid player name.  UID remains unchanged.");
    return;
  }
 if (! PERMIT_ATUSER(player,new_player))
  { notify(player,"Permission denied.");
    return;
  }
 if (awake_count(player) != 1)
  { notify(player,"Cannot set UID if you are connected more than once.");
    log_status("UID CHANGE: From %s to %s FAILED, multiple connects.",NAME(player),NAME(new_player));
    return;
  }
 if (awake_count(new_player) != 0)
  { notify(player,"Cannot set UID to that of a connected player.");
    log_status("UID CHANGE: From %s to %s FAILED, already connected.",NAME(player),NAME(new_player));
    return;
  }
 if ( ( !DBFETCH(new_player)->sp.player.password ||
	check_password(pass, new_player) ) &&
      !PERMIT_ATUSER_NOPW(player,new_player) )
  { notify(player,"Sorry");
    log_status("UID CHANGE: From %s to %s FAILED, BAD PASSWORD!",NAME(player),NAME(new_player));
  }
 else
  { for (d=descriptor_list;d;d=d->flink)
     { if (d->connected && (d->player == player)) d->player = new_player;
     }
    log_status("UID CHANGE: From %s to %s, successful.",NAME(player),NAME(new_player));
    notify(new_player,"UID changed.");
    sprintf(buf,"%s has setuid to %s.",NAME(player),NAME(new_player));
    for (i=0;i<db_top;i++)
     { if (TrueWizard(i) && (Typeof(i) == TYPE_PLAYER) && (FLAGS(i) & MONITOR))
	{ notify(i,buf);
	}
     }
   }
 return;
}