/**************************************************************************
*  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 "recycle.h"

int bitcount(char c)
{
	int count = 0;

	if (c & BIT_A)
		count++;
	if (c & BIT_B)
		count++;
	if (c & BIT_C)
		count++;
	if (c & BIT_D)
		count++;
	if (c & BIT_E)
		count++;
	if (c & BIT_F)
		count++;
	if (c & BIT_G)
		count++;
	if (c & BIT_H)
		count++;

	return count;
}

int roomcount(CharData * ch)
{
	int pIndex = 0, count = 0;

	if (IsNPC(ch))
		return top_room_index;

	for (pIndex = 0; pIndex < MAX_EXPLORE_HASH; pIndex++)
	{
		count += bitcount(ch->pcdata->explored[pIndex]);
	}

	return count;
}

void update_explored(CharData * ch)
{
	vnum_t vnum;
	RoomIndex *pRoom;
	int nMatch = 0;

	for (vnum = 0; nMatch < top_room_index; vnum++)
	{
		if ((pRoom = get_room_index(vnum)) != NULL)
		{
			nMatch++;
			if (IsSet(pRoom->room_flags, ROOM_NOEXPLORE)
				&& StrIsSet(ch->pcdata->explored, vnum))
				StrRemBit(ch->pcdata->explored, vnum);
		}
		else
		{
			if (StrIsSet(ch->pcdata->explored, vnum))
				StrRemBit(ch->pcdata->explored, vnum);
		}
	}
}

int areacount(CharData * ch, AreaData * area)
{
	vnum_t pIndex = 0;
	int count = 0;

	if (ch == NULL || area == NULL)
		return 0;

	if (IsNPC(ch))
		return top_room_index;

	for (pIndex = area->min_vnum; pIndex <= area->max_vnum; pIndex++)
	{
		count += StrIsSet(ch->pcdata->explored, pIndex) ? 1 : 0;
	}

	return count;
}

int arearooms(AreaData * area)
{
	int count = 0;
	vnum_t pIndex = 0;
	RoomIndex *pRoom;

	if (!area)
		return 0;

	for (pIndex = area->min_vnum; pIndex <= area->max_vnum; pIndex++)
	{
		if ((pRoom = get_room_index(pIndex)) != NULL
			&& !IsSet(pRoom->room_flags, ROOM_NOEXPLORE))
			count++;
	}

	return count;
}

void write_rle(char *explored, FileData * fp)
{
	vnum_t pIndex;
	int bit = 0;
	int count = 0;

	f_writef(fp, "RoomRLE", "%d", bit);

	for (pIndex = 0; pIndex < top_vnum_room; pIndex++)
	{
		if ((StrIsSet(explored, pIndex) ? 1 : 0) == bit)
			count++;
		else
		{
			f_printf(fp, " %d", count);
			count = 1;
			bit = (StrIsSet(explored, pIndex)) ? 1 : 0;
		}
	}
	f_printf(fp, " %d -1" LF, count);
	return;
}

void read_rle(char *explored, FileData * fp)
{
	vnum_t index;
	int bit = 0;
	int count = 0;
	vnum_t pos = 0;

	index = 0;

	bit = read_number(fp);

	for (;;)
	{
		count = read_number(fp);

		if (count < 0)
			break;
		if (count == 0)
			continue;

		do
		{
			if (bit == 1)
			{
				StrSetBit(explored, index);
			}
			index++;
		}
		while (index < pos + count);

		pos = index;
		bit = (bit == 1) ? 0 : 1;
	}
	return;
}

int compare_area_explored(const void *v1, const void *v2)
{
	AreaIndex area1 = *(AreaIndex *) v1;
	AreaIndex area2 = *(AreaIndex *) v2;

	return (int) (area2.percent - area1.percent);
}

Do_Fun(do_explored)
{
	int i = 0, c = 0;
	double rooms, rcnt, percent;
	AreaData *pArea;
	AreaIndex *list;

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

	if (NullStr(argument))
	{
		rcnt = (double) roomcount(ch);
		rooms = (double) top_explored;

		chprintlnf(ch, "ROM has {G%d{x explorable rooms.", top_explored);
		chprintlnf(ch, "You have explored {G%.0f (%.2f%%){x of the mud{x",
				   rcnt, Percent(rcnt, rooms));

		rcnt = (double) areacount(ch, ch->in_room->area);
		rooms = (double) (arearooms(ch->in_room->area));

		chprintlnf(ch, "This area has {G%.0f{x explorable rooms.", rooms);
		chprintlnf(ch,
				   "You have explored {G%.0f (%.2f%%){x rooms in this area.{x",
				   rcnt, Percent(rcnt, rooms));
	}
	else if (is_exact_name(argument, "reset"))
	{
		memset(ch->pcdata->explored, 0, MAX_EXPLORE_HASH);
		chprintln(ch, "Your explored rooms were set to 0.");
	}
	else if (!str_prefix(argument, "list"))
	{
		Buffer *output = new_buf();
		Column *Cd = new_column();

		set_cols(Cd, ch, 2, COLS_BUF, output);
		alloc_mem(list, AreaIndex, top_area);

		for (pArea = area_first; pArea != NULL; pArea = pArea->next)
		{
			rcnt = (double) (areacount(ch, pArea));
			rooms = (double) (arearooms(pArea));
			list[i].area = pArea;
			list[i].percent = Percent(rcnt, rooms);
			i++;
		}
		qsort(list, i, sizeof(AreaIndex), compare_area_explored);

		for (c = 0; c < i; c++)
		{
			pArea = list[c].area;
			percent = list[c].percent;

			print_cols(Cd, "{D[{Y%3.0f{y%%{D]{x %s", percent, pArea->name);
		}
		cols_nl(Cd);
		sendpage(ch, buf_string(output));
		free_buf(output);
		free_column(Cd);
		free_mem(list);
	}
	else
	{
		cmd_syntax(ch, NULL, n_fun, "        - show current area and world.",
				   "list    - list percentages for all areas.",
				   "reset   - reset explored rooms.", NULL);
	}
}