/*
 * copyright Spry Software, Inc. 2005-2007
 */
package spry.ui;

import spry.ext.model.MultipleTestResultByTestTableModel;
import spry.model.*;
import spry.model.util.LicenseChecker;
import spry.output.FileExportManager;
import spry.output.TableDataStreamer;
import spry.output.ProcessedLotDataOutputter;
import java.io.*;
import java.util.*;


public class DataFileConverter {
	String outputFileName;
	List inputFileNames;
	String outputFormat;
	String outputDataType;
	int splitCols;
	
	public DataFileConverter()
	{
		splitCols = -1;
	}	
	
	public void setSplitCols(int value)
	{
		splitCols = value;
	}
	/**
	 * @return Returns the inputFileName.
	 */
	public List getInputFileNames() {
		return inputFileNames;
	}
	/**
	 * @param intputFileName The intputFileName to set.
	 */
	public void setInputFileNames(List inputFileNames) {
		this.inputFileNames = inputFileNames;
	}
	/**
	 * @return Returns the outputDataType.
	 */
	public String getOutputDataType() {
		return outputDataType;
	}
	/**
	 * @param outputDataType The outputDataType to set.
	 */
	public void setOutputDataType(String outputDataType) {
		this.outputDataType = outputDataType;
	}
	/**
	 * @return Returns the outputFileName.
	 */
	public String getOutputFileName() {
		return outputFileName;
	}
	/**
	 * @param outputFileName The outputFileName to set.
	 */
	public void setOutputFileName(String outputFileName) {
		this.outputFileName = outputFileName;
	}
	/**
	 * @return Returns the outputFormat.
	 */
	public String getOutputFormat() {
		return outputFormat;
	}
	/**
	 * @param outputFormat The outputFormat to set.
	 */
	public void setOutputFormat(String outputFormat) {
		//trim leading --
		int index = 0;
		if (outputFormat == null)
			return;
		while (index < outputFormat.length() && 
				outputFormat.charAt(index)=='-')
		{
			index++;
		}
		if (index < outputFormat.length())
			this.outputFormat = outputFormat.substring(index);
	}
	
