#include <sys/resource.h>
#include <sys/signal.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include "kernel.h"
#include "locations.h"
#include "climate.h"
#include "bprintf.h"
#include "sendsys.h"
#include "timing.h"
#include "mobile.h"
#include "cflags.h"
#include "objsys.h"
#include "spell.h"
#include "rooms.h"
#include "log.h"
#include "mud.h"

#define  SECS_IN_A_MIN          60
#define  SECS_IN_AN_HOUR        (SECS_IN_A_MIN*60)
#define  SECS_IN_A_DAY          (SECS_IN_AN_HOUR*24)
#define  SECS_IN_A_WEEK         (SECS_IN_A_DAY*7)

#define  WARNING_1  15		/* Minutes before closing time to give warnings.  */
#define  WARNING_2   3		/* Only used if the mud is not open 24 hrs. a day */

#define NUM_INTERV 30

static int wrap = 0;		/* Number of times we wrap around */
int intervals = 0;
struct tm open_times[NUM_INTERV];

#define MUD_ALWAYS   0
#define MUD_OPEN     1
#define MUD_WARNING1 2
#define MUD_WARNING2 3
#define MUD_CLOSED   (-1)

int open_state = MUD_OPEN;
int wrap_point = -1;

/************************************************************************
 * 									*
 *  "DIRT"'s system for controlling it's opening and closing times.     *
 *									*
 *  mud_open() is called. It reads DATA/hours and returns true if mud   *
 *  is open, false if not. Read DATA/=README= for the format. The       *
 *  opening time (if closed) or closing time (if open) is placed in     *
 *  the global variable 'next_event' and checked regularly. Two         *
 *  warnings are given before the players are kicked off at closing     *
 *  time.								*
 ***********************************************************************/

time_t next_event;		/* closing time if open, opening time if closed. */


/* Return True if the time represented by a is later then that of b :
 * This procedure is to be used by the boot, where one and only one
 * interval may be later so one occurence should return true,
 * remaining false.
 * (We are only using the day, hour and min fields in tm.)
 */
static Boolean
blater (struct tm *a, struct tm *b)
{

  if (a->tm_wday > b->tm_wday ||
      (a->tm_wday == b->tm_wday && a->tm_hour > b->tm_hour) ||
      (a->tm_wday == b->tm_wday && a->tm_hour == b->tm_hour &&
       a->tm_min > b->tm_min))
    return True;

  ++wrap;
  if (wrap_point >= 0)
    return False;

  wrap_point = a - open_times;

  return True;
}

/* Return True if the time represented by a is later then that of b :
 * (We are only using the day, hour and min fields in tm.)
 */
static Boolean
later (struct tm *a, struct tm *b)
{

  if (a->tm_wday > b->tm_wday ||
      (a->tm_wday == b->tm_wday && a->tm_hour > b->tm_hour) ||
      (a->tm_wday == b->tm_wday && a->tm_hour == b->tm_hour &&
       a->tm_min > b->tm_min))
    return True;

  return False;
}


/* Return True if the time t occurs after a and before b, (between a and b).
 */
static Boolean
between (struct tm *t, struct tm *a, struct tm *b)
{
  return (later (a, b) ? !between (t, b, a) : later (t, a) && !later (t, b));
}


/* Return the time difference between two events in seconds.
 */
static time_t
diff (struct tm *from, struct tm *to)
{
  if (later (from, to))
    return (SECS_IN_A_WEEK - diff (to, from));
  else
    return ((to->tm_wday - from->tm_wday) * SECS_IN_A_DAY +
	    (to->tm_hour - from->tm_hour) * SECS_IN_AN_HOUR +
	    (to->tm_min - from->tm_min) * SECS_IN_A_MIN);
}


static int
next_time (struct tm *now)
{
  struct tm *u;
  int x;

  for (x = 0, u = open_times; x < intervals; x++, u++) {
    if (later (u, now))
      break;
  }
  if (x == 0) {
    now->tm_wday += 7;
    for (x = 0, u = open_times; x < intervals; x++, u++) {
      if (later (u, now))
	break;
    }
    now->tm_wday -= 7;
  }
  if (x == intervals)
    x = 0;
  return x;
}

static Boolean
ok_week_time (struct tm *t, char *d, char *fname, int lineno)
{
  static char *wdays[] =
  {"Sunday", "Monday", "Tuesday", "Wednesday",
   "Thursday", "Friday", "Saturday", TABLE_END};

  int x;

  if ((x = tlookup (d, wdays)) < 0) {
    printf ("%s:%d - No such day: %s\n", fname, lineno, d);
    return False;
  }
  t->tm_wday = x;
  if (t->tm_hour < 0 || t->tm_hour >= 24 || t->tm_min < 0 || t->tm_min >= 60) {
    printf ("%s:%d -  Illegal time: %d:%d\n",
	    fname, lineno, t->tm_hour, t->tm_min);
    return False;
  }
  return True;
}

