package org.opentrafficsim.road.network.factory.xml.parser;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.InputStream;
   import java.io.Serializable;
   import java.net.URISyntaxException;
   import java.rmi.RemoteException;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.xml.bind.JAXBContext;
  import javax.xml.bind.JAXBException;
  import javax.xml.bind.Unmarshaller;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.parsers.SAXParserFactory;
  import javax.xml.transform.sax.SAXSource;
  
  import org.djunits.value.vdouble.scalar.Direction;
  import org.djunits.value.vdouble.scalar.Speed;
  import org.djutils.io.URLResource;
  import org.djutils.logger.CategoryLogger;
  import org.opentrafficsim.base.logger.Cat;
  import org.opentrafficsim.base.parameters.ParameterException;
  import org.opentrafficsim.base.parameters.ParameterType;
  import org.opentrafficsim.core.dsol.OTSSimulator;
  import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
  import org.opentrafficsim.core.geometry.OTSGeometryException;
  import org.opentrafficsim.core.gtu.GTUException;
  import org.opentrafficsim.core.gtu.GTUType;
  import org.opentrafficsim.core.network.LinkType;
  import org.opentrafficsim.core.network.NetworkException;
  import org.opentrafficsim.core.parameters.InputParameters;
  import org.opentrafficsim.core.parameters.ParameterFactory;
  import org.opentrafficsim.draw.lane.LaneStructureAnimation;
  import org.opentrafficsim.road.gtu.generator.LaneBasedGTUGenerator;
  import org.opentrafficsim.road.gtu.lane.LaneBasedGTU;
  import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructure;
  import org.opentrafficsim.road.gtu.strategical.LaneBasedStrategicalPlannerFactory;
  import org.opentrafficsim.road.network.OTSRoadNetwork;
  import org.opentrafficsim.road.network.factory.xml.XmlParserException;
  import org.opentrafficsim.road.network.factory.xml.utils.StreamInformation;
  import org.opentrafficsim.xml.generated.ANIMATION;
  import org.opentrafficsim.xml.generated.CONTROL;
  import org.opentrafficsim.xml.generated.GTUTEMPLATE;
  import org.opentrafficsim.xml.generated.MODELTYPE;
  import org.opentrafficsim.xml.generated.NETWORK;
  import org.opentrafficsim.xml.generated.NETWORKDEMAND;
  import org.opentrafficsim.xml.generated.OTS;
  import org.opentrafficsim.xml.generated.ROADLAYOUT;
  import org.opentrafficsim.xml.generated.SCENARIO;
  import org.pmw.tinylog.Level;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.XMLReader;
  
  import nl.tudelft.simulation.dsol.SimRuntimeException;
  import nl.tudelft.simulation.dsol.experiment.Experiment;
  import nl.tudelft.simulation.dsol.logger.SimLogger;
  import nl.tudelft.simulation.dsol.model.inputparameters.InputParameter;
  import nl.tudelft.simulation.event.EventInterface;
  import nl.tudelft.simulation.event.EventListenerInterface;
  
  /**
   * Parse an XML file for an OTS network, based on the ots-network.xsd definition.
   * <p>
   * Copyright (c) 2013-2019 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/docs/license.html">OpenTrafficSim License</a>.
   * <p>
   * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
   * initial version Jul 23, 2015 <br>
   * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   */
  public final class XmlNetworkLaneParser implements Serializable
  {
      /** */
      private static final long serialVersionUID = 2019022L;
  
      /** */
      private XmlNetworkLaneParser()
      {
          // utility class
      }
  
      /**
       * Parse the XML file and build the network.
       * @param filename String; the name of the file to parse
       * @param otsNetwork OTSRoadNetwork; the network to insert the parsed objects in
       * @param simulator OTSSimulatorInterface; the simulator
       * @return the network that contains the parsed objects
       * @throws JAXBException when the parsing fails
       * @throws URISyntaxException when the filename is not valid
       * @throws NetworkException when the objects cannot be inserted into the network due to inconsistencies
       * @throws OTSGeometryException when the design line of a link is invalid
      * @throws XmlParserException when the stripe type cannot be recognized
      * @throws ParserConfigurationException on error with parser configuration
      * @throws SAXException on error creating SAX parser
      * @throws SimRuntimeException in case of simulation problems building the car generator
      * @throws GTUException when construction of the Strategical Planner failed
      */
     public static OTSRoadNetwork build(final String filename, final OTSRoadNetwork otsNetwork,
             final OTSSimulatorInterface simulator)
             throws JAXBException, URISyntaxException, NetworkException, OTSGeometryException, XmlParserException, SAXException,
             ParserConfigurationException, SimRuntimeException, GTUException
     {
         File xml = new File(URLResource.getResource(filename).toURI().getPath());
         try
         {
             build(new FileInputStream(xml), otsNetwork, simulator);
         }
         catch (FileNotFoundException exception)
         {
             throw new XmlParserException("File could not be found.", exception);
         }
 
         return otsNetwork;
     }
 
     /**
      * Parse the XML file and build the network.
      * @param xmlStream InputStream; the xml input stream
      * @param otsNetwork OTSRoadNetwork; the network to insert the parsed objects in
      * @param simulator OTSSimulatorInterface; the simulator
      * @return the experiment based on the information in the RUN tag
      * @throws JAXBException when the parsing fails
      * @throws URISyntaxException when the filename is not valid
      * @throws NetworkException when the objects cannot be inserted into the network due to inconsistencies
      * @throws OTSGeometryException when the design line of a link is invalid
      * @throws XmlParserException when the stripe type cannot be recognized
      * @throws ParserConfigurationException on error with parser configuration
      * @throws SAXException on error creating SAX parser
      * @throws SimRuntimeException in case of simulation problems building the car generator
      * @throws GTUException when construction of the Strategical Planner failed
      */
     public static Experiment.TimeDoubleUnit<OTSSimulatorInterface> build(final InputStream xmlStream,
             final OTSRoadNetwork otsNetwork, final OTSSimulatorInterface simulator)
             throws JAXBException, URISyntaxException, NetworkException, OTSGeometryException, XmlParserException, SAXException,
             ParserConfigurationException, SimRuntimeException, GTUException
     {
         JAXBContext jc = JAXBContext.newInstance(OTS.class);
         Unmarshaller unmarshaller = jc.createUnmarshaller();
         SAXParserFactory spf = SAXParserFactory.newInstance();
         spf.setXIncludeAware(true);
         spf.setNamespaceAware(true);
         spf.setValidating(false);
         XMLReader xmlReader = spf.newSAXParser().getXMLReader();
         SAXSource saxSource = new SAXSource(xmlReader, new InputSource(xmlStream));
         OTS ots = (OTS) unmarshaller.unmarshal(saxSource);
 
         CategoryLogger.setLogCategories(Cat.PARSER);
         CategoryLogger.setAllLogLevel(Level.TRACE);
 
         Map<String, StreamInformation> streamMap = new HashMap<>();
         Experiment.TimeDoubleUnit<OTSSimulatorInterface> experiment =
                 RunParser.parseRun(otsNetwork, ots.getRUN(), streamMap, simulator);
 
         Map<String, ROADLAYOUT> roadLayoutMap = new HashMap<>();
         Map<String, GTUTEMPLATE> gtuTemplates = new HashMap<>();
         Map<LinkType, Map<GTUType, Speed>> linkTypeSpeedLimitMap = new HashMap<>();
         DefinitionsParser.parseDefinitions(otsNetwork, ots.getDEFINITIONS(), true, roadLayoutMap, gtuTemplates, streamMap,
                 linkTypeSpeedLimitMap);
 
         NETWORK network = ots.getNETWORK();
         NetworkParser.parseNodes(otsNetwork, network);
         Map<String, Direction> nodeDirections = NetworkParser.calculateNodeAngles(otsNetwork, network);
         NetworkParser.parseLinks(otsNetwork, network, nodeDirections, simulator);
         NetworkParser.applyRoadLayout(otsNetwork, network, simulator, roadLayoutMap, linkTypeSpeedLimitMap);
         NetworkParser.parseRoutes(otsNetwork, network);
         NetworkParser.parseShortestRoutes(otsNetwork, network);
 
         List<NETWORKDEMAND> demands = ots.getNETWORKDEMAND();
         for (NETWORKDEMAND demand : demands)
         {
             List<LaneBasedGTUGenerator> generators =
                     GeneratorSinkParser.parseGenerators(otsNetwork, demand, gtuTemplates, simulator, streamMap);
             // The code below can be used to visualize the LaneStructure of a particular GTU
             /*-for (LaneBasedGTUGenerator generator : generators)
             {
                 EventListenerInterface listener = new EventListenerInterface()
                 {
                     @Override
                     public void notify(final EventInterface event) throws RemoteException
                     {
                         LaneBasedGTU gtu = (LaneBasedGTU) event.getContent();
                         if (gtu.getId().equals("25"))
                         {
                             try
                             {
                                 LaneStructureAnimation.visualize(
                                         (RollingLaneStructure) gtu.getTacticalPlanner().getPerception().getLaneStructure(), gtu);
                             }
                             catch (ParameterException | ClassCastException exception)
                             {
                                 SimLogger.always().warn("Could not draw lane structure of GTU.");
                             }
                         }
                     }
                 };
                 generator.addListener(listener, LaneBasedGTUGenerator.GTU_GENERATED_EVENT);
             }*/
             GeneratorSinkParser.parseSinks(otsNetwork, demand, simulator);
         }
         List<MODELTYPE> models = ots.getMODEL();
         // TODO: parse input parameters
         InputParameters inputParameters = new InputParameters()
         {
             /** {@inheritDoc} */
             @Override
             public <T> Set<T> getObjects(final Class<T> clazz)
             {
                 return new HashSet<>();
             }
 
             /** {@inheritDoc} */
             @Override
             public Map<String, InputParameter<?, ?>> getInputParameters(final Object object)
             {
                 throw new UnsupportedOperationException("No input parameters.");
             }
 
             /** {@inheritDoc} */
             @Override
             public InputParameter<?, ?> getInputParameter(final Object object, final String id)
             {
                 throw new UnsupportedOperationException("No input parameters.");
             }
         };
         Map<String, ParameterType<?>> parameterTypes = new LinkedHashMap<>();
         Map<String, ParameterFactory> parameterFactories =
                 ModelParser.parseParameters(otsNetwork, models, inputParameters, parameterTypes, streamMap);
         DefinitionsParser.parseParameterTypes(ots.getDEFINITIONS(), otsNetwork, parameterTypes);
         Map<String, LaneBasedStrategicalPlannerFactory<?>> factories =
                 ModelParser.parseModel(otsNetwork, models, inputParameters, parameterTypes, streamMap, parameterFactories);
         Map<String, String> modelIdReferrals = ScenarioParser.parseModelIdReferral(ots.getSCENARIO(), ots.getNETWORKDEMAND());
         List<LaneBasedGTUGenerator> generators =
                 DemandParser.parseDemand(otsNetwork, simulator, demands, gtuTemplates, factories, modelIdReferrals, streamMap);
         // The code below can be used to visualize the LaneStructure of a particular GTU
         /*-EventListenerInterface listener = new EventListenerInterface()
         {
             @Override
             public void notify(final EventInterface event) throws RemoteException
             {
                 LaneBasedGTU gtu = (LaneBasedGTU) event.getContent();
                 if (gtu.getId().equals("27"))
                 {
                     try
                     {
                         LaneStructureAnimation.visualize(
                                 (RollingLaneStructure) gtu.getTacticalPlanner().getPerception().getLaneStructure(), gtu);
                     }
                     catch (ParameterException | ClassCastException exception)
                     {
                         SimLogger.always().warn("Could not draw lane structure of GTU.");
                     }
                 }
             }
         };
         for (LaneBasedGTUGenerator generator : generators)
         {
             generator.addListener(listener, LaneBasedGTUGenerator.GTU_GENERATED_EVENT);
         }*/
 
         List<CONTROL> controls = ots.getCONTROL();
         List<MODELTYPE> modelParameters = ots.getMODEL();
         List<SCENARIO> scenario = ots.getSCENARIO();
         ANIMATION animation = ots.getANIMATION();
 
         ControlParser.parseControl(otsNetwork, simulator, controls);
 
         return experiment;
     }
 
     /**
      * @param args String[]; not used
      * @throws Exception on parsing error
      */
     public static void main(final String[] args) throws Exception
     {
         OTSSimulatorInterface simulator = new OTSSimulator();
         build("/example.xml", new OTSRoadNetwork("", true), simulator);
         System.exit(0);
     }
 }