/**
    * Copyright 2008 Bryan Ray
    * 
    * 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 uk.org.bryanray.testtoys.generator;
  
  import java.io.BufferedWriter;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Map.Entry;
  
  import org.apache.commons.cli.CommandLine;
  import org.apache.commons.cli.CommandLineParser;
  import org.apache.commons.cli.GnuParser;
  import org.apache.commons.cli.HelpFormatter;
  import org.apache.commons.cli.Option;
  import org.apache.commons.cli.OptionBuilder;
  import org.apache.commons.cli.Options;
  import org.apache.commons.cli.ParseException;
  
  import uk.org.bryanray.testtoys.generator.sequencegenerators.SequenceGenerator;
  import uk.org.bryanray.testtoys.util.BeanUtil;
  import uk.org.bryanray.testtoys.util.ExceptionUtil;
  import uk.org.bryanray.testtoys.util.TemplateUtil;
  
  /**
   * <DL>
   * <DT><B>Project:</B></DT>
   * <DD>TestDataLoader</DD>
   * <DT><B>Filename:</B></DT>
   * <DD>Generator.java</DD>
   * <DT><B>Creation Date:</B></DT>
   * <DD>25 May 2008</DD>
   * </DL>
   * 
   * The purpose of this this application is to generate a large quantity of test
   * data for performance testing.
   * 
   * @author Bryan Ray
   */
  public class Generator {
  
  	/**
  	 * A map that associates a sequence name with a {@link SequenceGenerator}
  	 * instance. The sequence name is what is used in the template to specify
  	 * which sequence to use.
  	 */
  	private Map<String, SequenceGenerator> sequences;
  
  	/**
  	 * A map that associates a template with an output stream to which the
  	 * template will repeatedly be written. The template is in the form of a
  	 * {@link String} and the output stream is an instance of
  	 * {@link OutputStream}.
  	 */
  	private Map<String, Writer> writerTemplates;
  
  	/**
  	 * The number of entities to generate.
  	 */
  	private int entityCount = 0;
  
  	/**
  	 * @param args
  	 *            The command line arguments.
  	 */
  	public static void main(String[] args) {
  		Generator generator = new Generator();
  		// Read configuration file
  		Options commandOptions = getCommandOptions();
  		CommandLine commandLine = parseCommandArguments(args, commandOptions);
  		if (commandLine.hasOption("configfile")) {
  			try {
  				String configFileName = commandLine
  						.getOptionValue("configfile");
  				generator.initialiseConfig(new FileInputStream(configFileName));
  			} catch (FileNotFoundException fnfe) {
 				throw ExceptionUtil.convertException(fnfe);
 			}
 		} else {
 			HelpFormatter formatter = new HelpFormatter();
 			formatter.printHelp("generator", commandOptions);
 		}
 
 		// Generate test data
 		generator.generate();
 		generator.closeWriters();
 	}
 
 	/**
 	 * @param commandArguments
 	 *            The command arguments passed to {@link #main(String[]).
 	 * @param options
 	 *            The options builder from {@link #getCommandOptions().
 	 */
 	private static CommandLine parseCommandArguments(String[] commandArguments,
 			Options options) {
 		CommandLineParser parser = new GnuParser();
 		try {
 			return parser.parse(options, commandArguments);
 		} catch (ParseException pe) {
 			throw ExceptionUtil.convertException(pe);
 		}
 	}
 
 	/**
 	 * @return A command line object that follows the builder pattern.
 	 */
 	@SuppressWarnings("static-access")
 	private static Options getCommandOptions() {
 		Options options = new Options();
 		Option configFile = OptionBuilder.withArgName("file").hasArg()
 				.withDescription("use given configuration file").create(
 						"configfile");
 		options.addOption(configFile);
 		return options;
 	}
 
 	/**
 	 * Convenience method that calls individual configuration methods.
 	 * 
 	 * @see #initialiseApplication(Properties)
 	 * @see #initialiseSequences(Properties)
 	 * @see #initialiseTemplates(Properties)
 	 */
 	private void initialiseConfig(InputStream inputStream) {
 		Properties properties = new Properties();
 		try {
 			properties.load(inputStream);
 		} catch (IOException ioe) {
 			throw ExceptionUtil.convertException(ioe);
 		}
 		initialiseApplication(properties);
 		initialiseSequences(properties);
 		initialiseTemplates(properties);
 	}
 
 	/**
 	 * @param properties
 	 *            The configuration that will determine how many entities will
 	 *            be generated for the test data.
 	 */
 	private void initialiseApplication(Properties properties) {
 		String entityCount = properties.getProperty("entity.count");
 		if (null != entityCount) {
 			this.entityCount = Integer.parseInt(entityCount);
 		}
 	}
 
 	/**
 	 * @param properties
 	 *            The configuration that will determine what values fill the
 	 *            place holders in the output stream templates.
 	 */
 	private void initialiseSequences(Properties properties) {
 		sequences = new HashMap<String, SequenceGenerator>();
 		for (Iterator<Entry<Object, Object>> i = properties.entrySet()
 				.iterator(); i.hasNext();) {
 			Entry<Object, Object> entry = i.next();
 			String key = entry.getKey().toString();
 			if (key.startsWith("sequence.")) {
 				String sequenceName = key.substring(9);
 				String[] sequenceValues = entry.getValue().toString().split(
 						",", 2);
 				if (2 <= sequenceValues.length) {
 					String className = sequenceValues[0];
 					String[] constructorArguments = sequenceValues[1]
 							.split(",");
 					SequenceGenerator generator = (SequenceGenerator) BeanUtil
 							.createInstance(className,
 									new Class[] { java.util.List.class },
 									new Object[] { Arrays
 											.asList(constructorArguments) });
 					sequences.put(sequenceName, generator);
 				} else {
 					throw new RuntimeException(
 							"Bad configuration for sequence:" + sequenceName);
 				}
 			}
 		}
 	}
 
 	/**
 	 * @param properties
 	 *            The configuration for the output streams, determining the file
 	 *            name for the stream and the template that will be written.
 	 */
 	private void initialiseTemplates(Properties properties) {
 		writerTemplates = new HashMap<String, Writer>();
 		for (Iterator<Entry<Object, Object>> i = properties.entrySet()
 				.iterator(); i.hasNext();) {
 			Entry<Object, Object> entry = i.next();
 			String key = entry.getKey().toString();
 			if (key.startsWith("template.")) {
 				String templateName = key.substring(9);
 				String template = entry.getValue().toString();
 
 				Object outputFileObject = properties.get("testdata."
 						+ templateName);
 				if (null != outputFileObject) {
 					String outputFile = outputFileObject.toString();
 					OutputStream outputStream = null;
 					try {
 						outputStream = new FileOutputStream(outputFile);
 					} catch (FileNotFoundException fnfe) {
 						throw ExceptionUtil.convertException(fnfe);
 					}
 					Writer writer = new BufferedWriter(new OutputStreamWriter(
 							outputStream));
 					writerTemplates.put(template, writer);
 				} else {
 					throw new RuntimeException(
 							"Bad configuration for template:" + templateName);
 				}
 			}
 		}
 	}
 
 	/**
 	 * Writes test data to the output streams.
 	 */
 	private void generate() {
 		for (int i = 0; i < entityCount; i++) {
 			for (Iterator<Entry<String, Writer>> templateIterator = writerTemplates
 					.entrySet().iterator(); templateIterator.hasNext();) {
 				Entry<String, Writer> entry = templateIterator.next();
 				String template = entry.getKey();
 				Writer writer = entry.getValue();
 				String entity = TemplateUtil.substituteTemplatePlaceholders(
 						template, new SequenceMapAdapter(sequences));
 				try {
 					writer.write(entity);
 				} catch (IOException ioe) {
 					throw ExceptionUtil.convertException(ioe);
 				}
 			}
 
 			for (Iterator<SequenceGenerator> generatorIterator = sequences
 					.values().iterator(); generatorIterator.hasNext();) {
 				SequenceGenerator generator = generatorIterator.next();
 				generator.next();
 			}
 		}
 	}
 
 	/**
 	 * Closes all the output streams.
 	 */
 	private void closeWriters() {
 		if (null != Generator.this.writerTemplates) {
 			for (Iterator<Writer> i = Generator.this.writerTemplates.values()
 					.iterator(); i.hasNext();) {
 				Writer w = i.next();
 				try {
 					w.close();
 				} catch (IOException ioe) {
 					ioe.printStackTrace();
 				}
 			}
 		}
 	}
 
 	/**
 	 * A finaliser that will always be called.
 	 */
 	private final Object finaliser = new Object() {
 		@Override
 		protected void finalize() throws Throwable {
 			closeWriters();
 		}
 	};
 }