#include <iostream>
#include <fstream>
#include <string>

using namespace std;

///////////////////////////////////////
// Basic Data Types
///////////////////////////////////////


/**
 * An amount of U.S. currency
 */
struct Money {
	int dollars;
	int cents; //< @invariant should be in the range 0..99, inclusive
};


/**
 * The time of the day, to the nearest second.
 */
struct Time {
  int hours;
  int minutes;
  int seconds;
};



/**
 * A Bid received during an auction
*/
struct Bid {
  std::string bidderName;
  Money amount;
  std::string itemName;
  Time bidPlacedAt;
};


/**
 * Someone registered to participate in an auction
 */
struct Bidder {
  std::string name;
  Money balance;
};


/**
 * An item up for auction
 */
struct Item {
	/// Name of the item
	std::string name;

	/// The minimum acceptable bid set by the seller
	Money reservedPrice;

	/// Time at which the auction ends
	Time auctionEndsAt;
};


/////////////////////////////////////
// Sequence Data Types
/////////////////////////////////////

/// A collection of bids
struct BidSequence {
	static const int capacity = 5000; ///< Max number allowed
	int size;                         ///< Number currently in array
	Bid data[capacity];               ///< The actual sequence data
};

/// A collection of bidders
struct BidderSequence {
	static const int capacity = 1000; ///< Max number allowed
	int size;                         ///< Number currently in array
	Bidder data[capacity];            ///< The actual sequence data
};

/// A collection of items
struct ItemSequence {
	static const int capacity = 500; ///< Max number allowed
	int size;                         ///< Number currently in array
	Item data[capacity];               ///< The actual sequence data
};


/////////////////////////////////////
// Global Variables
/////////////////////////////////////

/// The bidders participating in today's auction.
BidderSequence bidders;

/// The bids received for today's auction
BidSequence bids;

/**
 * The collection of all items being auctioned off for the day
 */
ItemSequence items;



/////////////////////////////////////
// Function Declarations
/////////////////////////////////////


/**
 * Adds two Money amounts together
 *
 * @param left  1st value to be added
 * @param right 2nd value to be added
 * @return sum of the two amounts
 */
Money add (const Money& left, const Money& right);


bool equal (const Money& left, const Money& right);


/**
 * Find the index of the bidder with the given name. If no such bidder exists,
 * return bidders.size.
 */
 int findBidder (std::string name, const BidderSequence& bidders);


 /**
 * Compare two Money amounts to see if the 1st is smaller
 * than the second
 *
 * @param left  1st value to be compared
 * @param right 2nd value to be compared
 * @return true iff left is a smaller amount than right
 */
bool lessThan (const Money& left, const Money& right);



/**
 *  Compare two times. Return true iff time1 is earlier than or equal to
 *  time2
 *
 *  Pre: Both times are normalized: sconds and minutes are in the range 0..59,
 *         hours are non-negative
 */
bool noLaterThan(const Time& time1, const Time& time2);


 /**
  * Print a monetary amount.The output format will always
  * include a decimal point and a two-digit cents amount.
  *
  * @param out the stream to which to print
  * @param money the value to be printed
  */
 void print (std::ostream& out, const Money& money);

 /**
  * Compare two Money amounts to see if they are equal
  *
  * @param left  1st value to be compared
  * @param right 2nd value to be compared
  * @return true iff the two amounts are equal
  */

 /**
  * Print a time in the format HH:MM:SS (two digits each)
  */
 void print (std::ostream& out, const Time& time);

 /**
  * Read a bid from the indicated file
  */
 void read (istream& in, Bid& bid);

 /**
  * Read all bids from the indicated file
  */
 void read (istream& in, BidSequence& bids);

 /**
 * Read a bidder from the indicated file
 */
void read (istream& in, Bidder& bidder);

/**
 * Read all bidders from the indicated file
 */
void read (istream& in, BidderSequence& bidders);


/**
 * Read one item from the indicated file
 */
void read (istream& in, Item& item);


/**
 * Read all items from the indicated file
 */
