/*
    * @(#)GameManufacturer.java Apr 25, 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.net.URL;
  import java.rmi.RemoteException;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.media.j3d.Bounds;
  import javax.vecmath.Point2d;
  import javax.vecmath.Point3d;
  
  import nl.tudelft.simulation.actor.messagehandlers.HandleAllMessages;
  import nl.tudelft.simulation.actor.messagehandlers.MessageHandlerInterface;
  import nl.tudelft.simulation.content.HandlerInterface;
  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.statistics.charts.XYChart;
  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.d3.BoundingBox;
  import nl.tudelft.simulation.language.d3.DirectedPoint;
  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.Content;
  import nl.tudelft.simulation.supplychain.content.InternalDemand;
  import nl.tudelft.simulation.supplychain.content.Order;
  import nl.tudelft.simulation.supplychain.handlers.InternalDemandHandlerRFQ;
  import nl.tudelft.simulation.supplychain.product.Product;
  import nl.tudelft.simulation.supplychain.reference.Manufacturer;
  import nl.tudelft.simulation.supplychain.roles.Role;
  import nl.tudelft.simulation.supplychain.stock.Stock;
  
  import org.gscg.common.GameActorInterface;
  import org.gscg.common.geo.CalculateLatLonDistance;
  import org.gscg.experiment.HandlerParser;
  import org.gscg.game.GameActorContentStore;
  import org.gscg.game.GameGlobalData;
  import org.gscg.gameleader.animation2D.GisActorAnimation;
  import org.gscg.singleuser.handlers.InteractiveQuoteHandler;
  import org.gscg.singleuser.interactionlayer.business.statistics.CustomerStatistics;
  import org.gscg.singleuser.interactionlayer.dataobjects.DateIntData;
  import org.gscg.singleuser.interactionlayer.dataobjects.content.RFQDataSuppliers;
  import org.jdom.Element;
  import org.jdom.input.SAXBuilder;
  
  /***
   * The GameManufacturer extends a Manufacturer from the supplychain project and
   * provides additional game-specific functionalities.
   * <p>
   * 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.4 $ $Date: 2005/08/10 11:23:30 $
   * @since 1.0.0 <br>
   */
  
  public class GameManufacturer extends Manufacturer implements
  		GameActorInterface, GameInteractiveActorRoleInterface
  {
  	/*** builder the xerces parser with validation turned on */
  	protected static SAXBuilder builder = new SAXBuilder(
  			"org.apache.xerces.parsers.SAXParser", true);
  
  	static
 	{
 		// turns on Schema Validation with Xerces
 		GameManufacturer.builder.setFeature(
 				"http://xml.org/sax/features/validation", true);
 		GameManufacturer.builder.setFeature(
 				"http://apache.org/xml/features/validation/schema", true);
 
 		// Let's find the XSD file
 		String xsd = URLResource.getResource("/handler.xsd").toExternalForm();
 		GameManufacturer.builder
 				.setProperty(
 						"http://apache.org/xml/properties/schema/external-schemaLocation",
 						"http://www.simulation.tudelft.nl/dsol " + xsd);
 	}
 
 	/*** the serial version uid */
 	private static final long serialVersionUID = 12L;
 
 	/*** debug */
 	private static final boolean DEBUG = false;
 
 	/*** the suppliers where the GameManufacturer buys */
 	protected Trader[] suppliers;
 
 	/*** the global supply chain game data */
 	protected GameGlobalData globalSupplyChainData = null;
 
 	/*** the customer statistisc for this player */
 	protected CustomerStatistics customerStatistics = null;
 
 	/*** the special interactive quotehander */
 	protected InteractiveQuoteHandler interactiveQuoteHandler = null;
 
 	/*** if true than we use any human intervention */
 	protected boolean humanControlled = false;
 
 	/*** true for warming-up */
 	protected boolean warmingUp = false;
 
 	/*** the lat lon distance calculator to use */
 	protected CalculateLatLonDistance latLonDistanceCalculator = null;
 
 	/*** the location on the small map */
 	private DirectedPoint smallMapLocation = new DirectedPoint();
 
 	/*** the animation used for serialization */
 	private GisActorAnimation animation = null;
 
 
 	/*** the map with product names and their suppliers */
 	private Map productNameToSuppliers = null;
 
 	/***
 	 * constructs a new GameManufacturer; used when dragging and dropping an
 	 * actor
 	 * 
 	 * @param name the name
 	 * @param simulator the simulator
 	 * @param position the position
 	 * @param bank the bank
 	 */
 	public GameManufacturer(final String name,
 			final DEVSSimulatorInterface simulator, final Point3d position,
 			final Bank bank)
 	{
 		super(name, simulator, position, new Role[]{}, bank);
 		this.initAnimation();
 	}
 
 	/***
 	 * constructs a new GameManufacturer
 	 * 
 	 * @param name the name
 	 * @param simulator the simulator
 	 * @param position the position on the map
 	 * @param roles the roles to implement
 	 * @param bank the bank
 	 * @param product the product
 	 * @param amount the amount
 	 * @param globalSupplyChainData the global supply chain data
 	 * @param suppliers the suppliers
 	 */
 	public GameManufacturer(final String name,
 			final DEVSSimulatorInterface simulator, final Point3d position,
 			final Role[] roles, final Bank bank, final Product[] product,
 			final Double[] amount, final GameGlobalData globalSupplyChainData,
 			final Trader[] suppliers)
 	{
 		this(name, simulator, position, roles, bank, 0.0, product, amount,
 				globalSupplyChainData, suppliers);
 	}
 
 	/***
 	 * constructs a new GameManufacturer
 	 * 
 	 * @param name the name
 	 * @param simulator the simulator
 	 * @param position the position on the map
 	 * @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 globalSupplyChainData the global supply chain data
 	 * @param suppliers the suppliers
 	 */
 	public GameManufacturer(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 GameGlobalData globalSupplyChainData,
 			final Trader[] suppliers)
 	{
 		super(name, simulator, position, roles, bank, initialBankAccount);
 		super.setContentStore(new GameActorContentStore(this, simulator));
 		this.suppliers = (Trader[]) suppliers.clone();
 		this.globalSupplyChainData = globalSupplyChainData;
 		this.latLonDistanceCalculator = new CalculateLatLonDistance();
 
 		// make a map which keeps track which manufacturer supplies what
 		// products
 		this.productNameToSuppliers = new HashMap();
 		for (int i = 0; i < this.suppliers.length; i++)
 		{
 			Trader trader = this.suppliers[i];
 			List productsOnStock = trader.getProductsOnStock();
 			for (int ii = 0; ii < productsOnStock.size(); ii++)
 			{
 				Product productOnStock = (Product) productsOnStock.get(ii);
 				if (GameManufacturer.DEBUG)
 				{
 					System.out
 							.println("DEBUG -- GameManufacturer: <init> : supplier: "
 									+ trader.getName()
 									+ "has product: "
 									+ productOnStock.getName() + " on stock");
 				}
 				if (!this.productNameToSuppliers.containsKey(productOnStock
 						.getName()))
 				{
 					this.productNameToSuppliers.put(productOnStock.getName(),
 							new HashSet());
 				}
 				Set set = (Set) this.productNameToSuppliers.get(productOnStock
 						.getName());
 				set.add(trader);
 				this.productNameToSuppliers.put(productOnStock.getName(), set);
 			}
 		}
 
 		// give the manufacturer some stock
 		Stock stock = new Stock(this);
 		for (int i = 0; i < product.length; i++)
 		{
 			stock.addStock(product[i], amount[i].doubleValue(), amount[i]
 					.doubleValue()
 					* product[i].getUnitMarketPrice());
 		}
 		super.setInitialStock(stock);
 
 		// add the devices
 		this.addDevices();
 
 		// We initialize GameManufacturer
 		this.init();
 
 		// may be initialized earlier during modeling of supply chain game
 		if (this.animation == null)
 		{
 			this.initAnimation();
 		}
 	}
 
 	/***
 	 * Initializes the animation.
 	 */
 	private void initAnimation()
 	{
 		// Let's give PCManufacturer its corresponding image
 		this.animation = new GisActorAnimation(
 				this,
 				this.simulator,
 				GameManufacturer.class
 						.getResource("/nl/tudelft/simulation/supplychain/images/Manufacturer.gif"));
 	}
 
 	/***
 	 * Method init
 	 */
 	protected void init()
 	{
 		this.addComputerControlledContentHandlers();
 		try
 		{
 			//
 			// CHARTS
 			//
 			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);
 		}
 
 		if (GameManufacturer.DEBUG)
 		{
 			System.out.println("GameManufacturer: player: " + this.name
 					+ " initialized.");
 		}
 	}
 
 	/***
 	 * adds computer-controlled interactive content handlers
 	 */
 	protected void addComputerControlledContentHandlers()
 	{
 		// remove all previous content handlers
 		this.removeAllContentHandlers();
 
 		// look for our personal xml file with handler description
 		URL url = URLResource.getResource("/" + this.name
 				+ "_computer_controlled.xml");
 		url=null;
 		if (url == null)
 		{
 			url = URLResource.getResource("/manufacturer_default_handler.xml");
 		}
 		Logger
 				.info(
 						this,
 						"addComputerControlledContentHandlers",
 						"Using: "
 								+ url.toExternalForm()
 								+ " as the file containing the configuration for the handlers.");
 		try
 		{
 			// let's parse the xml file data to handlers
 			Element rootElement = GameManufacturer.builder.build(url)
 					.getRootElement();
 			HandlerParser.parseAndAddHandler(this, rootElement);
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "addComputerControlledContentHandlers",
 					exception);
 		}
 
 		// after all handlers have been added we check whether there is an
 		// internal demand handler for rfq's
 		if (this.contentHandlers.containsKey(InternalDemand.class))
 		{
 			Set resolvedHandlers = (Set) this.contentHandlers
 					.get(InternalDemand.class);
 			for (Iterator resolvedHandlersIterator = resolvedHandlers
 					.iterator(); resolvedHandlersIterator.hasNext();)
 			{
 				HandlerInterface handler = (HandlerInterface) resolvedHandlersIterator
 						.next();
 
 				if (handler instanceof InternalDemandHandlerRFQ)
 				{
 					Iterator productIterator = this.getStock().iterator();
 					while (productIterator.hasNext())
 					{
 						Product product = (Product) productIterator.next();
 						Set suppliers = (Set) this.getProductNameToSuppliers()
 								.get(product.getName());
 
 						if (suppliers != null)
 						{
 							for (Iterator supplierIterator = suppliers
 									.iterator(); supplierIterator.hasNext();)
 							{
 								((InternalDemandHandlerRFQ) handler)
 										.addSupplier(product,
 												(Trader) supplierIterator
 														.next());
 								if (GameManufacturer.DEBUG)
 								{
 
 									System.out
 											.println("DEBUG -- GameManufacturer: addComputerControlledContentHandlers : added supplier to internaldemand handler rfq");
 								}
 							}
 						} else
 						{
 							Logger.warning(this,
 									"addComputerControlledContentHandlers",
 									"No suppliers found for product: "
 											+ product);
 						}
 					}
 				}
 			}
 		}
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.supplychain.actor.SupplyChainActor#sendContent(nl.tudelft.simulation.supplychain.content.Content, double)
 	 */
 	public void sendContent(final Content content,
 			final double administrativeDelay)
 	{
 		//TODO is this method still needed?
 		// we snoop the orders for statististical analysis
 		if (content instanceof Order)
 		{
 			// let's send to the statistics
 		}
 		super.sendContent(content, administrativeDelay);
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.animation.LocatableInterface#getBounds()
 	 */
 	public Bounds getBounds()
 	{
 		return new BoundingBox(1.0, 1.0, 0.0);
 	}
 
 	/***
 	 * @see org.gscg.gameactors.GameInteractiveActorRoleInterface#getGameContentStore()
 	 */
 	public GameActorContentStore getGameContentStore()
 	{
 		return (GameActorContentStore) super.getContentStore();
 	}
 
 	/***
 	 * Method getContent returns all data objects of type contentClass
 	 * 
 	 * @param contentClass the content class to look for
 	 * @param sent indicates whether the content is sent or received
 	 * @param productName the name of the product
 	 */
 	public void fireAllContentData(final Class contentClass,
 			final boolean sent, final String productName)
 	{
 		getGameContentStore().fireAllProductContentData(contentClass, sent,
 				productName);
 	}
 
 	/***
 	 * Method fireAllNumberData.
 	 */
 	public void fireAllNumberData()
 	{
 		Collection products = this.globalSupplyChainData.getProducts();
 		Iterator prodIter = products.iterator();
 		while (prodIter.hasNext())
 		{
 			Product product = (Product) prodIter.next();
 			getGameContentStore().fireAllProductNumberData(product.getName());
 		}
 	}
 
 	/***
 	 * @param productName the product we want
 	 * @return an initialized RFQData object with potential suppliers
 	 */
 	public RFQDataSuppliers getInitialRFQData(final String productName)
 	{
 		double day = 0;
 		try
 		{
 			day = TimeUnit.convert(1, TimeUnitInterface.DAY, this.simulator);
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "getInitialRFQData", "TimeUnit.convert failed");
 		}
 
 		// TODO the desired earliest and delivery date should not be hard-coded
 		double earliestDeliveryDate = this.getSimulatorTime() + 14 * day;
 		double defaultAmount = 100;
 		double latestDeliveryDate = earliestDeliveryDate + 7.0 * day;
 
 		String[] supplierNames = new String[0];
 		String[] supplierNickNames = new String[0];
 		Point2d ownLocation = new Point2d(this.getLocation().x, this
 				.getLocation().y);
 		Point2d[] suppliersLocations = new Point2d[0];
 
 		Set suppliers = (Set) this.productNameToSuppliers.get(productName);
 		if (suppliers != null)
 		{
 			supplierNames = new String[suppliers.size()];
 			supplierNickNames = new String[suppliers.size()];
 			suppliersLocations = new Point2d[suppliers.size()];
 
 			int counter = 0;
 			for (Iterator it = suppliers.iterator(); it.hasNext();)
 			{
 				Trader trader = (Trader) it.next();
 				supplierNames[counter] = trader.getName();
 				supplierNickNames[counter] = trader.getLocationDescription();
 				suppliersLocations[counter] = new Point2d(
 						trader.getLocation().x, trader.getLocation().y);
 				counter++;
 			}
 		}
 		return new RFQDataSuppliers(this.name, supplierNames,
 				supplierNickNames, DateIntData.makeDateIntData(
 						earliestDeliveryDate, this.simulator), DateIntData
 						.makeDateIntData(latestDeliveryDate, this.simulator),
 				defaultAmount, productName, ownLocation, suppliersLocations);
 	}
 
 	/***
 	 * @return Returns the smallMapLocation.
 	 */
 	public DirectedPoint getSmallMapLocation()
 	{
 		return this.smallMapLocation;
 	}
 
 	/***
 	 * @param smallMapLocation The smallMapLocation to set.
 	 */
 	public void setSmallMapLocation(final DirectedPoint smallMapLocation)
 	{
 		this.smallMapLocation = smallMapLocation;
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.actor.ActorInterface#getName()
 	 */
 	public String getName()
 	{
 		return this.name;
 	}
 
 	/***
 	 * @return Returns the animation
 	 */
 	protected GisActorAnimation getAnimation()
 	{
 		return this.animation;
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.supplychain.actor.SupplyChainActor#calculateDistance(nl.tudelft.simulation.supplychain.actor.SupplyChainActor)
 	 */
 	public double calculateDistance(final SupplyChainActor actor)
 	{
 		return new CalculateLatLonDistance().getDistance(new Point2d(
 				this.location.x, this.location.y), new Point2d(actor
 				.getLocation().x, actor.getLocation().y));
 	}
 
 	/***
 	 * @return Returns the productNameToSuppliers.
 	 */
 	public Map getProductNameToSuppliers()
 	{
 		return this.productNameToSuppliers;
 	}
 
 	/***
 	 * @return true if human controlled, false otherwise
 	 */
 	public boolean isHumanControlled()
 	{
 		return this.humanControlled;
 	}
 
 	/***
 	 * sets the interactive quote handler
 	 * 
 	 * @param interactiveQuoteHandler the interactive quote handler to set
 	 */
 	public void setInteractiveQuoteHandler(
 			final InteractiveQuoteHandler interactiveQuoteHandler)
 	{
 		this.interactiveQuoteHandler = interactiveQuoteHandler;
 	}
 
 	/***
 	 * removes all the content handlers
 	 */
 	protected void removeAllContentHandlers()
 	{
 		super.contentHandlers.clear();
 	}
 
 	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("GameManufacturerFax", this.simulator);
 			addSendingDevice(fax);
 			MessageHandlerInterface secretary = new HandleAllMessages(this);
 			addReceivingDevice(fax, secretary, hourDist);
 		} catch (RemoteException remoteException)
 		{
 			Logger.severe(this, "addDevices", remoteException);
 		}
 	}
 }