/*
    * Copyright 2010 The Kuali Foundation.
    * 
    * Licensed under the Educational Community License, Version 1.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    * http://www.opensource.org/licenses/ecl1.php
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.ole.sys.context;
  
  import static org.kuali.ole.sys.OLEConstants.SchemaBuilder.DD_VALIDATION_PREFIX;
  import static org.kuali.ole.sys.OLEConstants.SchemaBuilder.SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_BEGIN;
  import static org.kuali.ole.sys.OLEConstants.SchemaBuilder.SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_END;
  import static org.kuali.ole.sys.OLEConstants.SchemaBuilder.XSD_VALIDATION_PREFIX;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Set;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.BasicConfigurator;
  import org.apache.log4j.Level;
  import org.apache.log4j.Logger;
  
  /**
   * Called during the build process to output schema files with validation built from the data dictionary or set to defaults
   */
  public class SchemaBuilder {
      private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(SchemaBuilder.class);
      private static Level logLevel = Level.INFO;
  
      /**
       * <pre>
       * Performs schema build process. 
       * 
       * Build directory path containing the schema files, static directory that schema files will be
       * outputted to, and flag for whether to use data dictionary validation all must given as arguments. 
       * 
       * Schema files in build directory should contain place-holders for which the validation will be substituted. The place-holder begin symbol is ${,
       * and the end symbol is }. Then the place-holder should contain two parts, first the xsd type to use if data dictionary
       * validation is not on. The second is the data dictionary entry (businessObjectEntry.attributeName) prefixed with 'dd:' that
       * will be pulled for dd validation. The parts should be separated with a comma. Any type values without a place-holder will
       * not be modified. 
       * 
       * Program also fills in externalizable.static.content.url place-holder. Value to set should be passed as the fourth program argument
       * </pre>
       * 
       * @param args
       */
      public static void main(String[] args) {
          if (args.length < 5) {
              System.err.println("ERROR: You must pass the build directory, static directory, dd flag, external content url, and rebuild types flag as arguments");
              System.exit(8);
          }
          try {
              // initialize log4j
              BasicConfigurator.configure();
              Logger.getRootLogger().setLevel(Level.WARN);
              LOG.setLevel(logLevel);
  
              String buildDirectoryPath = args[0];
              if (StringUtils.isBlank(buildDirectoryPath)) {
                  logAndThrowException("Build directory must be passed as first argument");
              }
              if (LOG.isDebugEnabled()) {
                  LOG.debug("Build directory set to " + buildDirectoryPath);
              }
  
              String staticDirectoryPath = args[1];
              if (StringUtils.isBlank(staticDirectoryPath)) {
                  logAndThrowException("Static directory must be passed as second argument");
              }
              if (LOG.isDebugEnabled()) {
                  LOG.debug("Static directory set to " + staticDirectoryPath);
              }
  
              String dataDictionaryValidation = args[2];
              if (StringUtils.isBlank(dataDictionaryValidation)) {
                  logAndThrowException("Use data dictionary validation must be passed as third argument");
              }
  
              String externalizableContentUrl = args[3];
              if (StringUtils.isBlank(externalizableContentUrl)) {
                  logAndThrowException("Externalizalbe static content URL must be passed as fourth argument");
              }
  
              String rebuildDDTypesFlag = args[4];
             if (StringUtils.isBlank(rebuildDDTypesFlag)) {
                 logAndThrowException("Rebuild DD flags must be passed as fifth argument");
             }
 
             boolean useDataDictionaryValidation = Boolean.parseBoolean(dataDictionaryValidation);
             boolean rebuildDDTypes = Boolean.parseBoolean(rebuildDDTypesFlag);
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Use data dictionary validation set to " + useDataDictionaryValidation);
             }
 
             // if using dd validation must start up spring so we can read DD
             if (useDataDictionaryValidation && rebuildDDTypes) {
                 SpringContextForBatchRunner.initializeKfs();
             }
 
             LOG.debug("Getting build schema files");
             Collection buildSchemaFiles = getBuildSchemaFiles(buildDirectoryPath);
 
             LOG.debug("Building schema files");
             try {
                 buildSchemaFiles(buildSchemaFiles, staticDirectoryPath, buildDirectoryPath, useDataDictionaryValidation, externalizableContentUrl, rebuildDDTypes);
             }
             catch (IOException ex) {
                 LOG.error("Error building schema files: " + ex.getMessage(), ex);
                 throw new RuntimeException("Error building schema files: " + ex.getMessage(), ex);
             }
 
             LOG.info("Finished building schema files.");
             System.exit(0);
         }
         catch (Throwable t) {
             System.err.println("ERROR: Exception caught: " + t.getMessage());
             t.printStackTrace(System.err);
             System.exit(8);
         }
     }
 
     /**
      * Returns Collection of File objects for all .xsd files found in given directory (including sub-directories)
      * 
      * @param buildDirectoryPath Directory to look for schema files
      * @return Collection of File objects
      */
     protected static Collection getBuildSchemaFiles(String buildDirectoryPath) {
         File buildDirectory = new File(buildDirectoryPath);
 
         return FileUtils.listFiles(buildDirectory, new String[] { "xsd" }, true);
     }
 
     /**
      * Iterates through build schema files processing validation place-holders and outputting to static directory. Include file
      * for referenced schema types is also written out
      * 
      * @param buildSchemaFiles collection of File objects for build schema files
      * @param staticDirectoryPath path that processed schema files will be written to
      * @param buildDirectoryPath path of build schema files
      * @param useDataDictionaryValidation indicates whether data dictionary validation should be used, if false the general xsd
      *            datatype in the place-holder will be used
      * @param externalizableContentUrl URL to set for externalizable.static.content.url token
      * @throws IOException thrown for any read/write errors encountered
      */
     protected static void buildSchemaFiles(Collection buildSchemaFiles, String staticDirectoryPath, String buildDirectoryPath, boolean useDataDictionaryValidation, String externalizableContentUrl, boolean rebuildDDTypes) throws IOException {
         // initialize dd type schema
         Collection typesSchemaLines = initalizeDataDictionaryTypesSchema();
         Set<String> builtTypes = new HashSet<String>();
 
         // convert static directory path to abstract path
         File staticDirectory = new File(staticDirectoryPath);
         String staticPathName = staticDirectory.getAbsolutePath();
 
         for (Iterator iterator = buildSchemaFiles.iterator(); iterator.hasNext();) {
             File buildSchemFile = (File) iterator.next();
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Processing schema file: " + buildSchemFile.getName());
             }
 
             String outSchemaFilePathName = staticPathName + getRelativeFilePathName(buildSchemFile, buildDirectoryPath);
             LOG.info("Building schema file: " + outSchemaFilePathName);
 
             buildSchemaFile(buildSchemFile, outSchemaFilePathName, useDataDictionaryValidation, typesSchemaLines, externalizableContentUrl, builtTypes, rebuildDDTypes);
         }
 
         // finalize dd type schema
         typesSchemaLines.addAll(finalizeDataDictionaryTypesSchema());
 
         if (rebuildDDTypes) {
             LOG.debug("Writing ddTypes schema file");
             File ddTypesFile = new File(staticPathName + File.separator + "xsd" + File.separator + "sys" + File.separator + "ddTypes.xsd");
             File ddTypesFileBuild = new File(buildDirectoryPath + File.separator + "xsd" + File.separator + "sys" + File.separator + "ddTypes.xsd");
             FileUtils.writeLines(ddTypesFile, typesSchemaLines);
             FileUtils.copyFile(ddTypesFile, ddTypesFileBuild);
         }
     }
 
     /**
      * Process a single schema file (setting validation and externalizable token) and outputs to static directory. Any new data
      * dictionary types encountered are added to the given Collection for later writing to the types include file
      * 
      * @param buildSchemFile build schema file that should be processed
      * @param outSchemaFilePathName full file path name for the outputted schema
      * @param useDataDictionaryValidation indicates whether data dictionary validation should be used, if false the general xsd
      *            datatype in the place-holder will be used
      * @param typesSchemaLines collection of type XML lines to add to for any new types
      * @param externalizableContentUrl URL to set for externalizable.static.content.url token
      * @param builtTypes - Set of attribute names for which a schema validation type has been built
      * @throws IOException thrown for any read/write errors encountered
      */
     protected static void buildSchemaFile(File buildSchemFile, String outSchemaFilePathName, boolean useDataDictionaryValidation, Collection typesSchemaLines, String externalizableContentUrl, Set<String> builtTypes, boolean rebuildDDTypes) throws IOException {
         Collection buildSchemaLines = FileUtils.readLines(buildSchemFile);
         Collection outSchemaLines = new ArrayList();
         int lineCount = 1;
         for (Iterator iterator = buildSchemaLines.iterator(); iterator.hasNext();) {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Processing line " + lineCount + "of file " + buildSchemFile.getAbsolutePath());
             }
             String buildLine = (String) iterator.next();
             String outLine = buildLine;
 
             // check for externalizable.static.content.url token and replace if found
             if (StringUtils.contains(buildLine, "@externalizable.static.content.url@")) {
                 outLine = StringUtils.replace(buildLine, "@externalizable.static.content.url@", externalizableContentUrl);
             }
 
             // check for validation place-holder and process if found
             else if (StringUtils.contains(buildLine, SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_BEGIN) && StringUtils.contains(buildLine, SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_END)) {
                 String validationPlaceholder = StringUtils.substringBetween(buildLine, SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_BEGIN, SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_END);
                 if (StringUtils.isBlank(validationPlaceholder)) {
                     logAndThrowException(String.format("File %s line %s: validation placeholder cannot be blank", buildSchemFile.getAbsolutePath(), lineCount));
                 }
 
                 if (LOG.isDebugEnabled()) {
                     LOG.debug("Found dd validation placeholder: " + validationPlaceholder);
                 }
                 if (!StringUtils.contains(validationPlaceholder, ",")) {
                     logAndThrowException(String.format("File %s, line %s: Invalid format of placehoder value: %s, must contain a ',' seperating parts", buildSchemFile.getAbsolutePath(), lineCount, validationPlaceholder));
                 }
 
                 outLine = processValidationPlaceholder(validationPlaceholder, buildLine, buildSchemFile.getAbsolutePath(), lineCount, useDataDictionaryValidation, typesSchemaLines, builtTypes, rebuildDDTypes);
             }
 
             outSchemaLines.add(outLine);
             lineCount++;
         }
 
         LOG.debug("Writing schema file to static directory");
         File schemaFile = new File(outSchemaFilePathName);
         FileUtils.writeLines(schemaFile, outSchemaLines);
     }
 
     /**
      * Performs logic to processes a validation place-holder for a line. First collects the configuration given in the
      * place-holder (general xsd type and data dictionary attribute). If use data dictionary validation is set to false, then the
      * place-holder will be set to the xsd type. If data dictionary validation is set to true, the general xsd type will be
      * removed, and the corresponding the data dictionary will be consulted to build the dd type
      * 
      * <pre>
      * ex. type="${xsd:token,dd:Chart.chartOfAccountsCode}" with useDataDictionaryValidation=false becomes type="xsd:token"
      *    type="${xsd:token,dd:Chart.chartOfAccountsCode}" with useDataDictionaryValidation=true becomes type="dd:Chart.chartOfAccountsCode" and XML lines created for dd Types file
      * </pre>
      * 
      * @param validationPlaceholder the parsed place-holder contents
      * @param buildLine the complete line being read
      * @param fileName the name for the file being processed
      * @param lineCount count for the line being read
      * @param useDataDictionaryValidation indicates whether data dictionary validation should be used, if false the general xsd
      *            datatype in the place-holder will be used
      * @param typesSchemaLines collection of type XML lines to add to for any new types
      * @param builtTypes - Set of attribute names for which a schema validation type has been built
      * @return String the out XML line (which validation filled in)
      */
     protected static String processValidationPlaceholder(String validationPlaceholder, String buildLine, String fileName, int lineCount, boolean useDataDictionaryValidation, Collection typesSchemaLines, Set<String> builtTypes, boolean rebuildDDTypes) {
         String orignalPlaceholderValue = validationPlaceholder;
 
         // remove whitespace
         validationPlaceholder = StringUtils.deleteWhitespace(validationPlaceholder);
 
         // get two parts of validation place-holder
         String[] validationParts = StringUtils.split(validationPlaceholder, ",");
         String xsdValidation = validationParts[0];
         if (StringUtils.isBlank(xsdValidation) || !xsdValidation.startsWith(XSD_VALIDATION_PREFIX)) {
             logAndThrowException(String.format("File %s, line %s: specified xsd validation is invalid, must start with %s", fileName, lineCount, XSD_VALIDATION_PREFIX));
         }
 
         String ddAttributeName = validationParts[1];
         if (StringUtils.isBlank(ddAttributeName) || !ddAttributeName.startsWith(DD_VALIDATION_PREFIX)) {
             logAndThrowException(String.format("File %s, line %s: specified dd validation is invalid, must start with %s", fileName, lineCount, DD_VALIDATION_PREFIX));
         }
 
         String outLine = buildLine;
         if (useDataDictionaryValidation) {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Setting validation to use type: " + ddAttributeName);
             }
             outLine = StringUtils.replace(outLine, SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_BEGIN + orignalPlaceholderValue + SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_END, ddAttributeName);
 
             if (rebuildDDTypes) {
                 buildDataDictionarySchemaValidationType(ddAttributeName, typesSchemaLines, builtTypes);
             }
         }
         else {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Setting validation to use type: " + xsdValidation);
             }
             outLine = StringUtils.replace(outLine, SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_BEGIN + orignalPlaceholderValue + SCHEMA_FILE_DD_VALIDATION_PLACEHOLDER_END, xsdValidation);
         }
 
         return outLine;
     }
 
     /**
      * Constructs new AttributeSchemaValidationBuilder for the given attribute name to build the type XML lines which are added to
      * the given collection
      * 
      * @param ddAttributeName attribute entry name (business object class and attribute name) with dd: namespace prefix
      * @param typesSchemaLines collection of type XML lines to add to for any new types
      * @param builtTypes - Set of attribute names for which a schema validation type has been built
      * @see org.kuali.ole.sys.context.AttributeSchemaValidationBuilder
      */
     protected static void buildDataDictionarySchemaValidationType(String ddAttributeName, Collection typesSchemaLines, Set<String> builtTypes) {
         // strip prefix from attribute name so we can find it in dd map
         String attributeEntryName = StringUtils.removeStart(ddAttributeName, DD_VALIDATION_PREFIX);
         if (LOG.isDebugEnabled()) {
             LOG.debug("Retrieving entry from data dictionary for attribute: " + attributeEntryName);
         }
 
         // only build one type for the attribute name
         if (!builtTypes.contains(attributeEntryName)) {
             AttributeSchemaValidationBuilder schemaBuilder = new AttributeSchemaValidationBuilder(attributeEntryName);
             typesSchemaLines.addAll(schemaBuilder.toSchemaType());
             typesSchemaLines.add(" ");
 
             builtTypes.add(attributeEntryName);
         }
     }
 
     /**
      * Builds header XML lines for the data dictionary types include
      * 
      * @return Collection containing the XML lines
      */
     protected static Collection initalizeDataDictionaryTypesSchema() {
         LOG.debug("Initializing dd types schema");
         Collection typesSchemaLines = new ArrayList();
 
         typesSchemaLines.add("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
         typesSchemaLines.add("<xsd:schema elementFormDefault=\"qualified\"");
         typesSchemaLines.add("    targetNamespace=\"http://www.kuali.org/ole/sys/ddTypes\"");
         typesSchemaLines.add("    xmlns:dd=\"http://www.kuali.org/ole/sys/ddTypes\"");
         typesSchemaLines.add("    xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">");
         typesSchemaLines.add("");
 
         return typesSchemaLines;
     }
 
     /**
      * Builds footer XML lines for the data dictionary types include .
      * 
      * @return Collection containing the XML lines
      */
     protected static Collection finalizeDataDictionaryTypesSchema() {
         LOG.debug("Finalizing dd types schema");
         Collection typesSchemaLines = new ArrayList();
 
         typesSchemaLines.add("</xsd:schema>");
 
         return typesSchemaLines;
     }
 
     /**
      * Determines what the relative path of the given file is relative to the given parent path. Since parentPath is configured
      * string method checks for / or \\ path separators .
      * 
      * <pre>
      * eg. File path - /build/project/xsd/gl/collector.xsd, Parent Path - /build/project/xsd returns gl/collector.xsd
      * </pre>
      * 
      * @param file File for which we want to find the relative path
      * @param parentPath Path to parent directory
      * @return String the relative path of the file
      */
     protected static String getRelativeFilePathName(File file, String parentPath) {
         // create File for parentPath so we can compare path to schema File
         File parentDirectory = new File(parentPath);
 
         String fullParentPathName = parentDirectory.getAbsolutePath();
         String fullFilePathName = file.getAbsolutePath();
 
         String relativeFilePathName = StringUtils.substringAfter(fullFilePathName, fullParentPathName);
         if (LOG.isDebugEnabled()) {
             LOG.debug("sub-directory for schema: " + relativeFilePathName);
         }
 
         if (StringUtils.isBlank(relativeFilePathName)) {
             String msg = String.format("Cannot find relative path for file name %s from parent directory %s", fullFilePathName, fullParentPathName);
             LOG.error(msg);
             throw new RuntimeException(msg);
         }
 
         return relativeFilePathName;
     }
 
     /**
      * Helper method for logging an error and throwing a new RuntimeException
      * 
      * @param msg message for logging and exception
      */
     protected static void logAndThrowException(String msg) {
         LOG.error(msg);
         throw new RuntimeException(msg);
     }
 
 }