	/** @returns 2 for input file does not exist
	 * 
	 *
	 */
	public int runConversion()
	{
		File outputFile = null;
		if (outputFileName != null)
		{
			outputFile = new File(outputFileName);
			if (outputFile.getParentFile() != null &&
					!outputFile.getParentFile().exists())
				return 3;
		}
		Iterator nameIterator = inputFileNames.iterator();
		MultiFileDataStore totalStore = new MultiFileDataStore();
		while (nameIterator.hasNext())
		{
			String inputFileName = (String)nameIterator.next();
			File dataFile = new File(inputFileName);
			
			if (!dataFile.exists())
				System.err.println("Non-existent input file "+inputFileName);
			else
			{
				try
				{
					DataStore dataStore = DataStoreFactory.getInstance().loadDataFile(dataFile, null);
					totalStore.addDataStore(dataStore);
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
				catch (OutOfMemoryError o)
				{
					System.err.println("DataFileConverter ran out of memory reading " + inputFileName);
				}
			}
		}
		TableDataStreamer formatter = FileExportManager.getInstance().getOutputFormatter(
				outputFormat);
		ProcessedLotDataOutputter outputter =
			new ProcessedLotDataOutputter();
		outputter.setDataStore(totalStore);
		outputter.setOutputFormatter(formatter);
		Class modelClass = null;
		if (outputDataType.equals(ModelView.PARAMETRIC))
			modelClass = TestResultTableModel2.class;
		else if (outputDataType.equals(ModelView.HARDWARE_BIN))
			modelClass = HardwareBinSummaryTableModel.class;
		else if (outputDataType.equals(ModelView.SOFTWARE_BIN))
			modelClass = SoftwareBinSummaryTableModel.class;
		else if (outputDataType.equals(ModelView.TEST_SUMMARY))
			modelClass = TestSummaryTableModel2.class;
		else if (outputDataType.equals(ModelView.RESULTS_BY_TEST))
			modelClass = TestResultByTestTableModel.class;
		else if (outputDataType.equals(ModelView.MULTI_PARAMETRIC))
			modelClass = MultipleResultTableModel.class;
		else if (outputDataType.equals(ModelView.MULTI_RESULTS_BY_TEST))
			modelClass = MultipleTestResultByTestTableModel.class;
		if (modelClass != null)
		{
			try
			{
				DataStoreBasedTableModel model = (DataStoreBasedTableModel)modelClass.newInstance();
				model.setDataStore(totalStore);
				if (splitCols <= 0 || model.getColumnCount() <= splitCols)
					outputter.outputData(outputFile, model);
				else
				{
					splitAndOutput(outputFile, model, outputter);
				}
			}
			catch (Exception e)
			{
				System.out.println(e.toString());
			}
		
			//outputter.outputDataStoreBasedModel(outputFile, modelClass);
		}
		return 0;
	}
	
	private void splitAndOutput(File outputFile, DataStoreBasedTableModel model, ProcessedLotDataOutputter outputter)
	{
		int fileIndex = 1;
		int nonKeyColsRemaining = model.getColumnCount() - model.getKeyColumnCount();
		int nextColToMap = model.getKeyColumnCount();
		while (nonKeyColsRemaining > 0)
		{
			String fileName = outputFile.getAbsolutePath();
			if (fileName.contains("###"))
				fileName = fileName.replace("###", Integer.toString(fileIndex));
			else
				fileName = fileName + fileIndex;
			fileIndex++;
			File nextFile = new File(fileName);
			int minRemainingTotalCols = nonKeyColsRemaining + model.getKeyColumnCount();
			int nextModelCols = (minRemainingTotalCols >= splitCols) ? splitCols : minRemainingTotalCols;
			MappedColumnTableModel nextModel = new MappedColumnTableModel(model, nextModelCols);
			for (int newIndex = 0; newIndex < nextModelCols; newIndex++)
			{
				if (newIndex < model.getKeyColumnCount())
					nextModel.mapColumn(newIndex, newIndex);
				else
				{
					nonKeyColsRemaining--;
					nextModel.mapColumn(nextColToMap++, newIndex);
				}
			}
			outputter.outputData(nextFile, nextModel);
		}
	}
	private static void printUsage()
	{
		System.out.println(
				"Usage: java spry.ui.DataFileConverter [switches] datafile1 datafile2 datafile3 ...");
		System.out.println(" the switches currently available are ");
		System.out.println("--format csv (for csv output, currently the only option) ");
		System.out.println("--split columns per split (splits output into a number of files having no more than the given number of columns per file");
		System.out.println("   							Put the value ### in the output file name to indicate where the file number should go, if not at the end)");	
		System.out.println("--output filename (to output results to file instead of standard out)");
		System.out.println("--parametric (output parametric data, default)");
		System.out.println("--parametric_by_test (output parametric data with devices as columns, tests as rows");
		System.out.println("--hardbin (output hardware bin summary data)");
		System.out.println("--softbin (output sofware bin summary data)");
		System.out.println("--testsummary (output test summary data, including limits)");
		System.out.println("--multi_by_test (output multiple parametric result parametric data by test and pin)");
		System.out.println("--multi_parametric (output multiple parametric result parametric data");
	}
	
	static
	{
		DataStoreFactory.getInstance();
	}
	public static void main(String[] args) {
		if (args.length == 0 || args[0].equals("--help"))
		{
			printUsage();
			System.exit(1);
		}
		int argsIndex = 0;
		String format = null;
		LinkedList<String> inputFileNames = new LinkedList<String>();
		String outputFileName = null;
		String outputDataType = ModelView.PARAMETRIC;
		int splitCols = -1;
		while (argsIndex < args.length)
		{
			if (args[argsIndex].equals("--format"))
			{
				argsIndex++;
				format = args[argsIndex];
			}
			else if (args[argsIndex].equals("--output"))
			{
				argsIndex++;
				outputFileName = args[argsIndex];
			}
			else if (args[argsIndex].equals("--parametric"))
				outputDataType = ModelView.PARAMETRIC;
			else if (args[argsIndex].equals("--hardbin"))
				outputDataType = ModelView.HARDWARE_BIN;
			else if (args[argsIndex].equals("--softbin"))
				outputDataType = ModelView.SOFTWARE_BIN;
			else if (args[argsIndex].equals("--testsummary"))
				outputDataType = ModelView.TEST_SUMMARY;
			else if (args[argsIndex].equals("--parametric_by_test"))
				outputDataType = ModelView.RESULTS_BY_TEST;
			else if (args[argsIndex].equals("--multi_by_test"))
				outputDataType = ModelView.MULTI_RESULTS_BY_TEST;
			else if (args[argsIndex].equals("--multi_parametric"))
				outputDataType = ModelView.MULTI_PARAMETRIC;
			else if (args[argsIndex].equals("--split"))
			{
				argsIndex++;
				splitCols = Integer.parseInt(args[argsIndex]);
			}
			else 
			{
				inputFileNames.add(args[argsIndex]);
			}
			argsIndex++;
		}
		if (inputFileNames.size() == 0)
		{
			System.err.println("Error: No input file name provided");
			System.exit(2);
		}
		else if (format == null)
		{
			System.err.println("Error: No output file format provided");
			System.exit(3);
		}
		DataFileConverter converter = new DataFileConverter();
		converter.setOutputDataType(outputDataType);
		converter.setInputFileNames(inputFileNames);
		converter.setOutputFileName(outputFileName);
		converter.setOutputFormat(format);
		converter.setSplitCols(splitCols);
		try
		{
			int conversionReturn = converter.runConversion();
			if (conversionReturn == 3)
			{
				System.err.println("Non-existent directory for output file "+
						outputFileName);
				System.exit(3);
			}
		}
		catch (OutOfMemoryError e)
		{
			System.err.println("Conversion ran out of memory for " + inputFileNames);
		}
		System.exit(0);
	}
}