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

AuctionData *auction_lookup(int num)
{
	AuctionData *pAuc;

	for (pAuc = auction_first; pAuc != NULL; pAuc = pAuc->next)
	{
		if (pAuc->number == num)
			return pAuc;
	}
	return NULL;
}

int last_auc_id;

int get_auc_id(void)
{
	last_auc_id++;

	if (last_auc_id > 999)
		last_auc_id = 1;

	return last_auc_id;
}

const char *auc_type(auc_t type, bool fShort)
{
	switch (type)
	{
		default:
		case AUC_GOLD:
			return fShort ? "g" : " gold";
		case AUC_QUEST:
			return fShort ? "qp" : " quest points";
		case AUC_TRIVIA:
			return fShort ? "tp" : " trivia points";
	}
}

const char *auc_color(auc_t type)
{
	switch (type)
	{
		default:
		case AUC_GOLD:
			return "{Y";
		case AUC_QUEST:
			return "{G";
		case AUC_TRIVIA:
			return "{R";
	}
}

const char *auc_price(AuctionData * auc, bool fShort)
{
	return FORMATF("%s%ld%s{x", auc_color(auc->type), auc->bid,
				   auc_type(auc->type, fShort));
}

bool check_bid(CharData * ch, money_t bid, auc_t type)
{
	if (!ch)
		return true;

	switch (type)
	{
		default:
		case AUC_GOLD:
			return check_worth(ch, bid, VALUE_DEFAULT);
		case AUC_QUEST:
			return bid < (unsigned int) ch->pcdata->quest.points;
		case AUC_TRIVIA:
			return bid < (unsigned int) ch->pcdata->trivia;
	}
}

void pay_bid(AuctionData * auc)
{
	CharData *bidder = auc->high_bidder;
	CharData *seller = auc->owner;

	switch (auc->type)
	{
		default:
		case AUC_GOLD:
			add_cost(seller, auc->bid * 9 / 10, VALUE_DEFAULT);
			deduct_cost(bidder, auc->bid, VALUE_DEFAULT);
			break;

		case AUC_QUEST:
			seller->pcdata->quest.points += auc->bid;
			bidder->pcdata->quest.points -= auc->bid;
			break;
		case AUC_TRIVIA:
			seller->pcdata->trivia += auc->bid;
			bidder->pcdata->trivia -= auc->bid;
			break;
	}

	if (auc->item->in_room)
		obj_from_room(auc->item);
	else if (auc->item->in_obj)
		obj_from_obj(auc->item);
	else
		obj_from_char(auc->item);

	obj_to_char(auc->item, bidder);

	announce(bidder, INFO_AUCTION | INFO_PRIVATE, "You are sold %s for %s.",
			 auc->item->short_descr, auc_price(auc, false));

	if (auc->type == AUC_GOLD)
		auc->bid = (auc->bid * 9) / 10;

	chprintlnf(seller, "You receive %s for the sale of %s.",
			   auc_price(auc, false), auc->item->short_descr);
}

money_t bid_incr(auc_t type)
{
	switch (type)
	{
		default:
			return 10;
		case AUC_TRIVIA:
			return 1;
	}
}