void read (istream& in, ItemSequence& items);


/**
 * Read a money value from the input.  Acceptable formats are
 *
 *        ddd.cc or ddd
 *
 * where ddd is any positive/negative integer of
 * one or more digits denoting dollars, and cc, if
 * supplied, is a two-digit integer.
 *
 * @param in   stream from which to read
 * @param money the value read in. Result is unpredictable if an I/O error occurs
 */
void read (std::istream& in, Money& money);

/**
 * Read a time (in the format HH:MM:SS) after skipping any
 * prior whitespace.
 */
void read (std::istream& in, Time& time);



/**
 * Determine the winner of the auction for item number i.
 * Announce the winner and remove money from winner's account.
 */
void resolveAuction (const BidSequence& bids, BidderSequence& bidders, const Item& item);


/**
 * Subtract one Money amount from another
 *
 * @param left  the minuend
 * @param right the subtrahend
 * @return difference of the two amounts
 */
Money subtract (const Money& left, const Money& right);






/////////////////////////////////////
// Function Bodies
/////////////////////////////////////



int main (int argc, char** argv)
{
  if (argc != 4)
    {
      cerr << "Usage: " << argv[0] << " itemsFile biddersFile bidsFile" << endl;
      return -1;
    }

  {
	  ifstream itemInput (argv[1]);
	  read (itemInput, items);
  }
  {
	  ifstream bidderInput (argv[2]);
	  read (bidderInput, bidders);
  }
  {
	  ifstream bidInput (argv[3]);
	  read (bidInput, bids);
  }


  for (int i = 0; i < items.size; ++i)
    {
      resolveAuction(bids, bidders, items.data[i]);
    }
  return 0;
}



/**
 * Adds two Money amounts together
 *
 * @param left  1st value to be added
 * @param right 2nd value to be added
 * @return sum of the two amounts
 */
Money add (const Money& left, const Money& right)
{
	Money result;
	result.dollars = left.dollars + right.dollars;
	result.cents = left.cents + right.cents;
	while (result.cents > 99)
	{
		result.cents -= 100;
		++result.dollars;
	}
	while (result.cents < 0)
	{
		result.cents += 100;
		--result.dollars;
	}
	return result;
}



/**
  * Compare two Money amounts to see if they are equal
  *
  * @param left  1st value to be compared
  * @param right 2nd value to be compared
  * @return true iff the two amounts are equal
  */
 bool equal (const Money& left, const Money& right)
 {
 	return (left.dollars == right.dollars)
 			&& (left.cents == right.cents);
 }



/**
 * Find the index of the bidder with the given name. If no such bidder exists,
 * return bidders.size.
 */
 int findBidder (std::string name, const BidderSequence& bidders)
 {
     int found = bidders.size;
     for (int i = 0; i < bidders.size && found == bidders.size; ++i)
     {
         if (name == bidders.data[i].name)
            found = i;
     }
     return found;
 }


  /**
  * Compare two Money amounts to see if the 1st is smaller
  * than the second
  *
  * @param left  1st value to be compared
  * @param right 2nd value to be compared
  * @return true iff left is a smaller amount than right
  */
 bool lessThan (const Money& left, const Money& right)
 {
 	if (left.dollars < right.dollars)
 		return true;
 	else if (left.dollars == right.dollars)
 		return left.cents < right.cents;
 	return false;
 }



 /**
  *  Compare two times. Return true iff time1 is earlier than or equal to
  *  time2
  *
  *  Pre: Both times are normalized: sconds and minutes are in the range 0..59,
  *         hours are non-negative
  */
 bool noLaterThan(const Time& time1, const Time& time2)
 {
     // First check the hours
     if (time1.hours > time2.hours)
         return false;
     if (time1.hours < time2.hours)
         return true;
     // If hours are the same, compare the minutes
     if (time1.minutes > time2.minutes)
         return false;
     if (time1.minutes < time2.minutes)
         return true;
     // If hours and minutes are the same, compare the seconds
     if (time1.seconds > time2.seconds)
         return false;
     return true;
 }


 /**
  * Print a monetary amount.The output format will always
  * include a decimal point and a two-digit cents amount.
  *
  * @param out the stream to which to print
  * @param money the value to be printed
  */
 void print (std::ostream& out, const Money& money){
 	out << money.dollars;
 	out << '.';
 	if (money.cents < 10)
 		out << '0';
 	out << money.cents;
 }


 /**
  * Print a time in the format HH:MM:SS (two digits each)
  */
 void print (std::ostream& out, Time& t)
 {
     if (t.hours < 10)
         out << '0';
     out << t.hours << ':';
     if (t.minutes < 10)
         out << '0';
     out << t.minutes << ':';
     if (t.seconds < 10)
         out << '0';
     out << t.seconds;
 }



 /**
  * Read a bid from the indicated file
  */
 void read (istream& in, Bid& bid)
 {
 	in >> bid.bidderName;
 	read (in, bid.amount);

 	read (in, bid.bidPlacedAt);

 	string word, line;
 	in >> word; // First word of itemName
 	getline (in, line); // rest of item name

 	bid.itemName = word + line;
 }


 /**
  * Read all bids from the indicated file
  */
 void read (istream& in, BidSequence& bids)
 {
     int nBids;
     in >> nBids;
     bids.size = nBids;
     for (int i = 0; i < nBids; ++i)
     {
         Bid bid;
         read (in, bid);
         bids.data[i] = bid;
     }
 }


 /**
 * Read a bidder from the indicated file
 */
