/**

  *    Copyright 2005-2011 Steve McDuff d-duff@users.sourceforge.net

  *

  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0

  *

  * 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.deduced.generator.java;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import org.apache.commons.lang.StringUtils;

 import org.deduced.DeducedModelLayer;

 import org.deduced.DeducedSchemaLayer;

 import org.deduced.DeducedUtilities;

 import org.deduced.OrderedPropertyListType;

 import org.deduced.PropertyCollection;

 import org.deduced.PropertyCollectionType;

 import org.deduced.framework.DeducedModelLayerExtensionImplementation;

 import org.deduced.framework.FrameworkUtilities;

 import org.deduced.generator.VelocityGenerator;

 import org.deduced.utilities.FileUtilities;

 import org.deduced.xml.XmlFileParser;

 import org.deduced.xml.XmlFileParserImplementation;

 /**

  * Class used to generate a java interface based on a property collection type.

  * 

  * @author Steve McDuff

  */

 public class JavaGeneratorUtilities

 {

         /**

          * Logger

          */

         private static final Logger LOGGER = Logger

                 .getLogger(JavaGeneratorUtilities.class.getName());

         /** XML file parser to use */

         private static XmlFileParser XML_PARSER = new XmlFileParserImplementation();

         /**

          * file name used to generate Java Interfaces

          */

         public static final String JAVA_INTERFACE_TEMPLATE =

                 "org/deduced/generator/java/JavaInterface.vm";

         /**

          * file name used to generate Java Implementations

          */

         public static final String JAVA_IMPLEMENTATION_TEMPLATE =

                 "org/deduced/generator/java/JavaImplementation.vm";

         /**

          * file name used to generate Java Schema

          */

         public static final String JAVA_FRAMEWORK_TEMPLATE =

                 "org/deduced/generator/java/JavaFramework.vm";

         /**

          * file name used to generate Java ordered property list interfaces

          */

         private static final String JAVA_ORDERED_PROPERTY_LIST_INTERFACE_TEMPLATE =

                 "org/deduced/generator/java/JavaOrderedPropertyListInterface.vm";

         /**

          * file name used to generate Java ordered property list implementation

          */

         private static final String JAVA_ORDERED_PROPERTY_LIST_IMPLEMENTATION_TEMPLATE =

                 "org/deduced/generator/java/JavaOrderedPropertyListImplementation.vm";

         /**

          * method used to generate a java implementation for a property collection

          * type

          * 

          * @param type the property collection type

          * @param outputFolderName the output folder name to use

          * @throws IOException any exception that occurs while attempting to write

          *             the file

          */

         public static void generateImplementationForType(

                 PropertyCollection<?, ?> type, String outputFolderName)

                 throws IOException

         {

                 validateTypePackageName(type);

                 String implementationFileName =

                         JavaNamingUtilities.getImplementationFileName(type);

                 String implementationFolderName =

                         JavaNamingUtilities.getImplementationFolderName(type);

                 String folderName =

                         FileUtilities.mergeFolderName(outputFolderName,

                                 implementationFolderName);

                 String javaImplementationTemplate = JAVA_IMPLEMENTATION_TEMPLATE;

                 boolean isOrderedPropertyListType = isOrderedPropertyListType(type);

                 if (isOrderedPropertyListType)

                 {

                         javaImplementationTemplate =

                                 JAVA_ORDERED_PROPERTY_LIST_IMPLEMENTATION_TEMPLATE;

                 }

                 generateType(type, javaImplementationTemplate, folderName,

                         implementationFileName);

         }

         /**

          * utility method to generate an output based on a property collection type

          * and a velocity template

          * 

          * @param type the property collection type

          * @param template the velocity template file name to use

          * @param folderName the folder name in which to output the files

          * @param fileName the file name that will be created

          * @throws IOException any exception that occurs while attempting to write

          *             the file

          */

         private static void generateType(

                 PropertyCollection<?, ?> type, String template, String folderName,

                 String fileName) throws IOException

         {

                 if (LOGGER.isLoggable(Level.FINE))

                 {

                         LOGGER.log(Level.FINE,

                                 "Generating : " + DeducedUtilities.getCollectionName(type)

                                         + " using template : " + template);

                 }

                 ByteArrayOutputStream outStream = new ByteArrayOutputStream();

                 VelocityGenerator generator = new VelocityGenerator();

                 generator.setOutputStream(outStream);

                 generator.setTemplateName(template);

                 generator.getContext().put("type", type);

                 fillCommonGeneratorContext(generator);

                 generator.generate();

                 FileUtilities.forceCreateDirectory(folderName);

                 String output = FileUtilities.mergeFolderName(folderName, fileName);

                 FileUtilities.writeFileContent(output, outStream.toByteArray());

                 outStream.close();

         }

         /**

          * generate the framework class used to initialize a schema

          * 

          * @param model the model hosting the schema. Used to extract dependent

          *            schemas.

          * @param schema the schema which will be used to generate the factory

          * @param outputFolderName the output folder name.

          * @throws IOException any exception that occurs while attempting to write

          *             the file

          */

         public static void generateFrameworkForSchema(

                 PropertyCollection<?, ?> model, PropertyCollection<?, ?> schema,

                 String outputFolderName) throws IOException

         {

                 String template = JAVA_FRAMEWORK_TEMPLATE;

                 String schemaName = DeducedUtilities.getCollectionName(schema);

                 String frameworkFileName =

                         JavaNamingUtilities.getSchemaClassName(schemaName) + ".java";

                 String frameworkFolderName =

                         JavaNamingUtilities.getSchemaFolderName(schemaName);

                 String folderName =

                         FileUtilities

                                 .mergeFolderName(outputFolderName, frameworkFolderName);

                 if (LOGGER.isLoggable(Level.FINE))

                 {

                         LOGGER.log(Level.FINE, "Generating : " + schemaName

                                 + " using template : " + template);

                 }

                 ByteArrayOutputStream outStream = new ByteArrayOutputStream();

                 VelocityGenerator generator = new VelocityGenerator();

                 generator.setOutputStream(outStream);

                 generator.setTemplateName(template);

                 generator.getContext().put("schema", schema);

                 generator.getContext().put("model", model);

                 fillCommonGeneratorContext(generator);

                 generator.generate();

                 FileUtilities.forceCreateDirectory(folderName);

                 String output =

                         FileUtilities.mergeFolderName(folderName, frameworkFileName);

                 FileUtilities.writeFileContent(output, outStream.toByteArray());

                 outStream.close();

         }

         /**

          * method used to generate a java interface for a property collection type

          * 

          * @param type the property collection type

          * @param outputFolderName the output folder name

          * @throws IOException any exception that occurs while attempting to write

          *             the file

          */

         public static void generateInterfaceForType(

                 PropertyCollection<?, ?> type, String outputFolderName)

                 throws IOException

         {

                 validateTypePackageName(type);

                 String interfaceFileName =

                         JavaNamingUtilities.getInterfaceFileName(type);

                 String interfaceFolderName =

                         JavaNamingUtilities.getInterfaceFolderName(type);

                 String folderName =

                         FileUtilities

                                 .mergeFolderName(outputFolderName, interfaceFolderName);

                 String javaInterfaceTemplate = JAVA_INTERFACE_TEMPLATE;

                 boolean isOrderedPropertyListType = isOrderedPropertyListType(type);

                 if (isOrderedPropertyListType)

                 {

                         javaInterfaceTemplate =

                                 JAVA_ORDERED_PROPERTY_LIST_INTERFACE_TEMPLATE;

                 }

                 generateType(type, javaInterfaceTemplate, folderName, interfaceFileName);

         }

         /**

          * is Ordered Property List Type

          * 

          * @param type the type to test

          * @return true if the type of the specified type is an ordered property

          *         list type.

          */

         public static boolean isOrderedPropertyListType(

                 PropertyCollection<?, ?> type)

         {

                 PropertyCollectionType orderedPropertyListType =

                         OrderedPropertyListType.ORDERED_PROPERTY_LIST_TYPE_TYPE

                                 .getPropertyCollectionType();

                 PropertyCollection<?, ?> typeOfTheCurrentType = type.type();

                 boolean isOrderedPropertyListType =

                         DeducedUtilities.isInstanceOf(typeOfTheCurrentType,

                                 orderedPropertyListType);

                 return isOrderedPropertyListType;

         }

         /**

          * test if the package name is valid for a type

          * 

          * @param type the type to test

          */

         public static void validateTypePackageName(

                 PropertyCollection<?, ?> type)

         {

                 String interfacePackageName =

                         JavaNamingUtilities.getInterfacePackageName(type);

                 if (StringUtils.isEmpty(interfacePackageName))

                 {

                         throw new IllegalArgumentException(

                                 "Invalid empty package name for type : "

                                         + DeducedUtilities.getCollectionName(type));

                 }

         }

         /**

          * Utility method to fill the velocity generation context with common

          * variables

          * 

          * @param generator the velocity generator to use

          */

         private static void fillCommonGeneratorContext(

                 VelocityGenerator generator)

         {

                 generator.getContext().put("javaNamingUtilities",

                         JavaNamingUtilities.DEFAULT);

                 generator.getContext().put("deducedUtilities", new DeducedUtilities());

         }

         /**

          * generate all the files required to use the specified schema. This method

          * will generate the framework, all the interfaces and implementations of

          * types within the schema.

          * 

          * @param model the model hosting the schema

          * @param schema the schema to generate

          * @param outputFolderName the output folder to use

          * @throws IOException any exception that occurs while attempting to write

          *             the file

          */

         public static void generateFilesForSchema(

                 PropertyCollection<?, ?> model, PropertyCollection<?, ?> schema,

                 String outputFolderName) throws IOException

         {

                 List<PropertyCollection<?, ?>> propertyCollectionTypeListFromSchema =

                         JavaNamingUtilities.getPropertyCollectionTypeListFromSchema(schema);

                 generateFrameworkForSchema(model, schema, outputFolderName);

                 for (PropertyCollection<?, ?> currentType : propertyCollectionTypeListFromSchema)

                 {

                         generateImplementationForType(currentType, outputFolderName);

                         generateInterfaceForType(currentType, outputFolderName);

                 }

         }

         /**

          * generate the Java Schema files from a DeducedModelLayer. Any schema

          * contained in the base property collection list on the model will be

          * generated

          * 

          * @param outputFolderName the folder where Java files will be created

          * @param schemaModelToGenerate the DeducedModelLayer containing some

          *            DeducedSchemaLayer objects

          * @throws IOException any error that occurs while writing the files

          */

         public static void generateSchemaFromModel(

                 String outputFolderName, PropertyCollection<?, ?> schemaModelToGenerate)

                 throws IOException

         {

                 PropertyCollection<?, ?> collectionList =

                         (PropertyCollection<?, ?>) schemaModelToGenerate

                                 .getPropertyValue(DeducedModelLayer.COLLECTION_LIST_INSTANCE

                                         .getKey());

                 List<?> schemaValueList = collectionList.asValueList();

                 for (Object object : schemaValueList)

                 {

                         PropertyCollection<?, ?> possibleSchema =

                                 (PropertyCollection<?, ?>) object;

                         if (DeducedUtilities.isInstanceOf(possibleSchema.type(),

                                 DeducedSchemaLayer.DEDUCED_SCHEMA_LAYER_TYPE

                                         .getPropertyCollectionType()))

                         {

                                 JavaGeneratorUtilities.generateFilesForSchema(

                                         schemaModelToGenerate, possibleSchema, outputFolderName);

                         }

                 }

         }

         /**

          * Load a model layer from a XML file and add it to the application hub for

          * future reference. Note that if errors occur, the loaded model will only

          * contain a partially loaded file.

          * 

          * @param xmlFileName the XML file name to load

          * @param generatorApplicationModel the application model to use while

          *            loading

          * @param ignoreXmlErrors if set to true, any non-fatal error encountered

          *            while reading the xml file will not throw an exception and the

          *            resulting partially loaded model is returned

          * @return the loaded schema model layer

          * @throws Exception any error that occurs while decoding the XML file.

          */

         @SuppressWarnings("unchecked")

         public static PropertyCollection<?, ?> loadModelFromXmlFile(

                 String xmlFileName, PropertyCollection<?, ?> generatorApplicationModel,

                 boolean ignoreXmlErrors) throws Exception

         {

                 DeducedModelLayerExtensionImplementation newSchemaModel =

                         FrameworkUtilities.createDynamicModelLayer();

                 XmlFileParser xmlParser = getXmlParser();

                 xmlParser.readModelLayer(xmlFileName, newSchemaModel,

                         generatorApplicationModel, ignoreXmlErrors);

                 Object collectionListKey =

                         DeducedModelLayer.COLLECTION_LIST_INSTANCE.getKey();

                 PropertyCollection collectionList =

                         (PropertyCollection) generatorApplicationModel

                                 .getPropertyValue(collectionListKey);

                 collectionList.addProperty(null, null, newSchemaModel);

                 return newSchemaModel;

         }

         /**

          * @param setXmlParser the xml parser to set

          */

         public static void setXmlParser(

                 XmlFileParser setXmlParser)

         {

                 XML_PARSER = setXmlParser;

         }

         /**

          * @return the xml parser

          */

         public static XmlFileParser getXmlParser()

         {

                 return XML_PARSER;

         }

 }