Do_Fun(do_auction)
{
	AuctionData *auc;
	ObjData *obj = NULL;
	money_t minbid = 1;
	char arg1[MIL];
	char arg2[MIL];
	char arg3[MIL];
	auc_t type;

	argument = first_arg(argument, arg1, false);
	argument = first_arg(argument, arg2, false);
	first_arg(argument, arg3, false);

	if (ch == NULL)
		return;

	if (NullStr(arg1))
	{
		if (IsSet(ch->info_settings, INFO_AUCTION))
		{
			RemBit(ch->info_settings, INFO_AUCTION);
			chprintln(ch, "{YAUCTION{x channel is now ON.");
		}
		else
		{
			SetBit(ch->info_settings, INFO_AUCTION);
			chprintln(ch, "{YAUCTION{x channel is now OFF.");
		}
		return;
	}
	else if (!str_cmp(arg1, "stop") && IsImmortal(ch))
	{

		if (NullStr(arg2) || !is_number(arg2))
		{
			chprintln(ch, "Stop which auction?");
			return;
		}
		if ((auc = auction_lookup(atoi(arg2))) == NULL)
		{
			chprintln(ch, "No such auction.");
			return;
		}
		if (auc->item)
		{
			announce(ch, INFO_AUCTION,
					 "$n has stopped the auction and confiscated %s!",
					 auc->item->short_descr);
			announce(ch, INFO_AUCTION | INFO_PRIVATE,
					 "You have stopped the auction and confiscated %s!",
					 auc->item->short_descr);
			obj_from_char(auc->item);
			obj_to_char(auc->item, ch);
		}
		reset_auc(auc, true);
		return;
	}

	if ((obj = get_obj_carry(ch, arg1, ch)) == NULL)
	{
		chprintln(ch, "You aren't carrying that item.");
		return;
	}

	if (is_name(arg2, "gold coin"))
		type = AUC_GOLD;
	else if (is_name(arg2, "qp questpoints"))
		type = AUC_QUEST;
	else if (is_name(arg2, "tp triviapoints"))
		type = AUC_TRIVIA;
	else if (IsObjStat(obj, ITEM_QUEST))
		type = AUC_QUEST;
	else
	{
		chprintln(ch,
				  "What kind of currency do you want to use? (gold, quest points, or trivia points)");
		return;
	}

	if (IsObjStat(obj, ITEM_AUCTIONED))
	{
		chprintln(ch, "That items is already being auctioned.");
		return;
	}

	if (IsObjStat(obj, ITEM_NODROP) && !IsObjStat(obj, ITEM_QUEST))
	{
		chprintln(ch, "You can't let go of that item.");
		return;
	}

	if (obj->item_type == ITEM_CORPSE_PC || obj->item_type == ITEM_CORPSE_NPC)
	{
		chprintln(ch, "Not a good idea....");
		return;
	}

	if (count_auc(ch) >= 3)
	{
		chprintln(ch, "You can only auction up to 3 items at a time!");
		return;
	}

	if (!NullStr(arg3))
		minbid = atol(arg3);
	else if (IsObjStat(obj, ITEM_QUEST))
		minbid = obj_cost(obj) / 3;

	if (minbid > 1000000 || minbid < 1)
	{
		chprintln(ch,
				  "Minumum bids can't be higher than 1000000 or less than 1.");
		return;
	}

	auc = new_auction();
	Link(auc, auction, next, prev);
	SetBit(obj->extra_flags, ITEM_AUCTIONED);
	auc->owner = ch;
	auc->item = obj;
	auc->type = type;
	auc->bid = minbid;
	auc->number = get_auc_id();
	auc->status = AUCTION_LENGTH;

	announce(auc->owner, INFO_AUCTION,
			 "$n is auctioning %s (Level %d, Num %d). Current bid is %s.",
			 auc->item->short_descr, auc->item->level, auc->number,
			 auc_price(auc, false));
	announce(auc->owner, INFO_AUCTION | INFO_PRIVATE,
			 "You are auctioning %s (Level %d, Num %d). Current bid is %ld%s.",
			 auc->item->short_descr, auc->item->level, auc->number,
			 auc_price(auc, false));
	mud_info.stats.auctions++;
	return;
}