void read (istream& in, Bidder& bidder)
{
	in >> bidder.name;
	read (in, bidder.balance);
}

/**
 * Read all bidders from the indicated file
 */
void read (istream& in, BidderSequence& bidders)
{
    int nBidders;
    in >> nBidders;
    bidders.size = nBidders;
    for (int i = 0; i < nBidders; ++i)
    {
    	read (in, bidders.data[i]);
    }
}


/**
 * Read one item from the indicated file
 */
void read (istream& in, Item& item)
{
  read (in, item.reservedPrice);
  read (in, item.auctionEndsAt);

  // Reading the item name.
  char c;
  in >> c; // Skips blanks and reads first character of the name
  string line;
  getline (in, line); // Read the rest of the line
  item.name = string(1,c) + line;
}


/**
 * Read all items from the indicated file
 */
void read (istream& in, ItemSequence& items)
{
  int nItems;
  in >> nItems;
  items.size = nItems;
  for (int i = 0; i < nItems; ++i)
    read (in, items.data[i]);
}


/**
 * Read a money value from the input.  Acceptable formats are
 *
 *        ddd.cc or ddd
 *
 * where ddd is any positive/negative integer of
 * one or more digits denoting dollars, and cc, if
 * supplied, is a two-digit integer.
 *
 * @param in   stream from which to read
 * @param money the value read in. Result is unpredictable if an I/O error occurs
 */
void read (std::istream& in, Money& money)
{
	if (!in) return;
	in >> money.dollars;
	if (!in) return;
    if (in.peek() == '.') // if next input is a '.'
    {
    	char decimal;
    	in >> decimal;
    	in >> money.cents;
    } else
    	money.cents = 0;
}




/**
 * Determine the winner of the auction for item number i.
 * Announce the winner and remove money from winner's account.
 */
