/**************************************************************************
*  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
*  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
*                                                                         *
*  Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael         *
*  Chastain, Michael Quan, and Mitchell Tse.                              *
*                                                                         *
*  In order to use any part of this Merc Diku Mud, you must comply with   *
*  both the original Diku license in 'license.doc' as well the Merc       *
*  license in 'license.txt'.  In particular, you may not remove either of *
*  these copyright notices.                                               *
*                                                                         *
*  Much time and thought has gone into this software and you are          *
*  benefiting.  We hope that you share your changes too.  What goes       *
*  around, comes around.                                                  *
***************************************************************************
*       ROM 2.4 is copyright 1993-1998 Russ Taylor                        *
*       ROM has been brought to you by the ROM consortium                 *
*           Russ Taylor (rtaylor@hypercube.org)                           *
*           Gabrielle Taylor (gtaylor@hypercube.org)                      *
*           Brian Moore (zump@rom.org)                                    *
*       By using this code, you have agreed to follow the terms of the    *
*       ROM license, in the file Rom24/doc/rom.license                    *
***************************************************************************
*          1stMud ROM Derivative (c) 2001-2004 by Markanth                *
*            http://www.firstmud.com/  <markanth@firstmud.com>            *
*         By using this code you have agreed to follow the term of        *
*             the 1stMud license in ../doc/1stMud/LICENSE                 *
***************************************************************************/

#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "data_table.h"

DataTable stat_data_table[] = {
  {"name", FIELD_STRING, (void *) &stat_zero.name, NULL, NULL},
  {"stats", FIELD_LONG_ARRAY, (void *) &stat_zero.gamestat,
   (const void *) MAX_GAMESTAT, (const void *) 0},
  {"version", FIELD_INT, (void *) &stat_zero.version, NULL, NULL},
  {NULL, (field_t) - 1, NULL, NULL, NULL}
};

TableSave_Fun (rw_stat_data)
{
  rw_list (type, STAT_FILE, StatData, stat);
}

void
update_statlist (CharData * ch, bool pdelete)
{
  StatData *prev;
  StatData *curr;
  int i;

  if (IsNPC (ch) || IsImmortal (ch))
    return;

  prev = NULL;

  for (curr = stat_first; curr != NULL; curr = prev)
    {
      prev = curr->next;

      if (!str_cmp (ch->name, curr->name))
	{
	  if (curr->version < mud_info.stats.version)
	    {
	      memset (curr->gamestat, 0, MAX_GAMESTAT);
	      memset (ch->pcdata->gamestat, 0, MAX_GAMESTAT);
	    }
	  UnLink (curr, stat, next, prev);
	  free_stat (curr);
	}
    }
  if (pdelete || IsNPC (ch) || IsImmortal (ch))
    {
      rw_stat_data (act_write);
      return;
    }

  curr = new_stat ();
  curr->name = str_dup (ch->name);
  curr->version = mud_info.stats.version;
  for (i = 0; i < MAX_GAMESTAT; i++)
    curr->gamestat[i] = GetStat (ch, i);

  Link (curr, stat, next, prev);
  rw_stat_data (act_write);
  return;
}


const char *
print_stat (CharData * ch, const char *head, long value)
{
  return FORMATF ("{W%-19.19s {w[{R%10.10ld{w]", head, value);
}

