package org.lsst.ccs.bootstrap;
   
   import java.io.File;
   import java.net.URISyntaxException;
   import java.net.URL;
   import java.nio.file.Path;
   import java.nio.file.Paths;
   import java.util.ArrayList;
   import java.util.List;
  import java.util.Properties;
  import java.util.StringTokenizer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import org.lsst.ccs.bootstrap.resources.BootstrapResourceUtils;
  import org.lsst.ccs.bootstrap.resources.ResourcesTree;
  import org.lsst.ccs.bootstrap.resources.ResourcesUtils;
  
  /**
   * Utility methods for the Bootstrap application.
   *
   * @author turri
   */
  public abstract class BootstrapUtils {
  
      public static final String FILE_SEPARATOR = System.getProperty("file.separator");
      public static final String PATH_SEPARATOR = System.getProperty("path.separator");
      protected static final String DISTRIBUTION_JARS_DIRECTORY = "share" + FILE_SEPARATOR + "java" + FILE_SEPARATOR;
      private static final String DISTRIBUTION_RESOURCES_DIRECTORY = "etc" + FILE_SEPARATOR;
      private static final String DISTRIBUTION_LIB_DIRECTORY = "lib" + FILE_SEPARATOR;
      private static final String DISTRIBUTION_JNI_DIRECTORY = DISTRIBUTION_LIB_DIRECTORY + "jni" + FILE_SEPARATOR;
      protected static final String APPLICATION_MAINCLASS_PROPERTY = "org.lsst.ccs.application.mainClass";
      protected static final String OBSOLETE_MAINJAR_PROPERTY = "org.lsst.ccs.application.mainJar";
      private static List<String> listOfApplications = null;
  
      // Pattern to substitute environment variable in user provided properties
      private static final String envVar_str_pattern = ".*(\\$\\[env\\.(.*)\\]).*";
      private static final Pattern envVar_pattern = Pattern.compile(envVar_str_pattern);
  
      /**
       * Environment variable that defines the resource path.
       */
      private final static String CCS_RESOURCE_PATH_ENV_VAR = "CCS_RESOURCE_PATH";
      private final static String CCS_DISTRIBUTION_PATH_ENV_VAR = "CCS_DISTRIBUTION_PATH";
      private static String ccsDistributionRootDirectory = null;
      private static ResourcesTree resourcesTree = null;
  
      protected static void reset() {
          resourcesTree = null;
          ccsDistributionRootDirectory = null;
          listOfApplications = null;
      }
      
      /**
       * Get the ResourceTree for this Bootstrap environment. It contains all the
       * resources defined in the resource directory list.
       *
       * @return
       */
      public synchronized static ResourcesTree getBootstrapResourcesTree() {
          if (resourcesTree == null) {
              resourcesTree = new ResourcesTree();
              List<String> resourceDirectories = getOrderedListOfResourceDirectories();
              List<String> additionalResourceDirectories = extractDirectoriesFromPath(getUserProvidedResourceDirectories(), null, true);
  
              for (String resourceDirectory : resourceDirectories) {
                  File resourceDir = new File(resourceDirectory);
                  if (resourceDir.exists()) {
                      if ( additionalResourceDirectories.contains(resourceDirectory) ) {
                          resourcesTree.addUserResourceDirectory(resourceDirectory);
                      } else {
                          resourcesTree.addDistributionResourceDirectory(resourceDirectory);
                      }
                  } else {
                      if (Bootstrap.isBootstrapEnvironment()) {
                          System.out.println("***** WARNING: resource directory " + resourceDirectory + " does not exist.");
                      }
                  }
              }
          }
          return resourcesTree;
      }
  
      protected static String getUserProvidedResourceDirectories() {
          String userProvidedResourceDirectories = null;
          if ( "true".equals(System.getProperty("org.lsst.ccs.bootstrap.test"))  ) {
              userProvidedResourceDirectories = System.getProperty("org.lsst."+CCS_RESOURCE_PATH_ENV_VAR.replace("_", ".").toLowerCase());
              if ( userProvidedResourceDirectories != null ) {
                  return userProvidedResourceDirectories;
              }
          }
          return System.getenv(CCS_RESOURCE_PATH_ENV_VAR);        
      }
      
      protected static String getUserProvidedDistributionDirectories() {
          String userProvidedDistributionDirectories = null;
          if ( "true".equals(System.getProperty("org.lsst.ccs.bootstrap.test") ) ) {
              userProvidedDistributionDirectories = System.getProperty("org.lsst."+CCS_DISTRIBUTION_PATH_ENV_VAR.replace("_", ".").toLowerCase());
              if ( userProvidedDistributionDirectories != null ) {
                  return userProvidedDistributionDirectories;
             }
         }
         return System.getenv(CCS_DISTRIBUTION_PATH_ENV_VAR);                
     }
     
     /**
      * Get the ordered list of resource directories.
      *
      * The built in default is: - Distribution resources directory:
      * distribution/etc/ - System resources directory: /etc/ccs/ - User
      * resources directory: ~/.ccs/etc/
      *
      * By setting the environment variable CCS_RESOURCE_PATH, the developer can
      * change which resource directories are searched and in which order.
      *
      * When the CCS_RESOURCE_PATH environment variable is set, the distribution
      * resource directory will be still searched first, before any of the
      * directories provided by the user.
      *
      * This list is built once and its result is cached.
      *
      * @return The list of ordered directories used to search for resources.
      *
      */
     static List<String> getOrderedListOfResourceDirectories() {
         String userProvidedResourceDirs = getUserProvidedResourceDirectories();
         String userProvidedDistributionDirs = getUserProvidedDistributionDirectories();
         return getOrderedListOfResourceDirectories(userProvidedResourceDirs, userProvidedDistributionDirs, true);
     }
 
     /**
      * This method should do all the work of setting up the resource directories
      * as it is used in by the tests.
      *
      * @param userProvidedResourceDirs This resembles the environment variable
      * to set the list of resource directories.
      * @param userProvidedDistributions This resembles the environment variable
      * to set the list of additional distributions.
      * @return The list of ordered directories to search for resources.
      *
      */
     static List<String> getOrderedListOfResourceDirectories(String userProvidedResourceDirs, String userProvidedDistributions, boolean checkExistance) {
 
         String distributionResourceDirectoriy = getDistributionResourcesDirectory();
 
         List<String> additionaDistributionResourceDirectories = extractDirectoriesFromPath(userProvidedDistributions, DISTRIBUTION_RESOURCES_DIRECTORY, checkExistance);
 
         List<String> additionalResourceDirectories = extractDirectoriesFromPath(userProvidedResourceDirs, null, checkExistance);
 
         List<String> orderedListOfResourceDirectories = new ArrayList<>();
 
         // First add the additional resource directories
         for (String dir : additionalResourceDirectories) {
             orderedListOfResourceDirectories.add(dir);
         }
 
         // Then add the main distribution directory
         orderedListOfResourceDirectories.add(distributionResourceDirectoriy);
 
         // Finally add any additional distribution directory
         for (String dir : additionaDistributionResourceDirectories) {
             orderedListOfResourceDirectories.add(dir);
         }
 
         return orderedListOfResourceDirectories;
     }
 
     protected static List<String> extractDirectoriesFromPath(String directoryPath, String appendDirectory, boolean checkExistance) {
 
         ArrayList<String> extractedDirectories = new ArrayList<>();
 
         if (directoryPath != null && !"".equals(directoryPath)) {
             StringTokenizer dirsToken = new StringTokenizer(directoryPath, PATH_SEPARATOR);
             while (dirsToken.hasMoreTokens()) {
                 String resourceDir = dirsToken.nextToken().trim();
                 if (!resourceDir.endsWith(FILE_SEPARATOR)) {
                     resourceDir += FILE_SEPARATOR;
                 }
                 if (appendDirectory != null && !"".equals(appendDirectory)) {
                     if (!appendDirectory.endsWith(FILE_SEPARATOR)) {
                         appendDirectory += FILE_SEPARATOR;
                     }
                     resourceDir += appendDirectory;
                 }
 
                 //The root for relative paths is the root of the CCS distribution.
                 Path p = Paths.get(BootstrapUtils.getCCSDistributionRootDirectory());
                 resourceDir = resourceDir.replace("~", System.getProperty("user.home"));
                 resourceDir = p.resolve(resourceDir).normalize().toString();
                 if (!resourceDir.endsWith(FILE_SEPARATOR)) {
                     resourceDir += FILE_SEPARATOR;
                 }
                 File dir = new File(resourceDir);
                 if (checkExistance && !dir.exists()) {
                     if (Bootstrap.isBootstrapEnvironment()) {
                         System.out.println("** Ignoring resource directory " + resourceDir + " as it does not exist.");
                         System.out.println("** Please update the environment variable " + CCS_RESOURCE_PATH_ENV_VAR + " or " + CCS_DISTRIBUTION_PATH_ENV_VAR);
                     }
                 } else {
                     extractedDirectories.add(resourceDir);
                 }
             }
         }
         return extractedDirectories;
     }
 
     /**
      * Get the Distribution resources directory.
      *
      * @return The resources directory in the distribution.
      */
     public static String getDistributionResourcesDirectory() {
         return getDistributionResourcesDirectory(getCCSDistributionRootDirectory());
     }
 
     static String getDistributionResourcesDirectory(String distribution) {
         if (!distribution.endsWith(FILE_SEPARATOR)) {
             distribution += FILE_SEPARATOR;
         }
         return distribution + DISTRIBUTION_RESOURCES_DIRECTORY;
     }
 
     /**
      * Get the lib directory in the distribution.
      *
      * @return the lib files directory.
      *
      */
     static String getDistributionLibDirectory() {
         return getDistributionLibDirectory(getCCSDistributionRootDirectory());
     }
 
     static String getDistributionLibDirectory(String distribution) {
         if (!distribution.endsWith(FILE_SEPARATOR)) {
             distribution += FILE_SEPARATOR;
         }
         return distribution + DISTRIBUTION_LIB_DIRECTORY;
     }
 
     /**
      * Get the jni directory in the distribution.
      *
      * @return the jni files directory.
      *
      */
     static String getDistributionJniDirectory() {
         return getDistributionJniDirectory(getCCSDistributionRootDirectory());
     }
 
     static String getDistributionJniDirectory(String distribution) {
         if (!distribution.endsWith(FILE_SEPARATOR)) {
             distribution += FILE_SEPARATOR;
         }
         return distribution + DISTRIBUTION_JNI_DIRECTORY;
     }
 
     /**
      * Get the jar files directory in the distribution.
      *
      * @return the jar files directory.
      *
      */
     static String getDistributionJarFilesDirectory() {
         return getDistributionJarFilesDirectory(getCCSDistributionRootDirectory());
     }
 
     static String getDistributionJarFilesDirectory(String distribution) {
         if (!distribution.endsWith(FILE_SEPARATOR)) {
             distribution += FILE_SEPARATOR;
         }
         return distribution + DISTRIBUTION_JARS_DIRECTORY;
     }
 
     /**
      * Get the root directory of the CCS distribution from which the Bootstrap
      * code has been launched.
      *
      * @return The root directory of the CCS distribution. It ends with a
      * file.separator.
      */
     public static String getCCSDistributionRootDirectory() {
         if (ccsDistributionRootDirectory == null) {
             ccsDistributionRootDirectory = getCCSDistributionRootDirectory(Bootstrap.getLoaderClass());
         }
         return ccsDistributionRootDirectory;
     }
 
     /**
      * This is to be used only in test environment.
      *
      * @param clazz
      * @return
      */
     private static String getCCSDistributionRootDirectory(Class clazz) {
         URL location = clazz.getProtectionDomain().getCodeSource().getLocation();
         try {
             Path path = Paths.get(location.toURI());
             String sourceCodeLocation = path.toString();
             if (sourceCodeLocation.endsWith(".jar")) {
                 ccsDistributionRootDirectory = sourceCodeLocation.substring(0, sourceCodeLocation.lastIndexOf(FILE_SEPARATOR) + 1);
             } else if (path.toFile().isDirectory()) {
                 ccsDistributionRootDirectory = sourceCodeLocation + FILE_SEPARATOR;
             } else {
                 throw new RuntimeException("Could not process souce code location " + sourceCodeLocation + " It is neither a directory nor a jar file.");
             }
         } catch (URISyntaxException x) {
             throw new RuntimeException("Could not process souce code location ", x);
         }
 
         if (ccsDistributionRootDirectory.endsWith(DISTRIBUTION_JARS_DIRECTORY)) {
             ccsDistributionRootDirectory = ccsDistributionRootDirectory.replace(DISTRIBUTION_JARS_DIRECTORY, "");
 //            throw new RuntimeException("This executable is not being run from a CCS distribution directory. "+ccsDistributionRootDirectory);
         }
         return ccsDistributionRootDirectory;
     }
 
     /**
      * Get the list of available applications for the current Bootstrap
      * configuration.
      *
      * @return The list of application names.
      *
      */
     public synchronized static List<String> getBootstrapListOfApplications() {
         if (listOfApplications == null) {
             listOfApplications = new ArrayList<>();
             List<String> allPropertiesInResources = ResourcesUtils.getResourcesInResourcesTreeByExtension(getBootstrapResourcesTree(), "properties", 0);
             for (String propertyFile : allPropertiesInResources) {
                 Properties props = ResourcesUtils.getMergedPropertyFile(getBootstrapResourcesTree(), propertyFile);
                 String mainClass = props.getProperty(APPLICATION_MAINCLASS_PROPERTY);
                 if (mainClass != null && !mainClass.isEmpty()) {
                     listOfApplications.add(propertyFile.replace(".properties", ""));
                 }
             }
         }
         return listOfApplications;
     }
 
     /**
      * Get the application definition properties file for a given application
      * name.
      *
      * @param application The name of the application.
      * @return The Properties that define the application.
      */
     static Properties getApplicationDefinitionProperties(String application) {
 //        return getMergedProperties(application);
         if ( ! application.endsWith(".properties") ) {
             application = application += ".properties";
         }        
         return BootstrapResourceUtils.getBootstrapProperties(application);
     }
 
     static String getBootstrapLibraryPath() {
         String libraryPath = BootstrapUtils.getDistributionJniDirectory() + File.pathSeparator + BootstrapUtils.getDistributionLibDirectory();
         String existingLibraryPath = System.getenv("LD_LIBRARY_PATH");
         if (existingLibraryPath != null && !existingLibraryPath.isEmpty()) {
             libraryPath += File.pathSeparator + existingLibraryPath;
         }
         return libraryPath;
     }
 
     /**
      * Parse a user provided property to match environment variables specified
      * in the form ${ENV_VARIABLE}
      *
      */
     public static String parseProperty(String inputProperty) {
         String outProperty = inputProperty;
         Matcher m = envVar_pattern.matcher(outProperty);
         if (m.matches()) {
             String envVarValue = System.getenv(m.group(2));
             if (envVarValue != null) {
                 outProperty = outProperty.replace(m.group(1), envVarValue);
             } else {
                 if (Bootstrap.isBootstrapEnvironment()) {
                     System.out.println("[WARNING] Environment variable " + m.group(2) + " is not defined.");
                 }
             }
         }
         return outProperty;
     }
 
 }