void auction_update(void)
{
	AuctionData *auc, *auc_next;

	if (!auction_first)
		return;

	for (auc = auction_first; auc != NULL; auc = auc_next)
	{
		auc_next = auc->next;

		if (auc->status == 0)
			continue;

		auc->status--;

		if (auc->status < 0)
			auc->status = 0;

		if (!auc->item)
		{
			reset_auc(auc, true);
			bugf("Auction with no item, reseting.");
			continue;
		}
		else if (auc->status % PULSE_PER_SECOND == 0)
		{
			switch (auc->status / PULSE_PER_SECOND)
			{
				case 0:
					if (auc->high_bidder == NULL)
					{
						announce(NULL, INFO_AUCTION,
								 "No bids recieved on %s, sale stopped.",
								 auc->item->short_descr);
						reset_auc(auc, true);
					}
					else
						if (!check_bid(auc->high_bidder, auc->bid, auc->type))
					{
						announce(auc->high_bidder, INFO_AUCTION,
								 "$n can't cover their stake in the auction, sale stopped.");
						announce(auc->high_bidder,
								 INFO_AUCTION | INFO_PRIVATE,
								 "You can't cover your stake in the auction, sale stopped.");

						reset_auc(auc, true);
					}
					else
					{
						announce(auc->high_bidder, INFO_AUCTION,
								 "%s SOLD to $n for %s.",
								 auc->item->short_descr, auc_price(auc,
																   false));
						reset_auc(auc, false);
						mud_info.stats.aucsold++;
					}
					break;
				case 32:
					announce(NULL, INFO_AUCTION,
							 "Going once %s (Level %d, Num %d). Current bid is %s.",
							 auc->item->short_descr, auc->item->level,
							 auc->number, auc_price(auc, false));
					break;
				case 15:
					announce(NULL, INFO_AUCTION,
							 "Going twice %s (Level %d, Num %d). Current bid is %s.",
							 auc->item->short_descr, auc->item->level,
							 auc->number, auc_price(auc, false));
					break;
			}
		}
	}
	return;
}

void reset_auc(AuctionData * auc, bool forced)
{
	if (auc->item != NULL)
	{
		if (IsObjStat(auc->item, ITEM_AUCTIONED))
			RemBit(auc->item->extra_flags, ITEM_AUCTIONED);
		else
			bug("item not flagged auction item");

		if (!forced && auc->high_bidder != NULL && auc->bid > 0)
			pay_bid(auc);

		else if (auc->owner != NULL)
			chprintlnf(auc->owner, "Sale of %s has been stopped.",
					   auc->item->short_descr);

	}
	UnLink(auc, auction, next, prev);
	free_auction(auc);
	return;
}

int count_auc(CharData * ch)
{
	AuctionData *q;
	int count;

	q = auction_first;

	if (!q)
		return 0;

	for (count = 0; q; q = q->next)
	{
		if (q->owner == ch)
			count++;
	}

	return count;
}

money_t advatoi(const char *s)
{
	const char *sptr;
	money_t number;
	money_t multiplier;

	for (sptr = s, number = 0; *sptr != NUL && isdigit(*sptr); sptr++)
		number = (number * 10) + (*sptr - '0');

	switch (toupper(*sptr))
	{
		case 'K':
			multiplier = 1000;
			number *= multiplier;
			sptr++;
			break;
		case 'M':
			multiplier = 1000 * 1000;
			number *= multiplier;
			sptr++;
			break;
		case '\0':
			multiplier = 0;
			break;
		default:
			return 0;

	}

	while (*sptr != NUL && isdigit(*sptr) && (multiplier > 1))
	{
		multiplier = multiplier / 10;
		number = number + ((*sptr - '0') * multiplier);
		sptr++;
	}

	if (*sptr != '\0' && !isdigit(*sptr))
		return 0;

	return number;
}

money_t parsebet(const money_t currentbet, const char *argument)
{
	money_t newbet = 0;
	const char *strptr = argument;

	if (*strptr)
	{
		if (isdigit(*strptr))
			newbet = advatoi(strptr);
		else if (*strptr == '+')
		{
			if (strlen(strptr) == 1)
				newbet = (currentbet * 125) / 100;
			else
				newbet = (currentbet * (100 + atoi(++strptr))) / 100;
		}
		else
		{
			if ((*strptr == '*') || (*strptr == 'x'))
			{
				if (strlen(strptr) == 1)
					newbet = currentbet * 2;
				else
					newbet = currentbet * atoi(++strptr);
			}
		}
	}

	return newbet;
}