static Boolean
is_later (struct tm *b, struct tm *a,
	  char *fname, int lineno, int x)
{
  if (blater (b, a))
    return True;
  mudlog ("ERROR: %s:%d - Illegal format %s \'->\', not increasing times.",
	  fname, lineno, (x == 0) ? "before" : "after");
  return False;
}

/* If AberMUD is open, return True and the closing-time in the variable
 * pointed to by next_ev (global UNIX time). If the game is closed,
 * return False, and the opening time in the variable pointed to by next_ev.
 */
Boolean
mud_open (time_t * next_ev, time_t * current_time)
{
  struct tm *tm_now;
  int ct;
  time_t now = *current_time;

  now = round_to_min (now);
  tm_now = localtime (&now);

  if (intervals > 0) {
    ct = next_time (tm_now);
    *next_ev = now + diff (tm_now, open_times + ct);
    return ODD (ct);
  } else {
    *next_ev = TIME_NEVER;
    return True;
  }
}

static int
xboot_times (FILE * f, char *fname)
{
  struct tm *i = open_times;
  FILE *fl;
  char dnamefrom[20];
  char dnameto[20];
  char b[256];
  int status, ct = 0, lineno = 0;


  if ((fl = f) == NULL && (fl = fopen (fname, "r")) == NULL) {
    intervals = 0;
    next_event = TIME_NEVER;
    open_state = MUD_ALWAYS;
    return 0;
  }
  while (fgets (b, sizeof b, fl)) {
    lineno++;
    if (ct >= NUM_INTERV) {
      printf ("%s:%d - Too many intervals in hours file.\n",
	      fname, lineno);
      fclose (fl);
      return -1;
    }
    status = sscanf (b, "%s %d:%d %*s %s %d:%d\n",
		     dnamefrom, &i->tm_hour, &i->tm_min,
		     dnameto, &i[1].tm_hour, &i[1].tm_min);
    if (status <= 0)
      continue;
    if (status != 6) {
      fclose (fl);
      printf ("status == %d\n", status);
      printf ("%s:%d - Illegal format in hours file: %s", fname, lineno, b);
      return -1;
    }
    if (!ok_week_time (i, dnamefrom, fname, lineno)
	|| ((ct > 0) && !is_later (i, i - 1, fname, lineno, 0))
	|| !ok_week_time (++i, dnameto, fname, lineno)
	|| !is_later (i, i - 1, fname, lineno, 1)) {
      fclose (fl);

      return -1;
    }
    ct += 2;
    ++i;
  }
  if (!is_later (open_times, i - 1, fname, 1, 0)) {
    fclose (fl);
    return -1;
  }
  if (wrap != 1) {
    printf ("%s:%d - hours file should wrap once.\n", fname, lineno);
    fclose (fl);
    return -1;
  }
  if (!feof (fl)) {
    printf ("%s:%d [%d]%s\n", fname, lineno, errno, sys_errlist[errno]);
    fclose (fl);
    return -1;
  }
  if (f == NULL)
    fclose (fl);
  intervals = ct;
  for (ct = wrap_point; ct < intervals; ct++) {
    open_times[ct].tm_wday += 7;
  }
  return 0;
}

int
boot_hours (FILE * f, char *fname)
{
  int k;
  time_t now = time (NULL);

  if ((k = xboot_times (f, fname)) < 0) {
    intervals = 0;
    next_event = TIME_NEVER;
    open_state = MUD_ALWAYS;
  } else if (open_state == MUD_ALWAYS)
    return k;
  else if (mud_open (&next_event, &now))
    open_state = MUD_OPEN;
  else
    open_state = MUD_CLOSED;

  return k;
}


/* Check if closing time has arrived. If so, kick everyone off (except
 * the 'masteruser' if he is on). Give 2 warnings ahead of time.
 */
static void
check_if_closed (time_t * now)
{
  int time_left;

  if (next_event == TIME_NEVER)
    return;

  time_left = next_event - *now;

  switch (open_state) {
  case MUD_ALWAYS:
    return;
  case MUD_OPEN:
    if (time_left < WARNING_1 * SECS_IN_A_MIN) {
      bprintf ("  MUD is closing in %s.\a\n",
	       sec_to_str (round_to_min (time_left)));
      open_state = MUD_WARNING1;
    }
    break;
  case MUD_WARNING1:
    if (time_left < WARNING_2 * SECS_IN_A_MIN) {
      bprintf ("  MUD is closing in %s.\a\n",
	       sec_to_str (round_to_min (time_left)));
      open_state = MUD_WARNING2;
    }
    break;
  case MUD_WARNING2:
    if (time_left < 0) {
      broad ("\t\tMUD has closed. Thank you for playing...");
      open_state = MUD_CLOSED;
      if (mud_open (&next_event, now)) {
	mudlog ("ERROR: mud_open is not False");
      }
    }
    break;
  case MUD_CLOSED:
    if (time_left < 0) {
      open_state = MUD_OPEN;
      if (!mud_open (&next_event, now)) {
	mudlog ("ERROR: mud_open is not True");
      }
    }
  }
}


