/*
    *
    */
   package org.softevo.jdynpur.eval;
   
   import java.io.ByteArrayOutputStream;
   import java.io.File;
   import java.io.IOException;
   import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.TransformerException;
  
  import org.softevo.jdynpur.eval.PurityTraceAnalyser.ParameterMutabilityInformation;
  import org.softevo.util.asm.MethodIdentifier;
  import org.xml.sax.SAXException;
  
  /**
   * This class analyzes several execution traces for the same program and merges
   * the results. If a method was impure in at least one trace, then it is
   * considered to be impure.
   * 
   * @author dallmeier
   */
  public class MultiplePurityTraceAnalyser {
  
  	/**
  	 * The name of the trace file to be analyzed.
  	 */
  	private String fileName = null;
  
  	/**
  	 * The set of pure method identifiers.
  	 */
  	private HashMap<MethodIdentifier, HashSet<String>> pureMethodIdentifiers;
  
  	/**
  	 * The set of impure method identifiers.
  	 */
  	private HashMap<MethodIdentifier, HashSet<String>> impureMethodIdentifiers;
  
  	/**
  	 * The set of executed method identifiers.
  	 */
  	private HashMap<MethodIdentifier, HashSet<String>> executedMethodIdentifiers;
  
  	private HashMap<MethodIdentifier, HashSet<String>> methodsModifyingThis;
  
  	private String resultFileName;
  
  	private boolean analyseParameterMutability;
  
  	private HashMap<MethodIdentifier, ParameterMutabilityInformation> parameterMutabilityInformation;
  
  	/**
  	 * Creates a new analyzer for all traces in the given directory.
  	 * 
  	 * @param fileName
  	 *          the name of the directory
  	 */
  	public MultiplePurityTraceAnalyser(String fileName, String resultFileName, boolean analyseParameterMutability) {
  		this.fileName = fileName;
  		this.resultFileName = resultFileName;
  		this.analyseParameterMutability = analyseParameterMutability;
  	}
  
  	private HashSet<String> getTypeSet(HashMap<MethodIdentifier, HashSet<String>> map, MethodIdentifier identifier) {
  		HashSet<String> result;
  
  		result = map.get(identifier);
  		if (result == null) {
  			result = new HashSet<String>();
  			map.put(identifier, result);
  		}
  		return result;
  	}
  
  	/**
  	 * Analyzes all trace files in the directory. After this method has finished,
  	 * the results are stored in the classes' <code>HashSet</code> fields. This
  	 * method also outputs some information on <code>System.out</code>
  	 * 
  	 * @throws IOException
  	 *           if an exception occurs reading a trace.
  	 * @throws TransformerException 
  	 * @throws ParserConfigurationException 
  	 * @throws SAXException 
  	 */
  	public void analyse() throws IOException, ParserConfigurationException, TransformerException, SAXException {
  		File traceDirectory;
  		File[] children;
  		String suffix;
  		String[] fileNames;
  		PurityTraceAnalyser purityAnalyser;
  		Iterator<MethodIdentifier> newImpureMethodsIterator, newPureMethodsIterator;
  		MethodIdentifier identifier;
 		boolean isFirstTrace = true;
 		HashSet<String> pureTypes, impureTypes;
 
 		impureMethodIdentifiers = new HashMap<MethodIdentifier, HashSet<String>>();
 		pureMethodIdentifiers = new HashMap<MethodIdentifier, HashSet<String>>();
 		executedMethodIdentifiers = new HashMap<MethodIdentifier, HashSet<String>>();
 		methodsModifyingThis = new HashMap<MethodIdentifier, HashSet<String>>();
 		parameterMutabilityInformation = new HashMap<MethodIdentifier, ParameterMutabilityInformation>();
 		traceDirectory = new File(fileName);
 		if (traceDirectory.isDirectory()) {
 			children = traceDirectory.listFiles();
 			System.out.println("Found " + children.length + " trace files");
 			fileNames = new String[children.length];
 			for (int counter = 0; counter < children.length; counter++) {
 				fileNames[counter] = children[counter].getName();
 			}
 			Arrays.sort(fileNames);
 		} else {
 			fileNames = new String[] {fileName};
 			children = new File[] {new File(fileName)};
 		}
 		for (int counter = 0; counter < fileNames.length; counter++) {
 			suffix = fileNames[counter].substring(10, fileNames[counter].length());
 			System.out.println("Processing file " +  fileNames[counter]);
 			purityAnalyser = new PurityTraceAnalyser(children[counter].getAbsolutePath(), null, false, analyseParameterMutability);
 			System.out.println("Analysing purity trace " + suffix + ".");
 			try {
 				purityAnalyser.analyse(false, false);
 			} catch (Throwable analysisError) {
 				System.out.println("An error occured processing file " +  fileNames[counter]);
 				System.out.println(analysisError);
 				analysisError.printStackTrace();
 				System.out.println("Results of this file will be ignored.");
 				continue;
 			}
 			System.out.println("Comparing trace results.");
 			PurityResults results = new PurityResults(purityAnalyser.getPureMethodIdentifiers(), 
 			                                          purityAnalyser.getImpureMethodIdentifiers(), 
 			                                          purityAnalyser.getThisModifyingMethodIdentifiers(),
 			                                          purityAnalyser.getExecutedMethodIdentifiers(), 
 			                                          purityAnalyser.getParameterMutabilityInformation());
 			ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
 			results.saveXML(byteBuffer);
 			executedMethodIdentifiers.putAll(purityAnalyser.getExecutedMethodIdentifiers());
 			methodsModifyingThis.putAll(purityAnalyser.getThisModifyingMethodIdentifiers());
 			if (isFirstTrace) {
 				isFirstTrace = false;
 				pureMethodIdentifiers.putAll(purityAnalyser.getPureMethodIdentifiers());
 				impureMethodIdentifiers.putAll(purityAnalyser.getImpureMethodIdentifiers());
 				parameterMutabilityInformation.putAll(purityAnalyser.getParameterMutabilityInformation());
 			} else {
 				newImpureMethodsIterator = purityAnalyser.getImpureMethodIdentifiers().keySet().iterator();
 				while (newImpureMethodsIterator.hasNext()) {
 					identifier = newImpureMethodsIterator.next();
 					pureMethodIdentifiers.remove(identifier);
 					impureTypes = getTypeSet(impureMethodIdentifiers, identifier);
 					impureTypes.addAll(purityAnalyser.getImpureMethodIdentifiers().get(identifier));
 				}
 				newPureMethodsIterator = purityAnalyser.getPureMethodIdentifiers().keySet().iterator();
 				while (newPureMethodsIterator.hasNext()) {
 					identifier = newPureMethodsIterator.next();
 					if (!impureMethodIdentifiers.containsKey(identifier)) {
 						pureTypes = getTypeSet(pureMethodIdentifiers, identifier);
 						pureTypes.addAll(purityAnalyser.getPureMethodIdentifiers().get(identifier));
 					} 
 				}
 				HashMap<MethodIdentifier, ParameterMutabilityInformation> newParameterInformation = purityAnalyser.getParameterMutabilityInformation();
 				for (MethodIdentifier methodIdentifier: newParameterInformation.keySet()) {
 					if (parameterMutabilityInformation.containsKey(methodIdentifier)) {
 						ParameterMutabilityInformation oldMutabilityInformation = parameterMutabilityInformation.get(methodIdentifier);
 						int oldNumberOfImmutableParameters = oldMutabilityInformation.getUnmodifiedParameters().size();
 						ParameterMutabilityInformation newMutabilityInformation = newParameterInformation.get(methodIdentifier);
 						HashMap<String, HashSet<Integer>> classToUnmodifiedParametersMap = newMutabilityInformation.getRuntimeClassNameToUnmodifiedParametersMap();
 						for (String className : classToUnmodifiedParametersMap.keySet()) {
 							oldMutabilityInformation.updateUnmodifiedParameters(className, classToUnmodifiedParametersMap.get(className));
 						}
 						int newNumberOfImmutableParameters = oldMutabilityInformation.getUnmodifiedParameters().size();
 						assert (newNumberOfImmutableParameters <= oldNumberOfImmutableParameters) : "Incorrect increase of immutable parameters.";
 					} else {
 						parameterMutabilityInformation.put(methodIdentifier, newParameterInformation.get(methodIdentifier));
 					}
 				}
 				
 			}
 			byteBuffer = new ByteArrayOutputStream();
 			results.saveXML(byteBuffer);
 		  writeResults();
 		}
 		System.out.println("Done.");
 	}
 
 	/**
 	 * This method serializes the results to the file system. Pure methods are
 	 * stored in <code>puremethods.ser</code>, impure methods are stored in
 	 * <code>impuremethods.ser</code>, executed methods are stored in
 	 * <code>executedmethods.ser</code>.
 	 * @throws TransformerException 
 	 * @throws ParserConfigurationException 
 	 * @throws IOException 
 	 */
 	private void writeResults() throws IOException, ParserConfigurationException, TransformerException {
 		PurityResults results = new PurityResults(pureMethodIdentifiers, impureMethodIdentifiers, 
 		                                          methodsModifyingThis, executedMethodIdentifiers, 
 		                                          parameterMutabilityInformation);
 		results.saveXML(resultFileName);
 	}
 
 	/**
 	 * Launches analysis of a directory of trace files. It expects the name of the
 	 * trace directory as its only argument.
 	 * 
 	 * @param args
 	 *          the command line arguments
 	 * @throws TransformerException 
 	 * @throws ParserConfigurationException 
 	 * @throws SAXException 
 	 */
 	public static void main(String[] args) throws IOException, ParserConfigurationException, TransformerException, SAXException {
 		MultiplePurityTraceAnalyser traceAnalyser;
 
 		if (args.length < 3) {
 			System.out.println("Usage: java org.softevo.jdynpur.MultiplePurityTraceAnalyser <traceDirectory> <resultfilename> <analyseParameterMutability>");
 		} else {
 			traceAnalyser = new MultiplePurityTraceAnalyser(args[0], args[1], new Boolean(args[2]));
 			traceAnalyser.analyse();
 		}
 	}
 
 }