package org.djunits.generator;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.Authenticator;
   import java.net.MalformedURLException;
   import java.net.PasswordAuthentication;
   import java.net.URL;
  
  /**
   * The URLResource class helps to resolve a file location in a project, JAR, or folder. The static methods return a URL of the
   * file location that was found, or null in case it was not found. This class originates from the DSOL simulation project.
   * <p>
   * Copyright (c) 2002-2022 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved.<br>
   * BSD-style license. See <a href="https://djunits.org/docs/license.html">DJUNITS License</a>.
   * </p>
   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   */
  public final class URLResource
  {
      /**
       * constructs a new URLResource.
       */
      private URLResource()
      {
          // unreachable code
      }
  
      /**
       * Resolves a resource for name.
       * @param name String; the name to search for
       * @return the resolved URL
       */
      public static URL getResource(final String name)
      {
          try
          {
              File file = new File(name);
  
              if (name.startsWith("/"))
              {
                  URL url = URLResource.class.getResource(name);
                  if (url != null)
                  {
                      return url;
                  }
                  url = Thread.currentThread().getContextClassLoader().getResource(name.substring(1));
                  if (url != null)
                  {
                      return url;
                  }
                  if (file.exists())
                  {
                      return new URL("file:" + name);
                  }
              }
              else if (name.startsWith("\\") || name.contains("\\")) // added the second part
              {
                  if (file.exists())
                  {
                      return new URL("file:" + name);
                  }
              }
              else if (file.exists())
              {
                  return new URL("file:" + name);
              }
              else
              {
                  if (name.indexOf("@") == -1)
                  {
                      return new URL(name);
                  }
                  // we need authentication
                  String temp = name.substring(name.indexOf("//") + 2);
                  String userName = temp.substring(0, temp.indexOf(":"));
                  String password = temp.substring(temp.indexOf(":") + 1);
                  password = password.substring(0, password.indexOf("@"));
                  String url = name.substring(0, name.indexOf("//") + 2);
                  url = url + name.substring(name.indexOf("@") + 1);
                  Authenticator.setDefault(new PasswordAuthenticator(userName, password));
                  return new URL(url);
              }
          }
          catch (Exception exception)
          {
              exception = null;
              // We neglect exceptions since we return null
          }
          return null;
      }
  
      /**
       * Resolves a resource for name. For relative names, base is used to resolve to an absolute name. If name is absolute, base
       * is ignored.
       * @param name String; the name to search for
       * @param base String; the base for relative paths
       * @return the resolved URL
      */
     public static URL getResource(final String name, final String base)
     {
         URL url = null;
 
         // case complete URL
         try
         {
             url = new URL(name);
         }
         catch (MalformedURLException ex)
         {
             // neglect exception -- just trying
         }
 
         // absolute or relative case
         if (url == null)
         {
             String completeName = name;
             if (!name.startsWith(File.separator) && !name.startsWith("/") && base != null)
             {
                 String baseDir = "";
                 int i = base.lastIndexOf(File.separator);
                 if (i == -1 && !File.separator.equals("/"))
                 {
                     i = base.lastIndexOf("/");
                 }
                 if (i != -1)
                 {
                     baseDir = base.substring(0, i + 1);
                 }
                 completeName = baseDir + name;
             }
 
             // case base = URL
             try
             {
                 url = new URL(completeName);
                 if (url.getProtocol().equalsIgnoreCase("file"))
                 {
                     File file = new File(url.getPath());
                     if (!file.exists())
                     {
                         url = null;
                     }
                 }
             }
             catch (MalformedURLException ex)
             {
                 url = getResourceOrFile(completeName);
             }
 
             // just try plain name if that's still another option
             if (url == null && !name.equalsIgnoreCase(completeName))
             {
                 url = getResourceOrFile(name);
             }
 
         }
 
         // handle authentication
         if (url != null && url.getUserInfo() != null)
         {
             String ui = url.getUserInfo();
             String userName = ui.substring(0, ui.indexOf(":"));
             String password = ui.substring(ui.indexOf(":") + 1);
             Authenticator.setDefault(new PasswordAuthenticator(userName, password));
         }
 
         return url;
     }
 
     /**
      * Resolves a resource for a path.
      * @param path String; the path to search for
      * @return the resolved URL to the path
      */
     private static URL getResourceOrFile(String path)
     {
         URL url = null;
 
         // resource
         if (url == null)
         {
             url = URLResource.class.getResource(path);
         }
 
         // thread context resource
         if (url == null)
         {
             url = Thread.currentThread().getContextClassLoader().getResource(path.substring(1));
         }
 
         // file
         if (url == null)
         {
             File file = new File(path);
             if (file.exists())
             {
                 try
                 {
                     url = new URL("file:" + file.getCanonicalPath());
                 }
                 catch (IOException ex)
                 {
                     // ignore -- if not found, we return null
                 }
             }
         }
 
         return url;
     }
 
     /**
      * returns the resource as stream.
      * @param name String; the name of the resource
      * @return the inputStream
      */
     public static InputStream getResourceAsStream(final String name)
     {
         try
         {
             URL url = URLResource.getResource(name);
             if (url == null)
             {
                 return null;
             }
             return url.openStream();
         }
         catch (Exception exception)
         {
             return null;
         }
     }
 
     /**
      * A Private password authenticator.
      */
     private static class PasswordAuthenticator extends Authenticator
     {
         /** my user name. */
         private String userName = null;
 
         /** my password. */
         private String password = null;
 
         /**
          * constructs a new PasswordAuthenticator.
          * @param userName String; my userName
          * @param password String; my passWord
          */
         public PasswordAuthenticator(final String userName, final String password)
         {
             this.userName = userName;
             this.password = password;
         }
 
         /** {@inheritDoc} */
         @Override
         protected PasswordAuthentication getPasswordAuthentication()
         {
             return new PasswordAuthentication(this.userName, this.password.toCharArray());
         }
     }
 
 }