Do_Fun(do_bid)
{
	char arg1[MIL];
	char arg2[MIL];
	AuctionData *auc, *auc_next;

	argument = one_argument(argument, arg1);
	argument = one_argument(argument, arg2);

	if (auction_first == NULL)
	{
		chprintln(ch, "There's nothing up for auction right now.");
		return;
	}

	if (NullStr(arg1))
	{
		chprintln(ch,
				  stringf(ch, 0, Center, NULL,
						  "{Y[ Auction - Current List of Inventory ]{x"));
		chprintln(ch,
				  "{GNum   Seller       Buyer        Item Description                   Lvl   Last Bid    Time{x");
		chprintln(ch,
				  "{W---  ------------ ------------ ----------------------------------- --- ------------- ------------{x");
		for (auc = auction_first; auc; auc = auc_next)
		{
			auc_next = auc->next;

			if (!auc->item)
			{
				reset_auc(auc, true);
				continue;
			}

			chprintlnf(ch,
					   "{R%3d{x - %-12.12s %-12.12s" MXPTAG("Bid %d")
					   "%35.35s" MXPTAG("/Bid") " %3d" " {R%13s{G %s{x",
					   auc->number, GetName(auc->owner),
					   auc->high_bidder ? GetName(auc->high_bidder) : "None",
					   auc->number, stringf(ch, 35, Left, NULL,
											auc->item->short_descr),
					   auc->item->level, auc_price(auc, true),
					   format_pulse(auc->status));
		}
		chprintln(ch,
				  "{W---  ------------ ------------ ----------------------------------- --- ------------- ------------{x");
		chprintlnf(ch,
				   "Type: '%s <num>' to see stats and '%s <num> <amount>' to bid on an item.",
				   n_fun, n_fun);
		return;
	}
	else if ((auc = auction_lookup(atoi(arg1))) != NULL)
	{
		if (!auc->item)
		{
			reset_auc(auc, true);
			chprintln(ch, "No such item.");
			return;
		}

		if (NullStr(arg2))
		{
			if (ch == auc->owner)
				chprintlnf(ch, "You're auctioning %s.",
						   auc->item->short_descr);
			spell_identify(0, ch->level, ch, auc->item, TARGET_OBJ);
			chprintf(ch, "Current bid is %s", auc_price(auc, false));
			if (auc->high_bidder)
				chprintlnf(ch, ", placed by %s.", Pers(auc->high_bidder, ch));
			else
				chprintln(ch, ".");
			return;
		}
		else
		{
			money_t bid = 0;

			if (ch == auc->high_bidder)
			{
				chprintln(ch, "You already have the highest bid!");
				return;
			}

			if (ch == auc->owner)
			{
				chprintln(ch, "You cannot bid on your own items!");
				return;
			}

			bid = parsebet(auction_first->bid, arg2);

			if (bid < 0 || bid > 200000000)
			{
				chprintln(ch, "Invalid bid.");
				return;
			}

			if (!check_bid(ch, bid, auc->type))
			{
				chprintln(ch, "You can't cover that bid.");
				return;
			}

			if (bid < auc->bid)
			{
				chprintlnf(ch, "The minimum bid is %s.",
						   intstr(auc->bid, auc_type(auc->type, false)));
				return;
			}

			if (bid < (auc->bid + bid_incr(auc->type)))
			{
				chprintlnf(ch, "You must outbid %s by at least %ld.",
						   intstr(auc->bid, auc_type(auc->type, false)),
						   bid_incr(auc->type));
				return;
			}
			announce(ch, INFO_AUCTION, "$n has offered %s for %s.",
					 auc_price(auc, false), auc->item->short_descr);
			announce(ch, INFO_AUCTION | INFO_PRIVATE,
					 "You place a %s bid on %s.", auc_price(auc, false),
					 auc->item->short_descr);
			auc->high_bidder = ch;
			auc->bid = bid;
			auc->status = AUCTION_LENGTH;
			return;
		}
	}
	else
		chprintln(ch,
				  "Bid on what object? (type 'bid', nothing else for a list)");
}

bool has_auction(CharData * ch)
{
	AuctionData *auc;

	for (auc = auction_first; auc != NULL; auc = auc->next)
	{
		if (auc->owner == ch || auc->high_bidder == ch)
			return true;
	}

	return false;
}

void extract_auc(CharData * ch)
{
	AuctionData *auc, *auc_next;

	for (auc = auction_first; auc != NULL; auc = auc_next)
	{
		auc_next = auc->next;

		if (auc->owner == ch)
		{
			reset_auc(auc, true);
			continue;
		}

		if (auc->high_bidder == ch)
		{
			reset_auc(auc, true);
			continue;
		}
	}
}