Do_Fun (do_showstats)
{
  int option;
  char arg[MIL];

  argument = one_argument (argument, arg);

  if (NullStr (arg))
    {
      chprintln (ch, "      {ROPTIONS AVAILABLE:{x");
      chprintln (ch, "      {G0{x - Show general {n stats. (gstats)");
      chprintln (ch, "      {G1{x - Ranking of Player Killers (pkills)");
      chprintln (ch, "      {G2{x - Ranking of Player Deaths (pdeaths)");
      chprintln (ch, "      {G3{x - Ranking of Mob Kills (mkills)");
      chprintln (ch, "      {G4{x - Ranking of Mob Deaths (mdeaths)");
      chprintln (ch, "      {G5{x - Personal Rankings (personal)");
      if (IsImmortal (ch))
	chprintln (ch, "      {Gdelete <name>{x - deletes from statlist");
      return;
    }
  option = atoi (arg);

  if (!str_cmp (arg, "delete") && IsImmortal (ch))
    {
      StatData *prev = NULL;
      StatData *curr = NULL;
      bool found = false;

      for (curr = stat_first; curr != NULL; curr = prev)
	{
	  prev = curr->next;

	  if (!str_cmp (argument, curr->name))
	    {
	      UnLink (curr, stat, next, prev);
	      free_stat (curr);
	      rw_stat_data (act_write);
	      found = true;
	    }
	}
      if (!found)
	chprintlnf (ch, "Error deleting %s.", argument);
    }
  else if (option == 0 || !str_prefix (arg, "gstats"))
    {
      Column *Cd;
      Buffer *b;

      Cd = new_column ();
      b = new_buf ();
      set_cols (Cd, ch, 2, COLS_BUF, b);

      bprintln (b,
		stringf (ch, 0, Center, "{R-{r=",
			 "{C[ %s Stats ]", mud_info.name));
      print_cols (Cd, print_stat (ch, "Logins", mud_info.stats.logins));
      print_cols (Cd, print_stat (ch, "Quests", mud_info.stats.quests));
      print_cols (Cd,
		  print_stat (ch, "Quests Complete",
			      mud_info.stats.qcomplete));
      print_cols (Cd, print_stat (ch, "Levels", mud_info.stats.levels));
      print_cols (Cd, print_stat (ch, "Newbies", mud_info.stats.newbies));
      print_cols (Cd, print_stat (ch, "Deletions", mud_info.stats.deletions));
      print_cols (Cd,
		  print_stat (ch, "Mob Deaths", mud_info.stats.mobdeaths));
      print_cols (Cd, print_stat (ch, "Auctions", mud_info.stats.auctions));
      print_cols (Cd,
		  print_stat (ch, "Auctions Sold", mud_info.stats.aucsold));
      print_cols (Cd, print_stat (ch, "Player Deaths", mud_info.stats.pdied));
      print_cols (Cd, print_stat (ch, "Player Kills", mud_info.stats.pkill));
      print_cols (Cd, print_stat (ch, "Notes", mud_info.stats.notes));
      print_cols (Cd, print_stat (ch, "Remorts", mud_info.stats.remorts));
      print_cols (Cd, print_stat (ch, "Wars", mud_info.stats.wars));
      print_cols (Cd,
		  print_stat (ch, "Global Quests", mud_info.stats.gquests));
      print_cols (Cd,
		  print_stat (ch, "Connections", mud_info.stats.connections));
      print_cols (Cd,
		  print_stat (ch, "Connects this Boot",
			      mud_info.stats.boot_connects));
      print_cols (Cd,
		  print_stat (ch, "Online Record", mud_info.stats.online));
      print_cols (Cd,
		  print_stat (ch, "Web Hits", mud_info.stats.web_requests));
      print_cols (Cd,
		  print_stat (ch, "Channel Messages",
			      mud_info.stats.chan_msgs));
      cols_nl (Cd);
      bprintln (b,
		stringf (ch, 0, Center, "{R-{r=",
			 "{C[ Stats since: %s ]",
			 str_time (mud_info.stats.lastupdate,
				   GetTzone (ch), NULL)));
      sendpage (ch, buf_string (b));
      free_buf (b);
      free_column (Cd);
      return;
    }
  else if (option == 1 || !str_prefix (arg, "pkills"))
    show_game_stats (ch, PK_KILLS);
  else if (option == 3 || !str_prefix (arg, "mkills"))
    show_game_stats (ch, MOB_KILLS);
  else if (option == 2 || !str_prefix (arg, "pdeaths"))
    show_game_stats (ch, PK_DEATHS);
  else if (option == 4 || !str_prefix (arg, "mdeaths"))
    show_game_stats (ch, MOB_DEATHS);
  else if (option == 5 || !str_prefix (arg, "personal"))
    {
      StatData *curr;
      Column Cd;
      Buffer b;
      int i = 0;
      const char *stat_self[MAX_GAMESTAT] = {
	"PLAYER KILLS",
	"MOB KILLS",
	"PK DEATHS",
	"MOB DEATHS",
      };

      update_statlist (ch, false);

      for (curr = stat_first; curr != NULL; curr = curr->next)
	if (!str_cmp (ch->name, curr->name))
	  break;

      if (!curr)
	{
	  chprintln (ch, "You have no stats yet.");
	  return;
	}

      set_cols (&Cd, ch, 2, COLS_BUF, &b);

      bprintln (&b, stringf (ch, 0, Center, "{r-{R=",
			     "{C[ RANKING OF PERSONAL BESTS ]"));
      for (i = 0; i < MAX_GAMESTAT; i++)
	{
	  print_cols (&Cd, "{G%2d{w){W %s{x", i + 1,
		      print_stat (ch, stat_self[i], curr->gamestat[i]));
	}
      cols_nl (&Cd);
      bprintln (&b, draw_line (ch, "{r-{R=", 0));
      sendpage (ch, buf_string (&b));
      return;
    }
  else
    do_showstats (n_fun, ch, "");

  return;
}

int compare_type;

int
compare_stats (const void *v1, const void *v2)
{
  StatData *stat1 = *(StatData **) v1;
  StatData *stat2 = *(StatData **) v2;

  if (!stat2)
    return 1;
  if (!stat1)
    return 2;

  return stat2->gamestat[compare_type] - stat1->gamestat[compare_type];
}

void
show_game_stats (CharData * ch, int type)
{
  StatData *curr;
  Buffer *output;
  StatData **top;
  Column *Cd, c;
  int count, loop;
  bool found = false;
  const char *stat_name[MAX_GAMESTAT] = {
    "PLAYER KILLERS",
    "MOB KILLERS",
    "PK DEATHS",
    "MOB DEATHS",
  };

  output = new_buf ();
  Cd = &c;
  set_cols (Cd, ch, 2, COLS_BUF, output);
  count = 0;
  compare_type = type;

  alloc_mem (top, StatData *, top_stat);

  bprintln (output, stringf (ch, 0, Center, "{R-{r=",
			     "{C[ RANKING OF %s ]", stat_name[type]));
  loop = 0;
  loop = 0;
  for (curr = stat_first; curr != NULL; curr = curr->next)
    {
      top[count] = curr;
      count++;
      found = true;
    }

  if (found)
    {
      qsort (top, count, sizeof (*top), compare_stats);

      for (loop = 0; loop < count; loop++)
	{
	  if (loop >= 50)
	    break;

	  print_cols (Cd,
		      "{G%2d{w){W %-20s {w[{R%8ld{W]{x", loop + 1,
		      top[loop]->name, top[loop]->gamestat[type]);
	}
    }
  if (!found)
    bprintln (output, "No one found yet.");
  else
    cols_nl (Cd);
  bprintln (output, draw_line (ch, "{R-{r=", 0));
  sendpage (ch, buf_string (output));
  free_mem (top);
  free_buf (output);
  free_column (Cd);
  return;
}