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

#ifdef WINDOWS
void bzero(char *spot, int len) {
	while (len>0) {*spot='\0'; len--; spot++;}
return;
}

void dostuff(int sk) {return;}
#endif

void do_repop (CHAR_DATA * ch, char *argy)
{
  AREA_DATA *a;
  char buf[STD_LENGTH];
  DEFINE_COMMAND ("repop", do_repop, POSITION_DEAD, MAX_LEVEL, LOG_NORMAL, "Shows you the state of zone repops.")
    hugebuf_o[0] = '\0';
  for (a = area_first; a != NULL; a = a->next)
    {
      sprintf (buf, "[%3d] %-30s \x1B[1;37m%3d\x1B[37;0m/\x1B[1;37m%-3d\x1B[37;0m\n\r",
	       a->vnum, a->name, a->repop_counter, a->repop_rate);
      strcat (hugebuf_o, buf);
    }
  page_to_char (hugebuf_o, ch);
  return;
}

void aedit (CHAR_DATA * ch, char *argy)
{
  AREA_DATA *pArea;
  AREA_DATA *Area;
  char arg[STD_LENGTH];
  char arg1[STD_LENGTH];
  char arg2[STD_LENGTH];
  char buf[STD_LENGTH];
  int value;

  pArea = (AREA_DATA *) ch->desc->pEdit;
  strcpy (arg, argy);
  smash_tilde (argy);
  argy = one_argy (argy, arg1);
  
  if (!IS_BUILDER (ch, pArea))
    {
      send_to_char ("You are not a builder in this area!\n\r", ch);
    }
  if (!str_cmp (arg1, "show") || arg_count (arg) == 0)
    {
      sprintf (buf, "%d", pArea->vnum);
      do_astat (ch, buf);
      return;
    }


  if (!str_cmp (arg1, "done"))
    {
      ch->desc->pEdit = NULL;
      ch->desc->connected = CON_PLAYING;
      return;
    }

  if (!str_cmp (arg1, "?"))
    {
      do_help (ch, "aedit");
      return;
    }


  if (!IS_BUILDER (ch, pArea))
    {
      interpret (ch, arg);
      return;
    }

  if (!str_cmp (arg1, "	rate") && is_number (arg2))
    {
      int i;
      argy = one_argy (argy, arg2);
      i = atoi (arg2);
      pArea->repop_rate = i;
      if (pArea->repop_counter > pArea->repop_rate)
	pArea->repop_counter = pArea->repop_rate;
      send_to_char ("Area repop rate set.\n\r", ch);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      return;
    }
  if (!str_cmp (arg1, "counter") && is_number (arg2))
    {
      int i;
      argy = one_argy (argy, arg2);
      i = atoi (arg2);
      pArea->repop_counter = i;
      if (pArea->repop_counter > pArea->repop_rate)
	pArea->repop_counter = pArea->repop_rate;
      send_to_char ("Area repop counter set.\n\r", ch);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      return;
    }
  if (!str_cmp (arg1, "message"))
    {
      if (pArea->repop)
        free_string (pArea->repop);
      pArea->repop = NULL;
      pArea->repop = str_dup (argy);
      send_to_char ("Area repop message set.\n\r", ch);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      return;
    }

  if ((value = area_name_bit (arg1)) != AREA_NONE)
    {
      sprintf (buf, "%s toggled %s.\n\r", capitalize(arg1), (pArea->area_flags & value ? "\x1B[1;30mOFF\x1B[0;37m" : "\x1B[1;37mON\x1B[0;37m"));
      send_to_char(buf, ch);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      pArea->area_flags ^= value;
      if (!str_cmp (arg1, "nuke"))
	save_area_list();
      return;
    }
  
  if (!str_cmp (arg1, "name"))
    {
      if (argy[0] == '\0')
	{
	  send_to_char ("Syntax: name <name>\n\r", ch);
	  return;
	}
      free_string (pArea->name);
      pArea->name = str_dup (argy);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      send_to_char ("Name set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg1, "align") || !str_cmp (arg1, "alignment"))
    {
      argy = one_argy (argy, arg2);
      if (!is_number (arg2))
	{
	  send_to_char ("Align <number>, 0 means neutral\n\r", ch);
	  return;
	}
      set_area_align (pArea, atoi (arg2), ch);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      send_to_char ("Alignment set.\n\r", ch);
      save_area_list ();
      return;
    }
  if (!str_cmp (arg1, "filename") || !str_cmp (arg1, "file"))
    {
      for (value = 0;value <= 12;value++)
         {
           if (argy[value] == '\0')
             {
               send_to_char ("\n\rSyntax: filename <areaname>.are\n\r", ch);
               return;
             }
           if (argy[value] == '.' && argy[value + 1] == 'a' && argy[value + 2] == 'r' && argy[value + 3] == 'e'
               && argy[value + 4] =='\0')
             {
               for (Area = area_first; Area != NULL; Area = Area->next)
                  {
                    if (!str_cmp(Area->filename, argy))
                      {
                        send_to_char ("\n\rAn other area already use this filename.\n\r", ch);
                        return;
                      }
                  }
               free_string (pArea->filename);
               pArea->filename = str_dup (argy);
               save_area (pArea);
               SET_BIT (pArea->area_flags, AREA_CHANGED);
               send_to_char ("Filename set.\n\r", ch);
               save_area_list ();
               return;
             }
         }
    }
  if (!str_cmp (arg1, "coord") || !str_cmp (arg1, "coords") ||
      !str_cmp (arg1, "coordinates"))
    {
      int xval; 
      int yval; 
      AREA_DATA *ar;
      argy = one_argy (argy, arg2);
      if (!is_number (arg2) || !is_number (argy))
	{
	  send_to_char ("Coords <xval> <yval>\n\r", ch);
	  return;
	}
      xval = atoi(arg2);
      yval = atoi(argy);
      if (xval < 1 || xval > 79 || yval < 1 || yval > 25)
	{
	  send_to_char ("The x-values must be between 1 and 79 and the y-values must be between 1 and 24.\n\r", ch);
	  return;
	}
      for (ar = area_first; ar != NULL; ar = ar->next)
	{
	  if (ar != pArea && ar->x == xval && ar->y == yval)
	    {
	      send_to_char("Another area already has those coordinates.\n\r", ch);
	      return;
	    }
	}
      pArea->x = xval;
      pArea->y = yval;
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      send_to_char ("Coordinates set.\n\r", ch);
      return;
    }
      
  if (!str_cmp (arg1, "security"))
    {
      argy = one_argy (argy, arg2);
      if (!is_number (arg2) || arg2[0] == '\0')
	{
	  send_to_char ("Syntax: security <level>\n\r", ch);
	  return;
	}
      value = atoi (arg2);
      pArea->security = value;
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      send_to_char ("Security set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "builder"))
    {
      argy = one_argy (argy, arg2);
      if (arg2[0] == '\0')
	{
	  send_to_char ("Syntax: builder <name toggle>\n\r", ch);
	  return;
	}
      arg2[0] = UPPER (arg2[0]);
      if (strstr (pArea->builders, arg2) != NULL)
	{
	  pArea->builders = string_replace (pArea->builders, arg2, "\0");
	  pArea->builders = string_unpad (pArea->builders);
	  SET_BIT (pArea->area_flags, AREA_CHANGED);
	  send_to_char ("Builder removed.\n\r", ch);
	  return;
	}
      else
	{
	  buf[0] = '\0';
	  if (pArea->builders[0] != '\0')
	    {
	      strcat (buf, pArea->builders);
	      strcat (buf, " ");
	    }
	  strcat (buf, arg2);
	  free_string (pArea->builders);
	  pArea->builders = string_proper (str_dup (buf));
	  SET_BIT (pArea->area_flags, AREA_CHANGED);
	  send_to_char ("Builder added.\n\r", ch);
	  return;
	}
    }

  if (!str_cmp (arg1, "vnum"))
    {
      argy = one_argy (argy, arg2);
      if (!is_number (argy) || argy[0] == '\0'
	  || !is_number (arg2) || arg2[0] == '\0')
	{
	  send_to_char ("Syntax: vnum <lower> <upper>\n\r", ch);
	  return;
	}
      if (atoi(arg2) > atoi(argy))
        {
          send_to_char ("Lower vnums must have a lower value than upper vnum.\n\r", ch);
          return;
        }
      value = atoi (arg2);
      if (get_vnum_area (value) != NULL
	  && get_vnum_area (value) != pArea)
	{
	  send_to_char ("Lower vnum already assigned.\n\r", ch);
	  return;
	}
      pArea->lvnum = value;
      send_to_char ("Lower vnum set.\n\r", ch);
      value = atoi (argy);
      if (get_vnum_area (value) != NULL
	  && get_vnum_area (value) != pArea)
	{
	  send_to_char ("Upper vnum already assigned.\n\r", ch);
	  return;
	}
      pArea->uvnum = value;
      send_to_char ("Upper vnum set.\n\r", ch);
      SET_BIT (pArea->area_flags, AREA_CHANGED);
      return;
    }

  interpret (ch, arg);
  return;
}


void
soc_edit (CHAR_DATA * ch, char *argy)
{
  SOCIAL *s;
  char arg[STD_LENGTH];
  char arg1[STD_LENGTH];
  char arg2[STD_LENGTH];

  s = (SOCIAL *) ch->desc->pEdit;
  strcpy (arg, argy);
  smash_tilde (argy);
  argy = one_argy (argy, arg1);
  strcpy (arg2, argy);

  if (!str_cmp (arg1, "show") || arg_count (arg) == 0)
    {
      show_social (s, ch);
      return;
    }

  if (!str_cmp (arg1, "done"))
    {
      ch->desc->pEdit = NULL;
      ch->desc->connected = CON_PLAYING;
      social_update_hash ();
      save_new_socials ();
      return;
    }

  if (!str_cmp (arg1, "create"))
    {
      social_update_hash ();
      s = new_social ();
      strcpy (s->name, "none");
      ch->desc->pEdit = s;
      send_to_char ("Social created.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "name"))
    {
      if (strlen (arg2) < 20)
	{
	  send_to_char ("Name set.\n\r", ch);
	  strcpy (s->name, arg2);
	}
      return;
    }

  if (!str_cmp (arg1, "to_char"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->char_no_arg);
	  s->char_no_arg = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->char_no_arg);
      s->char_no_arg = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "to_others"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->others_no_arg);
	  s->others_no_arg = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->others_no_arg);
      s->others_no_arg = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "char_found"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->char_found);
	  s->char_found = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->char_found);
      s->char_found = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "others"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->others_found);
	  s->others_found = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->others_found);
      s->others_found = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "to_vict"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->vict_found);
	  s->vict_found = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->vict_found);
      s->vict_found = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "char_not"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->char_not_found);
	  s->char_not_found = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->char_not_found);
      s->char_not_found = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "char_self"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->char_auto);
	  s->char_auto = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->char_auto);
      s->char_auto = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg1, "others_self"))
    {
      if (arg2[0] == '\0')
	{
	  free_string (s->others_auto);
	  s->others_auto = NULL;
	  send_to_char ("Field cleared.\n\r", ch);
	  return;
	}
      free_string (s->others_auto);
      s->others_auto = str_dup (arg2);
      send_to_char ("Field set.\n\r", ch);
      return;
    }
  interpret (ch, arg);
  return;
}