package org.opentrafficsim.road.network.factory.xml.demand;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.Serializable;
   import java.net.URL;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.SortedSet;
  import java.util.TreeSet;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.djunits.unit.TimeUnit;
  import org.djunits.value.StorageType;
  import org.djunits.value.vdouble.scalar.Time;
  import org.djunits.value.vdouble.vector.FrequencyVector;
  import org.djunits.value.vdouble.vector.TimeVector;
  import org.opentrafficsim.base.parameters.ParameterException;
  import org.opentrafficsim.core.gtu.GTUType;
  import org.opentrafficsim.core.gtu.NestedCache;
  import org.opentrafficsim.core.gtu.Try;
  import org.opentrafficsim.core.network.OTSNetwork;
  import org.opentrafficsim.core.network.factory.xml.units.TimeUnits;
  import org.opentrafficsim.road.gtu.generator.od.ODApplier;
  import org.opentrafficsim.road.gtu.generator.od.ODOptions;
  import org.opentrafficsim.road.gtu.strategical.od.Categorization;
  import org.opentrafficsim.road.gtu.strategical.od.Category;
  import org.opentrafficsim.road.gtu.strategical.od.Interpolation;
  import org.opentrafficsim.road.gtu.strategical.od.ODMatrix;
  import org.opentrafficsim.road.network.factory.xml.XMLParser;
  import org.opentrafficsim.road.network.factory.xml.XmlParserException;
  import org.w3c.dom.Document;
  import org.w3c.dom.NamedNodeMap;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  import org.xml.sax.SAXException;
  
  import nl.tudelft.simulation.dsol.SimRuntimeException;
  import nl.tudelft.simulation.dsol.simulators.DEVSSimulatorInterface;
  import nl.tudelft.simulation.language.Throw;
  
  /**
   * OD parser.
   * <p>
   * Copyright (c) 2013-2018 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
   * BSD-style license. See <a href="http://opentrafficsim.org/node/13">OpenTrafficSim License</a>.
   * <p>
   * @version $Revision$, $LastChangedDate$, by $Author$, initial version 25 mei 2018 <br>
   * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
   * @author <a href="http://www.transport.citg.tudelft.nl">Wouter Schakel</a>
   */
  public class XmlOdParser implements Serializable
  {
  
      /** */
      private static final long serialVersionUID = 20180525L;
  
      /** Simulator. */
      private final DEVSSimulatorInterface.TimeDoubleUnit simulator;
  
      /** Network. */
      final OTSNetwork network;
  
      /** GTU types. */
      private final Map<String, GTUType> gtuTypes = new HashMap<>();
  
      /** Categorization. */
      Categorization categorization;
  
      /** Categories. */
      Map<String, CategoryTag> categories = new LinkedHashMap<>();
  
      /** Global time vector. */
      TimeVector globalTime;
  
      /** Global interpolation. */
      Interpolation globalInterpolation;
  
      /** Demand. */
      NestedCache<Set<DemandTag>> demand =
              new NestedCache<>(org.opentrafficsim.core.network.Node.class, org.opentrafficsim.core.network.Node.class);
  
      /**
       * Constructor.
       * @param simulator DEVSSimulatorInterface.TimeDoubleUnit; simulator
       * @param network OTSNetwork; network
       * @param gtuTypes Set; set of GTU types
       */
      public XmlOdParser(final DEVSSimulatorInterface.TimeDoubleUnit simulator, final OTSNetwork network, final Set<GTUType> gtuTypes)
     {
         Throw.whenNull(simulator, "Simulator should not be null.");
         Throw.whenNull(network, "Network should not be null.");
         this.simulator = simulator;
         this.network = network;
         for (GTUType gtuType : gtuTypes)
         {
             this.gtuTypes.put(gtuType.getId(), gtuType);
         }
     }
 
     /**
      * Returns the GTU type for the given id.
      * @param id String; id
      * @return GTU type for the given id
      * @throws XmlParserException if the GTU type is not available
      */
     public GTUType getGTUType(final String id) throws XmlParserException
     {
         Throw.when(!this.gtuTypes.containsKey(id), XmlParserException.class, "GTU type %s is not available.", id);
         return this.gtuTypes.get(id);
     }
 
     /**
      * Applies demand from URL.
      * @param url URL; URL to file
      * @throws XmlParserException if URL cannot be parsed
      */
     public final void apply(final URL url) throws XmlParserException
     {
         apply(url, new ODOptions());
     }
 
     /**
      * Applies demand from URL using OD options.
      * @param url URL; URL to file
      * @param odOptions ODOptions; OD options
      * @throws XmlParserException if URL cannot be parsed
      */
     public void apply(final URL url, final ODOptions odOptions) throws XmlParserException
     {
         try
         {
             apply(url.openStream(), odOptions);
         }
         catch (IOException exception)
         {
             throw new XmlParserException(exception);
         }
     }
 
     /**
      * Applies demand from stream.
      * @param stream InputStream; stream
      * @throws XmlParserException if URL cannot be parsed
      */
     public final void apply(final InputStream stream) throws XmlParserException
     {
         apply(stream, new ODOptions());
     }
 
     /**
      * Applies demand from stream using OD options.
      * @param stream InputStream; stream
      * @param odOptions ODOptions; OD options
      * @throws XmlParserException if URL cannot be parsed
      */
     public final void apply(final InputStream stream, final ODOptions odOptions) throws XmlParserException
     {
         applyOD(build(stream), odOptions);
     }
 
     /**
      * Applies demand from xml node.
      * @param xmlNode Node; node
      * @throws XmlParserException if URL cannot be parsed
      */
     public final void apply(final Node xmlNode) throws XmlParserException
     {
         apply(xmlNode, new ODOptions());
     }
 
     /**
      * Applies demand from URL using OD options.
      * @param xmlNode Node; node
      * @param odOptions ODOptions; OD options
      * @throws XmlParserException if URL cannot be parsed
      */
     public void apply(final Node xmlNode, final ODOptions odOptions) throws XmlParserException
     {
         applyOD(build(xmlNode), odOptions);
     }
 
     /**
      * Applies the OD to the network.
      * @param od ODMatrix; OD matrix
      * @param odOptions ODOptions; options
      * @throws XmlParserException if the ODApplier fails
      */
     private void applyOD(final ODMatrix od, final ODOptions odOptions) throws XmlParserException
     {
         try
         {
             ODApplier.applyOD(this.network, od, this.simulator, odOptions);
         }
         catch (ParameterException | SimRuntimeException exception)
         {
             throw new XmlParserException(exception);
         }
     }
 
     /**
      * Build demand from URL.
      * @param url URL; URL to file
      * @return ODMatrix; OD matrix
      * @throws XmlParserException if URL cannot be parsed
      */
     public final ODMatrix build(final URL url) throws XmlParserException
     {
         try
         {
             return build(url.openStream());
         }
         catch (IOException exception)
         {
             throw new XmlParserException(exception);
         }
     }
 
     /**
      * Build demand from stream.
      * @param stream InputStream; stream
      * @return ODMatrix; OD matrix
      * @throws XmlParserException if stream cannot be parsed
      */
     public final ODMatrix build(final InputStream stream) throws XmlParserException
     {
         try
         {
             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
             DocumentBuilder builder = factory.newDocumentBuilder();
             Document document = builder.parse(stream);
             return build(document.getDocumentElement());
         }
         catch (ParserConfigurationException | SAXException | IOException exception)
         {
             throw new XmlParserException(exception);
         }
     }
 
     /**
      * Build demand from xml node.
      * @param xmlNode Node; node
      * @return ODMatrix; OD matrix
      * @throws XmlParserException if stream cannot be parsed
      */
     public final ODMatrix build(final Node xmlNode) throws XmlParserException
     {
         Throw.when(!xmlNode.getNodeName().equals("OD"), XmlParserException.class,
                 "OD should be parsed from a node OD, found %s instead.", xmlNode.getNodeName());
 
         // name
         NamedNodeMap attributes = xmlNode.getAttributes();
         Node nameNode = attributes.getNamedItem("NAME");
         String name = nameNode == null ? "xml od" : nameNode.getNodeValue().trim();
 
         // global interpolation
         Node globalInterpolationNode = attributes.getNamedItem("GLOBALINTERPOLATION");
         if (globalInterpolationNode != null)
         {
             String globalInterpolationString = globalInterpolationNode.getNodeValue().trim();
             try
             {
                 this.globalInterpolation = Interpolation.valueOf(globalInterpolationNode.getNodeValue().trim());
             }
             catch (IllegalArgumentException exception)
             {
                 throw new XmlParserException("INTERPOLATION " + globalInterpolationString + " does not exist.", exception);
             }
         }
         else
         {
             this.globalInterpolation = Interpolation.LINEAR;
         }
 
         // global factor
         Node globalFractionNode = attributes.getNamedItem("GLOBALFACTOR");
         Double globalFraction = null;
         if (globalFractionNode != null)
         {
             String globalFractionString = globalFractionNode.getNodeValue().trim();
             globalFraction = DemandTag.parseFactor(globalFractionString);
         }
 
         // parse data
         // TODO global time as optional
         // TODO order of time values, and demand values later, is not guaranteed in xml, need a way to order them
         NodeList odNodeList = xmlNode.getChildNodes();
         List<Node> nodes = XMLParser.getNodes(odNodeList, "GLOBALTIME");
         Throw.when(nodes.size() > 1, XmlParserException.class, "Multiple GLOBALTIME tags, only 1 is allowed.");
         SortedSet<Time> timeSet = new TreeSet<>();
         if (!nodes.isEmpty())
         {
             for (Node timeNode : XMLParser.getNodes(nodes.get(0).getChildNodes(), "TIME"))
             {
                 NamedNodeMap timeAttributes = timeNode.getAttributes();
                 Node valueNode = timeAttributes.getNamedItem("VALUE");
                 Throw.when(valueNode == null, XmlParserException.class, "LEVEL tag is missing VALUE attribute.");
                 timeSet.add(Try.assign(() -> TimeUnits.parseTime(valueNode.getNodeValue()), XmlParserException.class,
                         "Unable to parse time %s.", valueNode.getNodeValue()));
             }
         }
         double[] timeArray = new double[timeSet.size()];
         Iterator<Time> it = timeSet.iterator();
         for (int i = 0; i < timeSet.size(); i++)
         {
             timeArray[i] = it.next().si;
         }
         this.globalTime = Try.assign(() -> new TimeVector(timeArray, TimeUnit.BASE, StorageType.DENSE),
                 XmlParserException.class, "Unexpected exception while creating global time vector.");
         CategoryTag.parse(odNodeList, this);
         DemandTag.parse(odNodeList, this);
 
         // create OD matrix
         List<org.opentrafficsim.core.network.Node> origins = new ArrayList<>();
         List<org.opentrafficsim.core.network.Node> destinations = new ArrayList<>();
         for (Object oKey : this.demand.getKeys())
         {
             origins.add((org.opentrafficsim.core.network.Node) oKey);
             for (Object dKey : this.demand.getChild(oKey).getKeys())
             {
                 if (!destinations.contains(dKey))
                 {
                     destinations.add((org.opentrafficsim.core.network.Node) dKey);
                 }
             }
         }
         ODMatrix odMatrix =
                 new ODMatrix(name, origins, destinations, this.categorization, this.globalTime, this.globalInterpolation);
 
         // add demand
         for (org.opentrafficsim.core.network.Node origin : origins)
         {
             for (org.opentrafficsim.core.network.Node destination : destinations)
             {
                 Set<DemandTag> set = this.demand.getValue(() -> new LinkedHashSet<>(), origin, destination);
                 if (!set.isEmpty())
                 {
                     // add demand
                     DemandTag main = null;
                     if (!this.categorization.equals(Categorization.UNCATEGORIZED))
                     {
                         for (DemandTag tag : set)
                         {
                             if (tag.category == null)
                             {
                                 Throw.when(main != null, XmlParserException.class,
                                         "Multiple DEMAND tags define main demand from %s to %s.", origin.getId(),
                                         destination.getId());
                                 Throw.when(set.size() == 1, XmlParserException.class,
                                         "Categorized demand from %s to %s has single DEMAND, and without category.",
                                         origin.getId(), destination.getId());
                                 main = tag;
                             }
                         }
                     }
                     for (DemandTag tag : set)
                     {
                         Throw.when(this.categorization.equals(Categorization.UNCATEGORIZED) && set.size() > 1,
                                 XmlParserException.class, "Multiple DEMAND tags define demand from %s to %s.", origin.getId(),
                                 destination.getId());
                         if (tag.equals(main))
                         {
                             // skip main demand itself
                             continue;
                         }
                         TimeVector timeVector = tag.timeVector == null
                                 ? (main == null || main.timeVector == null ? this.globalTime : main.timeVector)
                                 : tag.timeVector;
                         Interpolation interpolation = tag.interpolation == null
                                 ? (main == null || main.interpolation == null ? this.globalInterpolation : main.interpolation)
                                 : tag.interpolation;
                         // category
                         Category category = this.categorization.equals(Categorization.UNCATEGORIZED) ? Category.UNCATEGORIZED
                                 : tag.category;
                         // sort out factor
                         Double factor = globalFraction != null ? globalFraction : null;
                         Double mainFraction = main == null ? null : main.factor;
                         factor = nullMultiply(factor, mainFraction);
                         factor = nullMultiply(factor, tag.factor);
                         FrequencyVector demandVector = tag.demandVector;
                         if (demandVector == null)
                         {
                             demandVector = main.demandVector;
                         }
                         if (tag.factors != null)
                         {
                             double[] factors;
                             if (factor == null)
                             {
                                 factors = tag.factors;
                             }
                             else
                             {
                                 factors = new double[tag.factors.length];
                                 for (int i = 0; i < tag.factors.length; i++)
                                 {
                                     factors[i] = tag.factors[i] * factor;
                                 }
                             }
                             odMatrix.putDemandVector(origin, destination, category, demandVector, timeVector, interpolation,
                                     factors);
                         }
                         else if (factor != null)
                         {
                             odMatrix.putDemandVector(origin, destination, category, demandVector, timeVector, interpolation,
                                     factor);
                         }
                         else
                         {
                             odMatrix.putDemandVector(origin, destination, category, demandVector, timeVector, interpolation);
                         }
                     }
                 }
             }
         }
 
         return odMatrix;
     }
 
     /**
      * Returns the multiplication of two values, taking 1.0 for {@code null} and returning {@code null} if both {@code null}.
      * @param d1 Double value 1
      * @param d2 Double value 2
      * @return multiplication of two values, taking 1.0 for {@code null} and returning {@code null} if both {@code null}
      */
     final static Double nullMultiply(final Double d1, final Double d2)
     {
         if (d1 == null)
         {
             return d2;
         }
         if (d2 == null)
         {
             return d1;
         }
         return d1 * d2;
     }
 
 }