#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "mud.h"

PLANE_DATA *first_plane, *last_plane;

void do_plist( CHAR_DATA * ch, char *argument )
{
  PLANE_DATA *p;

  send_to_char( "Planes:\n\r-------\n\r", ch );
  for( p = first_plane; p; p = p->next )
    ch_printf( ch, "%s\n\r", p->name );
  return;
}

void do_pstat( CHAR_DATA * ch, char *argument )
{
  PLANE_DATA *p;
  char arg[MAX_INPUT_LENGTH];

  argument = one_argument( argument, arg );
  if( !( p = plane_lookup( arg ) ) )
  {
    send_to_char( "Stat which plane?\n\r", ch );
    return;
  }
  ch_printf( ch, "Name: %s\n\r", p->name );
  return;
}

void do_pset( CHAR_DATA * ch, char *argument )
{
  PLANE_DATA *p;
  char arg[MAX_INPUT_LENGTH];
  char mod[MAX_INPUT_LENGTH];

  argument = one_argument( argument, arg );
  if( !*arg )
  {
    send_to_char( "Syntax: pset <plane> create\n\r", ch );
    send_to_char( "        pset save\n\r", ch );
    send_to_char( "        pset <plane> delete\n\r", ch );
    send_to_char( "        pset <plane> <field> <value>\n\r", ch );
    send_to_char( "\n\r", ch );
    send_to_char( "  Where <field> is one of:\n\r", ch );
    send_to_char( "    name\n\r", ch );
    return;
  }
  if( !str_cmp( arg, "save" ) )
  {
    save_planes(  );
    send_to_char( "Planes saved.\n\r", ch );
    return;
  }

  argument = one_argument( argument, mod );
  p = plane_lookup( arg );

  if( !str_prefix( mod, "create" ) )
  {
    if( p )
    {
      send_to_char( "Plane already exists.\n\r", ch );
      return;
    }
    CREATE( p, PLANE_DATA, 1 );
    p->name = STRALLOC( arg );
    LINK( p, first_plane, last_plane, next, prev );
    send_to_char( "Plane created.\n\r", ch );
    return;
  }
  if( !p )
  {
    send_to_char( "Plane doesn't exist.\n\r", ch );
    return;
  }
  if( !str_prefix( mod, "delete" ) )
  {
    UNLINK( p, first_plane, last_plane, next, prev );
    STRFREE( p->name );
    DISPOSE( p );
    check_planes( p );
    send_to_char( "Plane deleted.\n\r", ch );
    return;
  }
  if( !str_prefix( mod, "name" ) )
  {
    if( plane_lookup( argument ) )
    {
      send_to_char( "Another plane has that name.\n\r", ch );
      return;
    }
    STRFREE( p->name );
    p->name = STRALLOC( argument );
    send_to_char( "Name changed.\n\r", ch );
    return;
  }
  do_pset( ch, "" );
  return;
}

PLANE_DATA *plane_lookup( const char *name )
{
  PLANE_DATA *p;

  for( p = first_plane; p; p = p->next )
    if( !str_cmp( name, p->name ) )
      return p;
  for( p = first_plane; p; p = p->next )
    if( !str_prefix( name, p->name ) )
      return p;
  return NULL;
}

void save_planes( void )
{
  FILE *fp;
  PLANE_DATA *p;

  fclose( fpReserve );

  if( !( fp = fopen( PLANE_FILE, "w" ) ) )
  {
    perror( PLANE_FILE );
    bug( "save_planes: can't open plane file" );
    fpReserve = fopen( NULL_FILE, "r" );
    return;
  }
  for( p = first_plane; p; p = p->next )
  {
    fprintf( fp, "#PLANE\n" );
    fprintf( fp, "Name      %s\n", p->name );
    fprintf( fp, "End\n\n" );
  }
  fprintf( fp, "#END\n" );
  fclose( fp );
  fpReserve = fopen( NULL_FILE, "r" );
  return;
}

#ifdef KEY
#undef KEY
#endif

#define KEY( literal, field, value )					\
				if ( !strcmp( word, literal ) )	\
				{					\
				    field  = value;			\
				    fMatch = TRUE;			\
				    break;				\
				}

void read_plane( FILE * fp )
{
  PLANE_DATA *p;
  char *word;
  bool fMatch;

  CREATE( p, PLANE_DATA, 1 );
  for( ;; )
  {
    word = ( feof( fp ) ? "End" : fread_word( fp ) );
    fMatch = FALSE;

    switch ( UPPER( *word ) )
    {
      case 'E':
        if( !str_cmp( word, "End" ) )
        {
          if( plane_lookup( p->name ) )
          {
            bug( "read_plane: duplicate plane name!" );
            STRFREE( p->name );
            DISPOSE( p );
          }
          else
            LINK( p, first_plane, last_plane, next, prev );
          return;
        }
        break;
      case 'N':
        KEY( "Name", p->name, fread_string( fp ) );
        break;
    }
    if( !fMatch )
    {
      bug( "read_plane: unknown field '%s'", word );
      fread_to_eol( fp );
    }
  }
  return;
}

void load_planes( void )
{
  extern FILE *fpArea;
  extern char strArea[];
  char *word;

  if( !( fpArea = fopen( PLANE_FILE, "r" ) ) )
  {
    perror( PLANE_FILE );
    bug( "load_planes: can't open plane file for read." );
    return;
  }
  strcpy( strArea, PLANE_FILE );

  for( ; !feof( fpArea ); )
  {
    if( fread_letter( fpArea ) != '#' )
    {
      bug( "load_planes: # not found." );
      break;
    }
    word = fread_word( fpArea );
    if( !str_cmp( word, "END" ) )
      break;
    else if( !str_cmp( word, "PLANE" ) )
      read_plane( fpArea );
    else
    {
      bug( "load_planes: invalid section '%s'.", word );
      break;
    }
  }
  fclose( fpArea );
  fpArea = NULL;
  strcpy( strArea, "$" );
  return;
}

void build_prime_plane( void )
{
  PLANE_DATA *p;

  CREATE( p, PLANE_DATA, 1 );
  memset( p, 0, sizeof( *p ) );
  p->name = STRALLOC( "Prime Material" );
  LINK( p, first_plane, last_plane, next, prev );
  return;
}

void check_planes( PLANE_DATA * p )
{
  extern ROOM_INDEX_DATA *room_index_hash[];
  int vnum;
  ROOM_INDEX_DATA *r;

  if( !first_plane )
    build_prime_plane(  );

  for( vnum = 0; vnum < MAX_KEY_HASH; ++vnum )
    for( r = room_index_hash[vnum]; r; r = r->next )
      if( !r->plane || r->plane == p )
        r->plane = first_plane;
  return;
}