/*
    * @(#)GameDistributorInteractive.java Jul 8, 2004
    * 
    * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
    * Delft, the Netherlands. All rights reserved.
    * 
    * See for project information <a href="http://www.simulation.tudelft.nl/">
    * www.simulation.tudelft.nl </a>.
    * 
   * The source code and binary code of this software is proprietary information
   * of Delft University of Technology.
   */
  
  package org.gscg.gameactors;
  
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.net.URL;
  import java.rmi.RemoteException;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Properties;
  import java.util.Set;
  
  import javax.vecmath.Point3d;
  
  import nl.tudelft.simulation.actor.messagehandlers.HandleAllMessages;
  import nl.tudelft.simulation.actor.messagehandlers.MessageHandlerInterface;
  import nl.tudelft.simulation.dsol.experiment.TimeUnit;
  import nl.tudelft.simulation.dsol.experiment.TimeUnitInterface;
  import nl.tudelft.simulation.dsol.simulators.AnimatorInterface;
  import nl.tudelft.simulation.dsol.simulators.DEVSSimulatorInterface;
  import nl.tudelft.simulation.dsol.simulators.SimulatorInterface;
  import nl.tudelft.simulation.dsol.statistics.charts.XYChart;
  import nl.tudelft.simulation.event.Event;
  import nl.tudelft.simulation.event.EventInterface;
  import nl.tudelft.simulation.event.EventType;
  import nl.tudelft.simulation.jstats.distributions.DistConstant;
  import nl.tudelft.simulation.jstats.distributions.DistContinuous;
  import nl.tudelft.simulation.jstats.streams.StreamInterface;
  import nl.tudelft.simulation.language.io.URLResource;
  import nl.tudelft.simulation.logger.Logger;
  import nl.tudelft.simulation.messaging.devices.reference.FaxDevice;
  import nl.tudelft.simulation.supplychain.actor.SupplyChainActor;
  import nl.tudelft.simulation.supplychain.actor.Trader;
  import nl.tudelft.simulation.supplychain.banking.Bank;
  import nl.tudelft.simulation.supplychain.banking.BankAccount;
  import nl.tudelft.simulation.supplychain.content.Bill;
  import nl.tudelft.simulation.supplychain.content.Content;
  import nl.tudelft.simulation.supplychain.content.InternalDemand;
  import nl.tudelft.simulation.supplychain.content.Order;
  import nl.tudelft.simulation.supplychain.content.OrderBasedOnQuote;
  import nl.tudelft.simulation.supplychain.content.OrderConfirmation;
  import nl.tudelft.simulation.supplychain.content.Payment;
  import nl.tudelft.simulation.supplychain.content.Quote;
  import nl.tudelft.simulation.supplychain.content.RequestForQuote;
  import nl.tudelft.simulation.supplychain.product.Product;
  import nl.tudelft.simulation.supplychain.roles.Role;
  import nl.tudelft.simulation.supplychain.stock.StockInterface;
  import nl.tudelft.simulation.supplychain.stock.StockUpdateData;
  import nl.tudelft.simulation.supplychain.transport.TransportMode;
  
  import org.gscg.common.gui.exceptions.ReceivedUnknownEventException;
  import org.gscg.common.interactionlayer.AnnounceInterface;
  import org.gscg.common.interactionlayer.timecontrol.GlobalRowOrColumnNumber;
  import org.gscg.experiment.HandlerParser;
  import org.gscg.game.GameGlobalData;
  import org.gscg.singleuser.handlers.InteractiveOrderHandlerStock;
  import org.gscg.singleuser.interactionlayer.SingleUserInteractionLayerInterface;
  import org.gscg.singleuser.interactionlayer.business.statistics.CustomerStatistics;
  import org.gscg.singleuser.interactionlayer.dataobjects.DateIntData;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.BillData;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.QuoteData;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.RFQData;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.RFQDataSuppliers;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.SentOrderConfirmationData;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.SentQuoteData;
  import org.jdom.Element;
  
  /***
   * The GameDistributorInteractive extends a GameDistributor from the
   * supplychain-game project and provides additional interactive functionalities.
   * <br>
   * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
   * Delft, the Netherlands. All rights reserved.
   * 
   * See for project information <a href="http://www.simulation.tudelft.nl/">
   * www.simulation.tudelft.nl </a>.
   * 
   * The source code and binary code of this software is proprietary information
   * of Delft University of Technology.
   * 
   * @author <a
   *         href="http://www.tbm.tudelft.nl/webstaf/alexandv/index.htm">Alexander
   *         Verbraeck </a>
   * @version $Revision: 1.2 $ $Date: 2005/08/09 15:43:40 $
   * @since 1.0.0 <br>
  */
 
 public class GameDistributorInteractive extends GameDistributor implements
 		GameActorInteractiveInterface, AnnounceInterface
 {
 	/*** the map with distributors after deserialization */
 	private static Set distributors = new HashSet();
 
 	/***
 	 * @return returns the set with distributors of which the interactivity mode
 	 *         has changed after deseriliazation due to changes in the
 	 *         distributor.properties file
 	 */
 	public static Set getChangedDistributors()
 	{
 		return GameDistributorInteractive.distributors;
 	}
 
 	/*** the serial version uid */
 	private static final long serialVersionUID = 13L;
 
 	/*** a client has sent an RFQ which forms the basis for a quote */
 	public static final EventType RFQ_SENT_BY_CLIENT_EVENT = new EventType(
 			"RFQ_SENT_BY_CLIENT_EVENT");
 
 	/*** a client has selected a quote which forms the basis for an order */
 	public static final EventType SELECTED_QUOTE_EVENT = new EventType(
 			"SELECTED_QUOTE_EVENT");
 
 	/*** a client has selected a bill to pay */
 	public static final EventType PAY_BILL_EVENT = new EventType(
 			"PAY_BILL_EVENT");
 
 	/*** a client has selected an rfq and sent a quote */
 	public static final EventType QUOTE_SENT_BY_CLIENT_EVENT = new EventType(
 			"QUOTE_SENT_BY_CLIENT_EVENT");
 
 	/*** a client has deleted an rfq */
 	public static final EventType RFQ_DELETED_BY_CLIENT_EVENT = new EventType(
 			"RFQ_DELETED_BY_CLIENT_EVENT");
 
 	/*** a client has confirmed an order */
 	public static final EventType ORDER_CONFIRMATION_SENT_BY_CLIENT_EVENT = new EventType(
 			"ORDER_CONFIRMATION_SENT_BY_CLIENT_EVENT");
 
 	/*** events fired by client */
 	private EventType[] eventsSentByClientArray = {
 			GameDistributorInteractive.ORDER_CONFIRMATION_SENT_BY_CLIENT_EVENT,
 			GameDistributorInteractive.RFQ_SENT_BY_CLIENT_EVENT,
 			GameDistributorInteractive.SELECTED_QUOTE_EVENT,
 			GameDistributorInteractive.PAY_BILL_EVENT,
 			GameDistributorInteractive.QUOTE_SENT_BY_CLIENT_EVENT,
 			GameDistributorInteractive.RFQ_DELETED_BY_CLIENT_EVENT};
 
 	/*** the SingleUserInteractionLayerInterface */
 	private SingleUserInteractionLayerInterface singleUserInteractionLayer;
 
 	/***
 	 * constructs a new GameDistributorInteractive; used when dragging and
 	 * dropping an actor
 	 * 
 	 * @param name the name
 	 * @param simulator the simulator
 	 * @param position the position
 	 * @param bank the bank
 	 */
 	public GameDistributorInteractive(final String name,
 			final DEVSSimulatorInterface simulator, final Point3d position,
 			final Bank bank)
 	{
 		super(name, simulator, position, bank);
 	}
 
 	/***
 	 * constructs a new GameDistributorInteractive
 	 * 
 	 * @param globalSupplyChainData the global supply chain data
 	 * @param name the name
 	 * @param simulator the simulator
 	 * @param position the position
 	 * @param roles the roles to implement
 	 * @param bank the bank
 	 * @param initialBankAccount the initial bank account
 	 * @param product the product
 	 * @param amount the amount
 	 * @param manufacturer the manufacturer
 	 */
 	public GameDistributorInteractive(
 			final GameGlobalData globalSupplyChainData, final String name,
 			final DEVSSimulatorInterface simulator, final Point3d position,
 			final Role[] roles, final Bank bank,
 			final double initialBankAccount, final Product[] product,
 			final Double[] amount, final Trader[] manufacturer)
 	{
 		super(name, simulator, position, roles, bank, initialBankAccount,
 				product, amount, manufacturer, globalSupplyChainData);
 	}
 
 	/***
 	 * constructs a new GameDistributorInteractive
 	 * 
 	 * @param globalSupplyChainData the global supply chain data
 	 * @param name the name
 	 * @param simulator the simulator
 	 * @param position the position
 	 * @param roles the roles to implement
 	 * @param bank the bank
 	 * @param product the product
 	 * @param amount the amount
 	 * @param manufacturer the manufacturer
 	 */
 	public GameDistributorInteractive(
 			final GameGlobalData globalSupplyChainData, final String name,
 			final DEVSSimulatorInterface simulator, final Point3d position,
 			final Role[] roles, final Bank bank, final Product[] product,
 			final Double[] amount, final Trader[] manufacturer)
 	{
 		super(name, simulator, position, roles, bank, product, amount,
 				manufacturer, globalSupplyChainData);
 	}
 
 	/***
 	 * @see org.gscg.gameactors.GameDistributor#init()
 	 */
 	protected void init()
 	{
 		// check whether we are in an interactive mode or
 		// computer-controlled mode
 
 		// read properties
 		Properties properties = new Properties();
 		try
 		{
 			properties.load(URLResource
 					.getResourceAsStream("/distributor.properties"));
 		} catch (Exception exception)
 		{
 			exception.printStackTrace();
 		}
 		if (properties.getProperty(this.name) != null)
 		{
 			String result = properties.getProperty(this.name);
 			if (result.equalsIgnoreCase("false"))
 			{
 				super.humanControlled = false;
 				Logger.info(this, "init", "GameDistributorInteractive: "
 						+ this.name + " set to computer-controlled mode");
 				this.addComputerControlledContentHandlers();
 			} else if (result.equalsIgnoreCase("true"))
 			{
 				try
 				{
 					if (this.simulator.getReplication().getRunControl()
 							.getWarmupPeriod() > 0.0)
 					{
 						// subscribe to warm-up events; these events are used
 						// for building up a history in a game, after the
 						// warmu-up period is finished, and if necessary,
 						// handlers are swapped from a computer-controlled mode
 						// to an interactive mode
 						this.simulator.addListener(this,
 								SimulatorInterface.WARMUP_EVENT);
 						super.humanControlled = false;
 						super.warmingUp = true;
 						Logger
 								.info(
 										this,
 										"init",
 										"GameDistributorInteractive: "
 												+ this.name
 												+ " set to computer-controlled mode due to the presence of a warm-up period.");
 						this.addComputerControlledContentHandlers();
 					} else
 					{
 						super.humanControlled = true;
 						Logger.info(this, "init",
 								"GameDistributorInteractive: " + this.name
 										+ " set to interactive mode");
 						this.addInteractiveContentHandlers();
 					}
 				} catch (RemoteException remoteException)
 				{
 					Logger.severe(this, "init", remoteException);
 				}
 			}
 		} else
 		{
 			// no key found
 			Logger.severe(this, "init",
 					"GameDistributorInteractive: no key found for " + this.name
 							+ " in properties: ." + properties);
 		}
 
 		//
 		// CHARTS
 		//
 		try
 		{
 			if (this.simulator instanceof AnimatorInterface)
 			{
 				XYChart bankChart = new XYChart(this.simulator, "BankAccount "
 						+ this.name);
 				bankChart.add("bank account", this.bankAccount,
 						BankAccount.BANK_ACCOUNT_CHANGED_EVENT);
 			}
 		} catch (RemoteException remoteException)
 		{
 			Logger.severe(this, "init", remoteException);
 		}
 	}
 
 	/***
 	 * @see org.gscg.gameactors.GameDistributor#addDevices()
 	 */
 	protected void addDevices()
 	{
 		try
 		{
 			StreamInterface stream = this.simulator.getReplication().getStream(
 					"default");
 			double hour = TimeUnit.convert(1.0, TimeUnitInterface.HOUR,
 					this.simulator);
 			DistContinuous hourDist = new DistConstant(stream, hour);
 			// give the actor a fax device which is checked every hour
 			FaxDevice fax = new FaxDevice("GameDistributorFax", this.simulator);
 			addSendingDevice(fax);
 			MessageHandlerInterface secretary = new HandleAllMessages(this);
 			addReceivingDevice(fax, secretary, hourDist);
 		} catch (RemoteException remoteException)
 		{
 			Logger.severe(this, "addDevices", remoteException);
 		}
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.AnnounceInterface#announce(nl.tudelft.simulation.event.EventType,
 	 *      boolean)
 	 */
 	public void announce(final EventType eventType, final boolean announce)
 	{
 		if (eventType.equals(StockInterface.STOCK_CHANGE_EVENT))
 		{
 			List products = super.getProductsOnStock();
 			for (int i = 0; i < products.size(); i++)
 			{
 				Product product = (Product) products.get(i);
 				this.stock.getActualAmount(product);
 				StockUpdateData data = new StockUpdateData(product.getName(),
 						this.stock.getActualAmount(product), this.stock
 								.getClaimedAmount(product), this.stock
 								.getOrderedAmount(product));
 				try
 				{
 					this.singleUserInteractionLayer.notifyAnnounced(new Event(
 							StockInterface.STOCK_CHANGE_EVENT, this, data));
 				} catch (RemoteException remoteException)
 				{
 					Logger.severe(this, "announce", remoteException);
 				}
 			}
 			return;
 		}
 		new ReceivedUnknownEventException(this, "announce", eventType);
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.event.EventListenerInterface#notify(nl.tudelft.simulation.event.EventInterface)
 	 */
 	public void notify(final EventInterface event)
 	{
 		if (event.getType().equals(GlobalRowOrColumnNumber.UPDATE_CURRENT_DAY))
 		{
 			// we use these events to update the statistics on a daily basis
 			this.sendStockUpdateEvent();
 			this.bankAccount.sendBalanceUpdateEvent();
 			return;
 		}
 		if (event.getType().equals(
 				GameDistributorInteractive.RFQ_SENT_BY_CLIENT_EVENT))
 		{
 			// make the internal demand
 			RFQDataSuppliers submitRFQData = (RFQDataSuppliers) event
 					.getContent();
 			Product product = this.globalSupplyChainData
 					.getProduct(submitRFQData.getProductName());
 			double earliestDeliveryDate = DateIntData.makeSimulationDate(
 					submitRFQData.getEarliestDelivery(), this.simulator);
 
 			double latestDeliveryDate = DateIntData.makeSimulationDate(
 					submitRFQData.getLatestDelivery(), this.simulator);
 			// we check whether the simulation date is not already further
 			// than the delivery dates, if so we ignore the rfq
 			try
 			{
 				if (earliestDeliveryDate > this.simulator.getSimulatorTime())
 				{
 					InternalDemand internalDemand = new InternalDemand(this,
 							product, submitRFQData.getAmount(),
 							earliestDeliveryDate, latestDeliveryDate);
 					String[] suppliers = submitRFQData.getSuppliers();
 					handleContent(internalDemand);
 					// make the RFQ and send it out to the selected actors
 					for (int i = 0; i < suppliers.length; i++)
 					{
 						SupplyChainActor supplier = this.globalSupplyChainData
 								.getSupplyChainActor(suppliers[i]);
 						RequestForQuote rfq = new RequestForQuote(this,
 								supplier, internalDemand, product,
 								submitRFQData.getAmount());
 						this.sendContent(rfq, 0.0);
 					}
 				} else
 				{
 					Logger
 							.info(
 									this,
 									"notify",
 									"GameDistributorInteractive did not send RFQ since the earliest delivery date has already been passed in the game.");
 				}
 			} catch (RemoteException remoteException)
 			{
 				Logger.severe(this, "notify", remoteException);
 			}
 			return;
 		}
 		if (event.getType().equals(
 				GameDistributorInteractive.SELECTED_QUOTE_EVENT))
 		{
 			QuoteData data = (QuoteData) event.getContent();
 
 			// first create the quote
 			SupplyChainActor sender = this.globalSupplyChainData
 					.getSupplyChainActor(data.getSenderName());
 			try
 			{
 				double proposedDeliveryDate = DateIntData.makeSimulationDate(
 						data.getProposedDelivery(), this.simulator);
 
 				List quotes = super.getGameContentStore().getContentList(
 						data.getRfqData().getInternalDemandIdentifier(),
 						Quote.class, false);
 				OrderBasedOnQuote order = null;
 				for (int i = 0; i < quotes.size(); i++)
 				{
 					Quote quote = (Quote) quotes.get(i);
 					if (quote.getSender().getName().equalsIgnoreCase(
 							sender.getName()))
 					{
 						order = new OrderBasedOnQuote(quote.getReceiver(),
 								quote.getSender(), data.getRfqData()
 										.getInternalDemandIdentifier(),
 								proposedDeliveryDate, quote);
 						break;
 					}
 				}
 
 				// let the interactive quote handler know that
 				// we have handled a quote for a rfq
 				// we block further quotes for this rfq
 				if (order != null)
 				{
 					super.interactiveQuoteHandler.addAnsweredQuote(order
 							.getQuote());
 				}
 
 				this.sendContent(order, 0.0);
 
 				// remove the quotes from the content store
 				for (int i = 0; i < quotes.size(); i++)
 				{
 					super.getGameContentStore().removeContent(
 							(Content) quotes.get(i), false);
 				}
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "notify", exception);
 			}
 			return;
 		}
 		if (event.getType().equals(GameDistributorInteractive.PAY_BILL_EVENT))
 		{
 			BillData data = (BillData) event.getContent();
 			Bill bill = (Bill) super.getGameContentStore().getContentList(
 					data.getInternalDemandID(), Bill.class, false).get(0);
 			if (bill == null)
 			{
 				Logger.severe(this, "notify PAY_BILL_EVENT",
 						"bill not found in ContentStore");
 			} else
 			{
 				// we pay the bill
 				this.pay(bill);
 
 				// create the payment and send it out
 				Payment payment = new Payment(bill.getReceiver(), bill
 						.getSender(), bill.getInternalDemandID(), bill, bill
 						.getPrice());
 				this.sendContent(payment, 0.0);
 			}
 			return;
 		}
 		if (event.getType().equals(
 				GameDistributorInteractive.QUOTE_SENT_BY_CLIENT_EVENT))
 		{
 			SentQuoteData data = (SentQuoteData) event.getContent();
 			try
 			{
 				SupplyChainActor sender = this.globalSupplyChainData
 						.getSupplyChainActor(data.getSenderName());
 				SupplyChainActor receiver = this.globalSupplyChainData
 						.getSupplyChainActor(data.getReceiverName());
 
 				// find the rfq
 				List rfqs = super.getGameContentStore().getContentList(
 						data.getRfqData().getInternalDemandIdentifier(),
 						RequestForQuote.class, false);
 				RequestForQuote rfq = null;
 				for (int i = 0; i < rfqs.size(); i++)
 				{
 					RequestForQuote result = (RequestForQuote) rfqs.get(i);
 					if (result.getReceiver().getName().equalsIgnoreCase(
 							sender.getName()))
 					{
 						rfq = result;
 						break;
 					}
 				}
 
 				double proposedDeliveryDate = DateIntData.makeSimulationDate(
 						data.getProposedDelivery(), this.simulator);
 
 				if (proposedDeliveryDate > this.simulator.getSimulatorTime())
 				{
 					double price = data.getPrice();
 					// we add the transportation costs
 					double weight = rfq.getAmount()
 							* rfq.getProduct().getAverageUnitWeight();
 
 					// calculate the costs based on the the lat lon distance!
 					double transportCosts = TransportMode.PLANE.transportCosts(
 							super.latLonDistanceCalculator.getDistance(rfq
 									.getSender(), rfq.getReceiver()), weight);
 
 					// add the transport costs to the price
 					price += transportCosts;
 
 					Quote quote = new Quote(sender, receiver, data.getRfqData()
 							.getInternalDemandIdentifier(), rfq, rfq
 							.getProduct(), data.getAmount(), price,
 							proposedDeliveryDate, TransportMode.PLANE);
 					this.sendContent(quote, 0.0);
 				} else
 				{
 					Logger
 							.info(
 									this,
 									"notify",
 									"GameDistributorInteractive did not send Quote since the proposed delivery date has already been passed in the game. The accompanying rfq has been deleted.");
 
 					// delete the rfq from the erp sysem
 					super.getGameContentStore().removeContent(rfq, false);
 				}
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "notify", exception);
 			}
 			return;
 		}
 		if (event.getType().equals(
 				GameDistributorInteractive.RFQ_DELETED_BY_CLIENT_EVENT))
 		{
 			RFQData data = (RFQData) event.getContent();
 			try
 			{
 				SupplyChainActor receiver = this.globalSupplyChainData
 						.getSupplyChainActor(data.getReceiverName());
 
 				// find the rfq
 				List rfqs = super.getGameContentStore().getContentList(
 						data.getInternalDemandIdentifier(),
 						RequestForQuote.class, false);
 				RequestForQuote rfq = null;
 				for (int i = 0; i < rfqs.size(); i++)
 				{
 					RequestForQuote result = (RequestForQuote) rfqs.get(i);
 					if (result.getReceiver().getName().equalsIgnoreCase(
 							receiver.getName()))
 					{
 						rfq = result;
 						break;
 					}
 				}
 
 				// delete the rfq from the erp sysem
 				super.getGameContentStore().removeContent(rfq, false);
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "notify", exception);
 			}
 			return;
 
 		}
 		if (event
 				.getType()
 				.equals(
 						GameDistributorInteractive.ORDER_CONFIRMATION_SENT_BY_CLIENT_EVENT))
 		{
 			SentOrderConfirmationData data = (SentOrderConfirmationData) event
 					.getContent();
 			try
 			{
 				SupplyChainActor sender = this.globalSupplyChainData
 						.getSupplyChainActor(data.getSenderName());
 				SupplyChainActor receiver = this.globalSupplyChainData
 						.getSupplyChainActor(data.getReceiverName());
 				Order order = (Order) super.getGameContentStore()
 						.getContentList(
 								data.getOrderData().getInternalDemandID(),
 								Order.class, false).get(0);
 				if (order == null)
 				{
 					Logger.severe(this,
 							"notify ORDER_CONFIRMATION_SENT_BY_CLIENT_EVENT",
 							"order not found in ContentStore");
 				} else
 				{
 					OrderConfirmation confirmation = new OrderConfirmation(
 							sender, receiver, data.getOrderData()
 									.getInternalDemandID(), order, data
 									.getConfirmationStatus());
 
 					this.sendContent(confirmation, 0.0);
 					InteractiveOrderHandlerStock handler = new InteractiveOrderHandlerStock(
 							this, super.stock);
 					handler.handleOrder(order);
 
 					// generate the customer statistics
 					super.customerStatistics.handleContent(confirmation);
 				}
 				return;
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "notify", exception);
 			}
 			return;
 		}
 		if (event.getType().equals(SimulatorInterface.WARMUP_EVENT))
 		{
 			super.humanControlled = true;
 			super.warmingUp = false;
 			Logger
 					.info(
 							this,
 							"init",
 							"GameDistributorInteractive: "
 									+ this.name
 									+ " set to interactive mode since the warm-up period has been finished");
 			this.addInteractiveContentHandlers();
 			return;
 		}
 		new ReceivedUnknownEventException(this, "notify", event.getType());
 	}
 
 	/***
 	 * pays the bill
 	 * 
 	 * @param bill the bill to pay
 	 */
 	public void pay(final Bill bill)
 	{
 		this.bankAccount.withdrawFromBalance(bill.getPrice());
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.content.HandlerInterface#handleContent(java.io.Serializable)
 	 */
 	public boolean handleContent(final Serializable content)
 	{
 		try
 		{
 			if (super.humanControlled)
 			{
 				if (content instanceof Quote)
 				{
 					// handle with the special interactive quote handler
 					if (super.interactiveQuoteHandler.handleContent(content))
 					{
 						// save content in the content store
 						super.getContentStore().addContent((Content) content,
 								false);
 					}
 					return true;
 				}
 			}
 			return super.handleContent(content);
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "handleContent", exception);
 			return false;
 		}
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.supplychain.actor.SupplyChainActor#sendContent(nl.tudelft.simulation.supplychain.content.Content,
 	 *      double)
 	 */
 	public void sendContent(final Content content,
 			final double administrativeDelay)
 	{
 		super.sendContent(content, administrativeDelay);
 	}
 
 	/***
 	 * @see org.gscg.gameactors.GameActorInteractiveInterface#getSingleUserInteractionLayer()
 	 */
 	public SingleUserInteractionLayerInterface getSingleUserInteractionLayer()
 	{
 		return this.singleUserInteractionLayer;
 	}
 
 	/***
 	 * @see org.gscg.gameactors.GameActorInteractiveInterface#setSingleUserInteractionLayer(org.gscg.singleuser.interactionlayer.SingleUserInteractionLayerInterface)
 	 */
 	public void setSingleUserInteractionLayer(
 			final SingleUserInteractionLayerInterface singleUserInteractionLayer)
 	{
 		this.singleUserInteractionLayer = singleUserInteractionLayer;
 		getGameContentStore().setSingleUserInteractionlayer(
 				this.singleUserInteractionLayer);
 
 		try
 		{
 			for (int i = 0; i < this.eventsSentByClientArray.length; i++)
 			{
 				this.singleUserInteractionLayer.addListener(this,
 						this.eventsSentByClientArray[i], false);
 
 				this.singleUserInteractionLayer
 						.addEventTypeSentByClient(this.eventsSentByClientArray[i]);
 
 			}
 
 			// announce to update the stock
 			// add the announce events
 			singleUserInteractionLayer.addEventTypeToAnnounceList(
 					StockInterface.STOCK_CHANGE_EVENT, this);
 
 			//
 			// listeners
 			//
 			// subscribe for time change events on a daily basis these
 			// events are used to update client side statistics on a daily basis
 			this.singleUserInteractionLayer.addListener(this,
 					GlobalRowOrColumnNumber.UPDATE_CURRENT_DAY);
 		} catch (RemoteException remoteException)
 		{
 			Logger.severe(this, "<init>", remoteException);
 		}
 
 		//
 		// CUSTOMER STATISTICS
 		//
 		this.customerStatistics = new CustomerStatistics(this.simulator,
 				this.singleUserInteractionLayer);
 	}
 
 	/***
 	 * adds computer-controlled interactive content handlers
 	 */
 	public void addComputerControlledContentHandlers()
 	{
 		super.addComputerControlledContentHandlers();
 	}
 
 	/***
 	 * adds interactive content handlers
 	 */
 	public void addInteractiveContentHandlers()
 	{
 		// remove all previus content handlers
 		this.removeAllContentHandlers();
 
 		// look for our personal xml file with handler description
 		URL url = URLResource.getResource("/" + this.name + "_interactive.xml");
 		if (url == null)
 		{
 			url = URLResource
 					.getResource("/distributor_interactive_default_handler.xml");
 		}
 		Logger
 				.info(
 						this,
 						"addInteractiveContentHandlers",
 						"Using: "
 								+ url.toExternalForm()
 								+ " as the file containing the configuration for the handlers.");
 		try
 		{
 			// let's parse the xml file data to handlers
 			Element rootElement = GameDistributor.builder.build(url)
 					.getRootElement();
 			HandlerParser.parseAndAddHandler(this, rootElement);
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "addInteractiveContentHandlers", exception);
 		}
 	}
 
 	// private methods
 	/***
 	 * Method sendStockUpdateEvent fires an update for all the products
 	 * available in the stock
 	 */
 	private void sendStockUpdateEvent()
 	{
 		for (Iterator i = this.stock.iterator(); i.hasNext();)
 		{
 			this.stock.sendStockUpdateEvent((Product) i.next());
 		}
 	}
 
 	/***
 	 * writes a serializable method to stream
 	 * 
 	 * @param out the outputstream
 	 * @throws IOException on IOException
 	 */
 	private synchronized void writeObject(final ObjectOutputStream out)
 			throws IOException
 	{
 		out.defaultWriteObject();
 	}
 
 	/***
 	 * reads a serializable method from stream
 	 * 
 	 * @param in the inputstream
 	 */
 	private synchronized void readObject(final java.io.ObjectInputStream in)
 	{
 		try
 		{
 			in.defaultReadObject();
 
 			// check whether we are in an interactive mode or
 			// computer-controlled mode
 			// read properties
 			Properties properties = new Properties();
 			try
 			{
 				properties.load(URLResource
 						.getResourceAsStream("/distributor.properties"));
 			} catch (Exception exception)
 			{
 				exception.printStackTrace();
 			}
 			if (properties.getProperty(this.name) != null)
 			{
 				String result = properties.getProperty(this.name);
 				if (result.equalsIgnoreCase("false"))
 				{
 					// only if there has been a change in the properties file
 					// we put 'this' in the set, this set is evaluated by the
 					// game management project (LoadGame.deserializeGame) after
 					// all the actors have been deserialized, otherwise the
 					// references between objects are not set yet
 					if (super.humanControlled)
 					{
 						GameDistributorInteractive.distributors.add(this);
 						super.humanControlled = false;
 						System.out
 								.println("GameDistributorInteractive: "
 										+ this.name
 										+ ": mode has been changed to computer-controlled mode");
 					}
 				} else if (result.equalsIgnoreCase("true"))
 				{
 					// only if there has been a change in the properties file
 					// we put 'this' in the set, this set is evaluated by the
 					// game management project (LoadGame.deserializeGame) after
 					// all the actors have been deserialized, otherwise the
 					// references between objects are not set yet
 					// furthermore, the warm-up period must be finished
 					if (!super.humanControlled && !super.warmingUp)
 					{
 						System.out
 								.println("GameDistributorInteractive: Deserializing: "
 										+ this + " warm-up finished");
 						GameDistributorInteractive.distributors.add(this);
 						super.humanControlled = true;
 						System.out
 								.println("GameDistributorInteractive: "
 										+ this.name
 										+ ": mode has been changed to interactive mode");
 					} else if (!super.humanControlled)
 					{
 						System.out.println("Deserializing: " + this
 								+ " however warm-up not finished yet");
 					}
 				}
 			} else
 			{
 				// no key found
 				System.out
 						.println("GameDistributorInteractive: no key found for "
 								+ this.name + " in properties.");
 			}
 		} catch (IOException exception)
 		{
 			Logger.severe(this, "readObject", exception);
 		} catch (ClassNotFoundException exception)
 		{
 			Logger.severe(this, "readObject", exception);
 		}
 	}
 }