void resolveAuction (const BidSequence& bids, BidderSequence& bidders, const Item& item)
{
  Money zero = {0, 0};
  Money highestBidSoFar = zero;
  string winningBidderSoFar;
  for (int bidNum = 0; bidNum < bids.size; ++bidNum)
    {
      Bid bid = bids.data[bidNum];
      if (noLaterThan(bid.bidPlacedAt, item.auctionEndsAt))
        {
          if (bid.itemName == item.name
            && lessThan(highestBidSoFar, bid.amount)
            && !lessThan(bid.amount, item.reservedPrice)
            )
            {
              int bidderNum = findBidder(bid.bidderName, bidders);
              Bidder bidder = bidders.data[bidderNum];
              // Can this bidder afford it?
              if (!lessThan(bidder.balance, bid.amount))
                {
                  highestBidSoFar = bid.amount;
                  winningBidderSoFar = bid.bidderName;
                }
            }
        }
    }

    // If highestBidSoFar is non-zero, we have a winner
    if (lessThan(zero, highestBidSoFar))
      {
        int bidderNum = findBidder(winningBidderSoFar, bidders);
        cout << item.name
             << " won by " << winningBidderSoFar
             << " for $";
        print (cout, highestBidSoFar);
        cout << endl;
        bidders.data[bidderNum].balance =
        		subtract (bidders.data[bidderNum].balance, highestBidSoFar);
      }
    else
      {
        cout << item.name
             << " reserve not met"
             << endl;
      }
}


/**
 * Read a time from the indicated stream after skipping any
 * leading whitespace
 */
void read (istream& in, Time& t)
{
  char c;
  in >> t.hours >> c >> t.minutes >> c >> t.seconds;
}



/**
 * Subtract one Money amount from another
 *
 * @param left  the minuend
 * @param right the subtrahend
 * @return difference of the two amounts
 */
Money subtract (const Money& left, const Money& right)
{
	Money result;
	result.dollars = left.dollars - right.dollars;
	result.cents = left.cents - right.cents;
	while (result.cents > 99)
	{
		result.cents -= 100;
		++result.dollars;
	}
	while (result.cents < 0)
	{
		result.cents += 100;
		--result.dollars;
	}
	return result;
}

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

#include "items.h"
#include "bidders.h"
#include "bids.h"
#include "times.h"
#include "sequence.h"


/**
 * Determine the winner of the auction for item number i.
 * Announce the winner and remove money from winner's account.
 */
void resolveAuction (const BidSequence& bids, BidderSequence& bidders, const Item& item);



int main (int argc, char** argv)
{
  if (argc != 4)
    {
      cerr << "Usage: " << argv[0] << " itemsFile biddersFile bidsFile" << endl;
      return -1;
    }

  {
	  ifstream itemInput (argv[1]);
	  read (itemInput, items);
  }
  {
	  ifstream bidderInput (argv[2]);
	  read (bidderInput, bidders);
  }
  {
	  ifstream bidInput (argv[3]);
	  read (bidInput, bids);
  }


  for (int i = 0; i < items.size; ++i)
    {
      resolveAuction(bids, bidders, items.data[i]);
    }
  return 0;
}


/**
 * Determine the winner of the auction for item number i.
 * Announce the winner and remove money from winner's account.
 */
void resolveAuction (const BidSequence& bids, BidderSequence& bidders, const Item& item)
{
  Money zero = {0, 0};
  Money highestBidSoFar = zero;
  string winningBidderSoFar;
  for (int bidNum = 0; bidNum < bids.size; ++bidNum)
    {
      Bid bid = bids.data[bidNum];
      if (noLaterThan(bid.bidPlacedAt, item.auctionEndsAt))
        {
          if (bid.itemName == item.name
            && lessThan(highestBidSoFar, bid.amount)
            && !lessThan(bid.amount, item.reservedPrice)
            )
            {
              int bidderNum = findBidder(bid.bidderName, bidders);
              Bidder bidder = bidders.data[bidderNum];
              // Can this bidder afford it?
              if (!lessThan(bidder.balance, bid.amount))
                {
                  highestBidSoFar = bid.amount;
                  winningBidderSoFar = bid.bidderName;
                }
            }
        }
    }

    // If highestBidSoFar is non-zero, we have a winner
    if (lessThan(zero, highestBidSoFar))
      {
        int bidderNum = findBidder(winningBidderSoFar, bidders);
        cout << item.name
             << " won by " << winningBidderSoFar
             << " for $";
        print (cout, highestBidSoFar);
        cout << endl;
        bidders.data[bidderNum].balance =
        		subtract (bidders.data[bidderNum].balance, highestBidSoFar);
      }
    else
      {
        cout << item.name
             << " reserve not met"
             << endl;
      }
}