/* Return a pointer to a string containing the a date, without the \n
 * supplied by ctime(3). If the argument is 0, use the current local time.
 */
char *
time2ascii (time_t t)
{
  char *str;

  if (t == 0)
    t = global_clock;

  *strchr ((str = ctime (&t)), '\n') = '\0';

  return (t == TIME_UNAVAIL) ? "Not Available" : str;
}


/* The TIME command. List game time elapsed, current time, last reset
 * and closing time if applicable.
 */
void
timecom (void)
{
  bprintf ("Elapsed Time : ");
  eltime ();
  bprintf ("Current Time : %s\n", time2ascii (TIME_CURRENT));
  bprintf ("Last Reset   : %s\n", ctime (&last_reset));

  bprintf ("Last Healall : %s",
	   last_healall != last_startup ?
	   ctime (&last_healall) : "Never\n");

  bprintf ("Time to Next : %s\n",
	   HEALALL_TIME ?
	   time2ascii (global_clock - last_healall + HEALALL_TIME) :
	   "No Time Limit Has Been Set.");

  if (next_event != TIME_NEVER) {
    bprintf ("Closing Time : %s\n", time2ascii (next_event));
  }
}

void
uptimecom (void)
{
  bprintf ("Elapsed Time      : %s\n", sec_to_str (global_clock - last_startup));
  bprintf ("Been Up Since     : %s", ctime (&last_startup));
  bprintf ("Number of Resets  : %d\n", numresets);
  bprintf ("Number of Reboots : %d\n", numreboots);
  bprintf ("Recovered Crashes : %d\n", numcrashes);
}

/* Prints the game time elapsed. Called by timecom() and main.
 */
void
eltime (void)
{
  long int et;

  switch (et = gametime ()) {
  case TIME_NEVER:
    bprintf ("AberMUD has yet to ever start!");
    break;
  case TIME_UNAVAIL:
    bprintf ("Current time is unavailable!");
    break;
  default:
    if (et > SECS_IN_A_DAY)
      bprintf ("Over a day!");
    else
      bprintf ("%s", sec_to_str (et));
    break;
  }
  bprintf ("\n");
}


long int
gametime (void)
{
  return global_clock - last_reset;
}



/*  Takes a number of seconds as input and converts this to seconds,
 *  minutes, hours, days, which is returned if the pointers != NULL.
 */
static void
split_time (long int sec, int *secs, int *min, int *hrs, int *days)
{
  int s = 0, m = 0, h = 0, d = 0;

  if (sec >= SECS_IN_A_DAY) {
    d = sec / SECS_IN_A_DAY;

    sec -= d * SECS_IN_A_DAY;
  }
  if (sec >= SECS_IN_AN_HOUR) {
    h = sec / SECS_IN_AN_HOUR;

    sec -= h * SECS_IN_AN_HOUR;
  }
  if (sec >= SECS_IN_A_MIN) {
    m = sec / SECS_IN_A_MIN;

    sec -= m * SECS_IN_A_MIN;
  }
  s = sec;

  /* Assign return values:
   */
  if (secs != NULL)
    *secs = s;
  if (min != NULL)
    *min = m;
  if (hrs != NULL)
    *hrs = h;
  if (days != NULL)
    *days = d;
}


/*  Takes a number of seconds as input and returns a pointer to a string
 *  containing the amount of time in english, ex: "2 hours, 3 minutes"..etc..
 */
char *
sec_to_str (long int seconds)
{
  static char str[50];

  int sec, min, hrs, days;

  char aux[15];

  *str = '\0';

  split_time (seconds, &sec, &min, &hrs, &days);

  if (days > 0) {
    sprintf (str, "%d day%s", days, (days == 1) ? "" : "s");
  }
  if (hrs > 0) {
    if (days > 0)
      strcat (str, ", ");
    sprintf (aux, "%d hour%s", hrs, (hrs == 1) ? "" : "s");
    strcat (str, aux);
  }
  if (min > 0) {
    if (days > 0 || hrs > 0)
      strcat (str, ", ");
    sprintf (aux, "%d minute%s", min, (min == 1) ? "" : "s");
    strcat (str, aux);
  }
  if (sec > 0) {
    if (days > 0 || hrs > 0 || min > 0)
      strcat (str, ", ");
    sprintf (aux, "%d second%s", sec, (sec == 1) ? "" : "s");
    strcat (str, aux);
  }
  return (str);
}


