/**
    * 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.loader;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.PrintStream;
  import java.io.Reader;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  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 org.supercsv.io.CsvMapReader;
  import org.supercsv.prefs.CsvPreference;
  
  import uk.org.bryanray.testtoys.util.ExceptionUtil;
  import uk.org.bryanray.testtoys.util.TemplateUtil;
  
  /**
   * A class that generates a SQL script to load test data, from a SQL template
   * and CSV data describing the entities.
   */
  public class Loader {
  
  	private static Map<String, ValueFormatter> FORMATTERS = new HashMap<String, ValueFormatter>();
  	private static ValueFormatter STRING_FORMATTER = new StringFormatter();
  
  	static {
  		FORMATTERS.put("st", STRING_FORMATTER);
  		FORMATTERS.put("sq", new SqlFormatter());
  		FORMATTERS.put("nu", new NumberFormatter());
  	}
  
  	private String template = "";
  	private String[] header = new String[0];
  	private Iterator<Map<String, String>> testDataEntities;
  	private Map<String, ValueFormatter> columnValueFormatters;
  
  	/**
  	 * @param args
  	 *            The command line arguments.
  	 */
  	public static void main(String[] args) {
  		Loader loader = new Loader();
  		Options commandOptions = getCommandOptions();
  		CommandLine commandLine = parseCommandArguments(args, commandOptions);
  		if (commandLine.hasOption("templatefile")
  				&& commandLine.hasOption("testdatafile")
  				&& commandLine.hasOption("sqlfile")) {
  			String templateFileName = commandLine
  					.getOptionValue("templatefile");
  			String testDataFileName = commandLine
  					.getOptionValue("testdataFile");
  			String sqlFileName = commandLine.getOptionValue("sqlfile");
  
  			File templateFile = new File(templateFileName);
  			File testDataEntitiesFile = new File(testDataFileName);
  			File sqlOutputFile = new File(sqlFileName);
  
  			try {
  				InputStream templateInputStream = new FileInputStream(
  						templateFile);
  				loader.setTemplate(templateInputStream);
  			} catch (FileNotFoundException fnfe) {
  				System.err.println("Template file not found.");
  				return;
  			}
  
  			try {
 				InputStream testDataEntitiesInputStream = new FileInputStream(
 						testDataEntitiesFile);
 				loader.setTestDataEntities(testDataEntitiesInputStream);
 			} catch (FileNotFoundException fnfe) {
 				System.err.println("Test data entities file not found.");
 				return;
 			}
 
 			loader.configureValueFormatters();
 
 			try {
 				String testData = loader.generateTestData();
 				PrintStream output = System.out;
 				if (null != sqlOutputFile) {
 					output = new PrintStream(sqlOutputFile);
 				}
 				output.println(testData);
 			} catch (FileNotFoundException fnfe) {
 				System.err.println("SQL output file not found.");
 				return;
 			}
 		} else {
 			HelpFormatter formatter = new HelpFormatter();
 			formatter.printHelp("loader", commandOptions);
 		}
 	}
 
 	/**
 	 * @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 templateFile = OptionBuilder.withArgName("file").hasArg()
 				.withDescription("use given template file").create(
 						"templatefile");
 		options.addOption(templateFile);
 
 		Option testDataFile = OptionBuilder.withArgName("file").hasArg()
 				.withDescription("use given CSV test data file").create(
 						"testdatafile");
 		options.addOption(testDataFile);
 
 		Option sqlOutputFile = OptionBuilder.withArgName("file").hasArg()
 				.withDescription("SQL data file to generate").create("sqlfile");
 		options.addOption(sqlOutputFile);
 
 		return options;
 	}
 
 	/**
 	 * @param header
 	 *            The header from which to remove the data types.
 	 * @return The header without the data types.
 	 */
 	public String[] stripParameters(String[] header) {
 		String[] result = new String[header.length];
 		for (int i = 0; i < header.length; i++) {
 			String headerItem = header[i];
 			int p = headerItem.indexOf("(");
 			result[i] = headerItem.substring(0, -1 < p ? p : headerItem
 					.length());
 		}
 		return result;
 	}
 
 	/**
 	 * Reads the data types from the header and selects the appropriate
 	 * formatter for the column.
 	 */
 	public void configureValueFormatters() {
 		columnValueFormatters = new HashMap<String, ValueFormatter>();
 		for (int i = 0; i < header.length; i++) {
 			Pattern pattern = Pattern.compile("([^\\(]*)\\(([^\\)]*)\\)");//    
 			Matcher matcher = pattern.matcher(header[i]);
 			String name = header[i];
 			if (matcher.matches()) {
 				name = matcher.group(1);
 			}
 			if (matcher.matches()) {
 				String type = matcher.group(2);
 				ValueFormatter valueFormatter = FORMATTERS.get(type);
 				columnValueFormatters.put(name, valueFormatter);
 			} else {
 				columnValueFormatters.put(name, STRING_FORMATTER);
 			}
 		}
 	}
 
 	/**
 	 * @param template
 	 *            The SQL template.
 	 * @param entities
 	 *            An iterator, which supplies a {@link java.util.Map} for each
 	 *            iteration. The map represents a single entity, with the place
 	 *            holder value in the map value.
 	 * @return The SQL script that will insert test data.
 	 */
 	public String generateTestData() {
 		StringBuffer testData = new StringBuffer();
 		while (testDataEntities.hasNext()) {
 			Map<String, String> placeholderValues = testDataEntities.next();
 
 			// Replace all the place holder values with their formatted values.
 			for (Iterator<Map.Entry<String, String>> i = placeholderValues
 					.entrySet().iterator(); i.hasNext();) {
 				Map.Entry<String, String> entry = i.next();
 				ValueFormatter formatter = columnValueFormatters.get(entry
 						.getKey());
 				entry.setValue(formatter.format(entry.getValue()));
 			}
 
 			// Replace all the place holders with the formatted place holder
 			// values.
 			testData.append(TemplateUtil.substituteTemplatePlaceholders(
 					template, placeholderValues));
 			testData.append("\n");
 		}
 		return testData.toString();
 	}
 
 	/**
 	 * An iterator, which supplies a {@link java.util.Map} for each iteration.
 	 * The map represents a single entity, with the place holder value in the
 	 * map value.
 	 * 
 	 * @param inputStream
 	 *            The input stream to parse as CSV data.
 	 */
 	public void setTestDataEntities(InputStream inputStream) {
 		List<Map<String, String>> entityList = new ArrayList<Map<String, String>>();
 		try {
 			Reader reader = new InputStreamReader(inputStream);
 			CsvMapReader csvReader = new CsvMapReader(reader,
 					CsvPreference.STANDARD_PREFERENCE);
 			this.header = csvReader.getCSVHeader(false);
 			String[] header = stripParameters(this.header);
 			while (true) {
 				Map<String, String> entity = csvReader.read(header);
 				if (null != entity) {
 					entityList.add(entity);
 				} else {
 					break;
 				}
 			}
 		} catch (IOException ioe) {
 			throw new RuntimeException(ioe);
 		}
 		testDataEntities = entityList.iterator();
 	}
 
 	/**
 	 * The SQL template.
 	 * 
 	 * @param The
 	 *            input stream that holds the template.
 	 */
 	public void setTemplate(InputStream inputStream) {
 		StringBuffer template = new StringBuffer();
 		BufferedReader reader = new BufferedReader(new InputStreamReader(
 				inputStream));
 		try {
 			template.append(reader.readLine());
 			while (reader.ready()) {
 				template.append(reader.readLine());
 			}
 			this.template = template.toString();
 		} catch (IOException ioe) {
 			throw new RuntimeException(ioe);
 		}
 	}
 }