/**

  *    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 org.apache.commons.cli.CommandLine;

 import org.apache.commons.cli.CommandLineParser;

 import org.apache.commons.cli.HelpFormatter;

 import org.apache.commons.cli.Option;

 import org.apache.commons.cli.Options;

 import org.apache.commons.cli.ParseException;

 import org.apache.commons.cli.PosixParser;

 import org.apache.commons.lang.StringUtils;

 import org.deduced.AbstractPropertyCollection;

 import org.deduced.DeducedModelLayerExtension;

 import org.deduced.PropertyCollection;

 import org.deduced.framework.FrameworkLoader;

 import org.deduced.utilities.LogUtilities;

 import org.deduced.utilities.SystemExit;

 import org.deduced.utilities.SystemExitImplementation;

 /**

  * Class used go generate java files from the command line

  * 

  * @author Steve McDuff

  */

 public class CommandLineJavaGenerator

 {

         /** system exit wrapper used for tests */

         private static SystemExit EXIT = new SystemExitImplementation();

         /** help option short name */

         public static final String HELP_OPTION_SHORT_NAME = "h";

         /** output folder option short name */

         public static final String OUTPUT_OPTION_SHORT_NAME = "o";

         /** input file name option short name */

         public static final String INPUT_OPTION_SHORT_NAME = "i";

         /** ignore XML loading errors short name */

         public static final String IGNORING_XML_LOADING_ERROR_NAME = "x";

         /** dependent file list option short name */

         public static final String DEPENDENCY_OPTION_SHORT_NAME = "d";

         /**

          * main method used to start the generator

          * 

          * @param arguments command line arguments

          */

         public static void main(

                 String[] arguments)

         {

                 LogUtilities.readLoggerConfigurationOnce(true, new String[]{

                         "logging.properties", "org/deduced/generator/logging.properties" });

                 if (!runGeneratorBasedOnArguments(arguments))

                 {

                         getExit().exit(-1);

                 }

         }

         /**

          * run Generator Based On Arguments

          * 

          * @param arguments the arguments

          * @return true if the execution was successful

          */

         public static boolean runGeneratorBasedOnArguments(

                 String[] arguments)

         {

                 boolean returnValue = false;

                 FrameworkLoader.createBaseSchemaModel();

                 AbstractPropertyCollection

                         .setCheckDeleteMode(AbstractPropertyCollection.CHECK_DELETE_MODE_MANUAL);

                 Options createOptions = createOptions();

                 GeneratorOptions options = new GeneratorOptions();

                 if (readOptions(arguments, createOptions, options))

                 {

                         returnValue = executeActionBasedOnOption(options);

                 }

                 return returnValue;

         }

         /**

          * execute the required action on the generator based on the selected

          * options

          * 

          * @param options the command line option configuration. This parameter is

          *            used to print the help guide if required.

          * @return true if the execution is successful

          */

         public static boolean executeActionBasedOnOption(

                 GeneratorOptions options)

         {

                 boolean retVal = true;

                 if (options.isShowHelp())

                 {

                         printHelp();

                 }

                 else

                 {

                         retVal = runGenerator(options);

                 }

                 return retVal;

         }

         /**

          * run the java file generator based on the selected options

          * 

          * @param options the selected options

          * @return true if the generator ran successfully

          */

         public static boolean runGenerator(

                 GeneratorOptions options)

         {

                 boolean retVal = false;

                 try

                 {

                         DeducedModelLayerExtension hub =

                                 FrameworkLoader

                                         .createApplicationModel("Deduced Generator Application");

                         if (StringUtils.isBlank(options.getInputFileName()))

                         {

                                 throw new IllegalArgumentException("No input file specified");

                         }

                         String[] dependencyFileNameList =

                                 options.getDependencyFileNameList();

                         boolean ignoringXmlLoadingErrors =

                                 options.isIgnoringXmlLoadingErrors();

                         if (dependencyFileNameList != null)

                         {

                                 for (String currentDependency : dependencyFileNameList)

                                 {

                                         if (!StringUtils.isEmpty(currentDependency))

                                         {

                                                 JavaGeneratorUtilities.loadModelFromXmlFile(

                                                         currentDependency, hub, ignoringXmlLoadingErrors);

                                         }

                                 }

                         }

                         PropertyCollection<?, ?> schemaModelToGenerate = null;

                         String inputFileName = options.getInputFileName();

                         schemaModelToGenerate =

                                 JavaGeneratorUtilities.loadModelFromXmlFile(inputFileName, hub,

                                         ignoringXmlLoadingErrors);

                         JavaSchemaGenerator javaGenerator =

                                 new JavaSchemaGeneratorImplementation();

                         javaGenerator.generateSchemaFromModel(

                                 options.getOutputFolderName(), schemaModelToGenerate);

                         retVal = true;

                 }

                 catch (Exception e)

                 {

                         handleError(e, "Failed to generate files");

                         printHelp();

                 }

                 return retVal;

         }

         /**

          * handle Error

          * 

          * @param error the exception that occurred

          * @param errorContext the error context description

          */

         private static void handleError(

                 Exception error, String errorContext)

         {

                 String errorMessage = errorContext + " : " + error.getMessage();

                 setLastError(errorMessage);

                 System.err.println(errorMessage);

                 error.printStackTrace();

         }

         /**

          * last error message

          */

         private static String LAST_ERROR = null;

         /**

          * read options from the input arguments and fill the generator options

          * file. If the parameters fail to be parsed, the error message will printed

          * in the System.err output stream and the method will return false.

          * 

          * @param arguments the command line arguments

          * @param createOptions the command line options

          * @param options the generator options to fill

          * @return true if parameters were successfully parsed.

          */

         public static boolean readOptions(

                 String[] arguments, Options createOptions, GeneratorOptions options)

         {

                 try

                 {

                         CommandLineParser parser = new PosixParser();

                         CommandLine cmd = parser.parse(createOptions, arguments);

                         options.setShowHelp(cmd.hasOption(HELP_OPTION_SHORT_NAME));

                         options.setOutputFolderName(cmd

                                 .getOptionValue(OUTPUT_OPTION_SHORT_NAME));

                         options.setInputFileName(cmd

                                 .getOptionValue(INPUT_OPTION_SHORT_NAME));

                         options.setDependencyFileNameList(cmd

                                 .getOptionValues(DEPENDENCY_OPTION_SHORT_NAME));

                         options.setIgnoringXmlLoadingErrors(cmd

                                 .hasOption(IGNORING_XML_LOADING_ERROR_NAME));

                 }

                 catch (ParseException ex)

                 {

                         handleError(ex, "Parsing command line arguments failed.");

                         printHelp();

                         return false;

                 }

                 return true;

         }

         /**

          * print help on the console

          */

         public static void printHelp()

         {

                 printHelp(createOptions());

         }

         /**

          * print help on the console

          * 

          * @param options the generator options

          */

         public static void printHelp(

                 Options options)

         {

                 HelpFormatter formatter = new HelpFormatter();

                 formatter.printHelp("javagenerator", options);

         }

         /**

          * create command line options used to parse arguments

          * 

          * @return the command line options

          */

         public static Options createOptions()

         {

                 Options retVal = new Options();

                 retVal.addOption(createInputOption());

                 retVal.addOption(createOutputOption());

                 retVal.addOption(createDependenciesOption());

                 retVal.addOption(createHelpOption());

                 retVal.addOption(createIgnoringXmlLoadingErrorOption());

                 return retVal;

         }

         /**

          * create the help option

          * 

          * @return the help option

          */

         public static Option createHelpOption()

         {

                 Option helpOption =

                         new Option(HELP_OPTION_SHORT_NAME, "Print this message.");

                 // set the option properties

                 helpOption.setLongOpt("help");

                 return helpOption;

         }

         /**

          * create the output folder option

          * 

          * @return the output folder option

          */

         public static Option createOutputOption()

         {

                 Option dependenciesOption =

                         new Option(

                                 OUTPUT_OPTION_SHORT_NAME,

                                 "Output folder name where the generated files will be created. "

                                         + "If the folder doesn't exist, the generator will create it. "

                                         + "This option isn't mandatory. If it isn't specified, the output will be "

                                         + "in the current folder.");

                 // set the option properties

                 dependenciesOption.setLongOpt("output");

                 dependenciesOption.setArgs(1);

                 dependenciesOption.setArgName("FOLDER");

                 return dependenciesOption;

         }

         /**

          * create the input file option

          * 

          * @return the input file option

          */

         public static Option createInputOption()

         {

                 Option inputOption =

                         new Option(

                                 INPUT_OPTION_SHORT_NAME,

                                 "Input file name. This should point to a valid XML file that contains "

                                         + "a deduced schema layer. Use quotes to enter file names with blank spaces. "

                                         + "This option is mandatory.");

                 // set the option properties

                 inputOption.setLongOpt("input");

                 inputOption.setArgs(1);

                 inputOption.setArgName("FILE");

                 return inputOption;

         }

         /**

          * create the input file option

          * 

          * @return the input file option

          */

         public static Option createIgnoringXmlLoadingErrorOption()

         {

                 Option inputOption =

                         new Option(IGNORING_XML_LOADING_ERROR_NAME,

                                 "Ignore XML loading errors encountered while loading the input file or "

                                         + "it's dependencies. Default setting is false.");

                 // set the option properties

                 inputOption.setLongOpt("ignoreXmlLoadingErrors");

                 return inputOption;

         }

         /**

          * create the dependencies file list option

          * 

          * @return the dependencies file list option

          */

         public static Option createDependenciesOption()

         {

                 Option dependenciesOption =

                         new Option(

                                 DEPENDENCY_OPTION_SHORT_NAME,

                                 "List of dependent schema files required to generate the current schema. "

                                         + "Use a list of file names separated by a semicolon. The files have to "

                                         + "be in order of dependency. Example : "

                                         + "--dependencies=\"file1.xml;file2.xml\"");

                 // set the option properties

                 dependenciesOption.setLongOpt("dependencies");

                 dependenciesOption.setArgs(Option.UNLIMITED_VALUES);

                 dependenciesOption.setValueSeparator(';');

                 dependenciesOption.setArgName("FILES");

                 return dependenciesOption;

         }

         /**

          * @param setExit the system exit implementation to set

          */

         public static void setExit(

                 SystemExit setExit)

         {

                 EXIT = setExit;

         }

         /**

          * @return the system exit implementation

          */

         public static SystemExit getExit()

         {

                 return EXIT;

         }

         /**

          * @param setLastError the last error to set

          */

         public static void setLastError(

                 String setLastError)

         {

                 LAST_ERROR = setLastError;

         }

         /**

          * @return the last error

          */

         public static String getLastError()

         {

                 return LAST_ERROR;

         }

 }