/*  Takes a number of seconds as input and returns a pointer to a string
 *  containing hh:mm:ss.
 */
char *
sec_to_hhmmss (long int seconds)
{
  static char str[25];

  int sec, min, hrs, days;

  split_time (seconds, &sec, &min, &hrs, &days);

  if (days > 0) {
    hrs += days * 24;
  }
  sprintf (str, "%02d:%02d:%02d", hrs, min, sec);

  return (str);
}


/* Returns time t rounded to the nearest minute.
 */
time_t
round_to_min (time_t t)
{
  t += SECS_IN_A_MIN / 2;

  return (t -= t % SECS_IN_A_MIN);
}


/* Like ctime(3) but strips the seconds, year-part and the \n.
 */
char *
my_ctime (time_t * clock)
{
  char *t = ctime (clock);

  t[16] = '\0';
  return t;
}


void
set_timer (void)
{
  alarm (TIMER_INTERRUPT);
}

void
on_timer (void)
{
  static long int n = 0;
  static const int interupts_per_hour = 3600 / TIMER_INTERRUPT;
  int plx;

  if (++n % interupts_per_hour != 0 || time (&global_clock) == -1) {
    global_clock += TIMER_INTERRUPT;
  }
  check_if_closed (&global_clock);
  move_mobiles ();
  special_events (SP_ALL);
  change_weather ();
  move_time ();

  for (plx = 0; plx < max_players; plx++) {
    if (is_in_game (plx)) {
      if (IDLE_MAX)
	check_idle (plx);
      regenerate (plx);
      calib_player (plx);
      handle_duration (plx);
      trace_handler (plx);
      setup_globals (plx);
    }
  }
}

void
trace_handler (int plr)
{
  static char *Carry[] =
  {
    "In Room", "In Container", "Carried By", "Worn By",
    "Wielded By", "Worn and Wielded By"
  };

  TRACE *Trace = &players[plr].Trace;
  char output[256], buffer[256];
  int obj, loc;

  if (Trace->trace == -1)
    return;

  if (Trace->is_obj) {
    if (getobjloc (Trace->trace) == LOC_PIT_PIT) {
      sendf (plr, "&+G(&+WTrace: Object Has Been Pitted&+G)\n");
      Trace->trace = -1;
      return;
    }
    if (Trace->loc != oloc (Trace->trace) ||
	Trace->oloc != getobjloc (Trace->trace) ||
	Trace->carry != ocarrf (Trace->trace)) {
      Trace->loc = oloc (Trace->trace);
      Trace->oloc = getobjloc (Trace->trace);
      Trace->carry = ocarrf (Trace->trace);
      obj = Trace->trace;
      loc = oloc (Trace->trace);
      if (Trace->carry == IN_CONTAINER) {
	while (ocarrf (obj) == IN_CONTAINER) {
	  obj = loc;
	  loc = oloc (obj);
	}
	sprintf (output, "&+B(&+w%s%s&+B) ", Carry[IN_CONTAINER], oname (loc));
      } else {
	output[0] = '\0';
      }
      if (ocarrf (obj) >= CARRIED_BY)
	sprintf (output, "%s&+B(&+w%s%s&+B)", output, Carry[ocarrf (obj)],
		 pname (oloc (obj)));

      sendf (plr, "&+G(&+WTrace: &+C%s &+B[&+w%d&+B]&+w; Loc: %s &+C%s&+G)\n",
	     oname (Trace->trace), Trace->trace, output,
	     xshowname (buffer, Trace->oloc));
    }
  }
  if (!Trace->is_obj) {
    if (!is_in_game (Trace->trace) || pvis (Trace->trace) > plev (plr)) {
      sendf (plr, "&+G(&+WTrace: Person/Mobile Has Exited Game&+G)\n");
      Trace->trace = -1;
      return;
    }
    if (Trace->loc != ploc (Trace->trace)) {
      Trace->loc = ploc (Trace->trace);
      sendf (plr, "&+G(&+WTrace: &+C%s &+B[&+w%d&+B]&+w; Loc: &+C%s&+G)\n",
	     pname (Trace->trace), Trace->trace,
	     xshowname (buffer, Trace->loc));
    }
  }
}

void
check_idle (int plr)
{
  int itime = plev (plr) < LVL_WIZARD ? IDLE_MAX : IDLE_MAX + 3600;

  if (plev (plr) > LVL_PROPHET)
    return;

  if (global_clock > (plast_cmd (plr) + itime)) {
    send_msg (DEST_ALL, MODE_QUIET, max (pvis (plr), LVL_MIN), LVL_MAX, plr,
	      NOBODY, "&+B[&+W%s &+whas timed-out&+B]\n", pname (plr));
    p_crapup (plr, "\tYou have timed-out.\n", CRAP_SAVE | CRAP_RETURN);
  }
}