package mior.controler;
  
  
  import java.io.IOException;
  import java.util.Arrays;
  
  import javax.swing.SwingUtilities;
  import javax.swing.UIManager;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import mcmas.core.MCMChrono;
  import mior.model.IMiorModel;
  import mior.model.ModelFactory;
  import mior.view.MiorResultWriter;
  import mior.view.MiorView;
  import joptsimple.OptionParser;
  import joptsimple.OptionSet;
  
  public class MiorLauncher {
  	
  	private final ModelFactory factory;
  	
  	private int modelVersion;
  	private boolean topologyOnly;
  	private boolean guiEnabled;
  	private String outputFile;
  	private String prefix;
  	
  	private int nbRepetitions;
  	private int nbSimulations;
  	//private int nbKernels;
  	
  	private final static Logger logger = LoggerFactory.getLogger(MiorLauncher.class);
  	
  	public MiorLauncher() {
  		this.modelVersion  = 4;
  		this.factory       = new ModelFactory();
  		this.topologyOnly  = false;
  		this.guiEnabled    = false;
  		this.outputFile    = "output.dat";
  		this.prefix        = "";
  		
  		this.nbRepetitions     = 0;
  		//this.nbKernels     = 0;
  		this.nbSimulations     = 0;
  	}
  	
  	public void setTopologyOnly(boolean topologyOnly) {
  		this.topologyOnly = topologyOnly;
  	}
  	
  	public boolean isTopologyOnly() {
  		return topologyOnly;
  	}
  	
  	public String getPrefix() {
  		return prefix;
  	}
  	
  	public void setPrefix(String prefix) {
  		this.prefix = prefix;
  	}
  	
  	public int getModelVersion() {
  		return modelVersion;
  	}
  	
  	public void setModelVersion(int modelVersion) {
  		this.modelVersion = modelVersion;
  	}
  	
  	public void setBatchSize(int batchSize) {
  		this.nbRepetitions = batchSize;
  	}
  	
  	public int getBatchSize() {
  		return nbRepetitions;
  	}
  	
  	/*
  	public void setNbKernels(int nbKernels) {
  		this.nbKernels = nbKernels;
  	}
  	
  	public int getNbKernels() {
  		return nbKernels;
  	}*/
  	
  	public void setTotalSize(int totalSize) {
  		this.nbSimulations = totalSize;
  	}
  	
  	public int getTotalSize() {
  		return nbSimulations;
  	}
  	
  	public String getOutputFile() {
  		return outputFile;
  	}
  	
  	public void setOutputFile(String outputFile) {
  		this.outputFile = outputFile;
  	}
  	
  	public boolean isGuiEnabled() {
  		return guiEnabled;
  	}
  	
  	public void setGuiEnabled(boolean guiEnabled) {
  		this.guiEnabled = guiEnabled;
  	}
  	
  	public ModelFactory getFactory() {
  		return factory;
  	}
  	
  	public void start(int nbMM, int nbOM, int scale) {
  		logger.info("Simulation size: " + nbMM + "x" + nbOM + " (scale: " + scale + ")");
  		IMiorModel model = factory.createModel(nbMM, nbOM, scale, modelVersion);
  		model.addUpdateListener(new MiorResultWriter(outputFile));
  		
  		if (guiEnabled) {
  			startGUI(model);
  		}
  		
  		if ((nbRepetitions < 1 || nbSimulations < 1) && !guiEnabled) {
  			throw new RuntimeException("No GUI and no simulation to execute");
  		}
  		
  		System.err.println("# Running " + nbRepetitions + " time(s) the simulation");
  		
  		//System.out.println(guiEnabled);
  		//System.out.println(nbKernels);
  		long [] results = new long[nbRepetitions];
  		final int groupSize = getFactory().getGroupSize();
  		
  		final int nbKernels = (nbSimulations % groupSize == 0 ? nbSimulations / groupSize : nbSimulations / groupSize + 1);
  		final int actualTotalSize = nbKernels * groupSize;
  		final double correctionFactor = (1.0d * nbSimulations) /  actualTotalSize;
  		
  		System.err.println("# " + correctionFactor);
  		
  		for (int i = 0; i < nbRepetitions; i++) {
  			MCMChrono simChrono = new MCMChrono("Mior simulation");
  			
  			System.err.println("# Running " + nbKernels + " times(s) a kernel of size " + groupSize + " to complete the simulation");
  			simChrono.start();
  			
  			for (int j = 0; j < nbKernels; j++) {
  				
  				if (topologyOnly) {
  					model.reset();
  					model.doTopology();
  				} else {
  					model.reset();
  					model.doAutoLive();
  				}
  			}
  			
  			results[i] = (long) (simChrono.stop().getValue() * correctionFactor);
  		}
  		
  		//System.out.println(Arrays.toString(results));
  		if (nbRepetitions != 0) {
  			printStats(results);
  		}
  		
  		if (! guiEnabled) {
  			model.release();
  		}
  	}
  	
  	private void startGUI(IMiorModel model) {
  		try {
  			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
  		} catch (final Exception e) {
  			e.printStackTrace();
  		}
  		
  		final MiorView view = new MiorView(model, "MIOR Model version: " + modelVersion);
  		
  		SwingUtilities.invokeLater(new Runnable() {
  
  			@Override
  			public void run() {
  				view.getFrame().setVisible(true);
  			}
  
  		});
  	}
  	
  	private void printStats(long [] rawResults) {
  		// Sort the results
  		long [] results = rawResults.clone(); //Arrays.copyOf(rawResults, rawResults.length);
  		Arrays.sort(results);
  		
  		// Remove the min and max if we have more than 5 values
  		if (results.length >= 5) {
  			results = Arrays.copyOfRange(results, 1, results.length - 1);
  		}
  		
  		// Min and max time
  		final long min = results[0];
  		final long max = results[results.length - 1];
  		
  		// Algebric mean
  		double totalTime = 0;
  		
  		for (long time : results) {
  			totalTime += time;
  		}
  		
  		final double mean = totalTime / results.length;
  		
  		// ET computation
  		
  		long totalET = 0;
  		
  		for (long time : results) {
  			totalET += (time - mean) * (time - mean);
  		}
  		
  		final double ET = Math.sqrt(totalET / results.length);
  		
  		// Display
  		
  		System.out.println("# Min Max Avg ET");
  		System.out.println((prefix != null ? prefix + " " : "") + min + " " + max + " " + mean + " " + ET);
  	}
  	
  	public static void main(String[] args) {
  		final MiorLauncher simulation = new MiorLauncher();
  		
  		OptionParser parser = new OptionParser();
  		
  		parser.acceptsAll(Arrays.asList("o", "output"), "Output File")
  				.withRequiredArg().ofType(String.class)
  				.defaultsTo("output.dat");
  		
  		/*
  		 * batchSize  : Number of time to repeat (and average results) the whole simulation
  		 * totalSize  : Total number of MIOR simulations to execute
  		 * kernelSize : Total number of MIOR to execute in the same kernel (par. implementations only)
  		 */
  		
  		parser.acceptsAll(Arrays.asList("b", "batchSize", "r", "repeat"),
  				"Number of time to repeat (for stats) the whole simulation")
  				.withOptionalArg().ofType(Integer.class).defaultsTo(20);
  		
  		parser.acceptsAll(Arrays.asList("ts", "totalSize", "n", "nbSimulations"),
  				"Total number of MIOR simulations to execute")
  				.withRequiredArg().ofType(Integer.class).defaultsTo(0);
  		
  		parser.acceptsAll(Arrays.asList("ks", "kernelSize", "groupSize"),
  				"Number of simulations to execute each kernel (PAR. IMPLEMENTATIONS ONLY)")
  				.withRequiredArg().ofType(Integer.class);
  		
  		parser.acceptsAll(Arrays.asList("r", "random", "randomizePopulations"),
  				"Enable randomization of Mior models").withOptionalArg()
  				.ofType(Boolean.class).defaultsTo(true);
  		
  		parser.acceptsAll(Arrays.asList("c", "copy", "alwaysCopy"),
  				"Always copy data between GPU and CPU").withOptionalArg()
  				.ofType(Boolean.class).defaultsTo(true);
  		
  		parser.acceptsAll(Arrays.asList("j", "java"),
  				"Use the Java implementation");
  		
  		parser.acceptsAll(Arrays.asList("s", "scale"),
  				"Scale the model by the given factor").withRequiredArg()
  				.ofType(Integer.class).defaultsTo(1);
  		
  		parser.accepts("mm", "Number of MM to use").withRequiredArg()
  				.ofType(Integer.class).defaultsTo(38);
  		
  		parser.accepts("om", "Number of OM to use").withRequiredArg()
  				.ofType(Integer.class).defaultsTo(310);
  		
  		parser.acceptsAll(Arrays.asList("v", "version"),
  				"Use this OpenCL implementation version").withRequiredArg()
  				.ofType(Integer.class).defaultsTo(5);
  		
  		parser.acceptsAll(Arrays.asList("p", "prefix"),
  				"Prefix to use for output").withRequiredArg()
  				.ofType(String.class);
  		
  		parser.acceptsAll(Arrays.asList("t", "topoOnly"),
  				"Execute only the topology step").withOptionalArg()
  				.ofType(Boolean.class).defaultsTo(false);
  		
  		parser.acceptsAll(Arrays.asList("g", "gui"), "Enable GUI")
  				.withOptionalArg().ofType(Boolean.class).defaultsTo(true);
  		
  		parser.acceptsAll(Arrays.asList("h", "help"), "Print this help");
  		
  		OptionSet options = parser.parse(args);
  		
  		/**
  		 * HELP
  		 */
  		
  		if (options.has("help")) {
  			try {
  				parser.printHelpOn(System.out);
  				return;
  			} catch (IOException e) {
  				System.err.println("Failed to print help to standard output");
  				e.printStackTrace();
  			}
  		}
  		
  		/**
  		 * PARALLELIZATION SETTINGS
  		 */
  		
  		if (options.has("batchSize")) {
  			simulation.getFactory().setBatchModeEnabled(true);
  			simulation.setBatchSize((Integer) options.valueOf("batchSize"));
  		}
  
  		
  		if (options.has("totalSize")) {
  			int totalSize = (Integer) options.valueOf("totalSize");
  			simulation.setTotalSize(totalSize);
  			
  			if (options.has("kernelSize")) {
  				int kernelSize = (Integer) options.valueOf("kernelSize");
  				
  				if (kernelSize < 1) {
  					throw new RuntimeException("kernelSize must be a divider of the total number of simulations (" + totalSize  + ")");
  				}
  				
  				//simulation.setNbKernels(totalSize % kernelSize == 0 ? totalSize / kernelSize : (totalSize / kernelSize) + 1);
  				simulation.getFactory().setGroupSize(kernelSize);
  			} else {
  				//simulation.setNbKernels(totalSize);
  				simulation.getFactory().setGroupSize(1);
  			}
  		}
  		
  		if (options.has("blockSize")) {
  			simulation.getFactory().setBlockSize((Integer) options.valueOf("blockSize"));
  		}
  		
  		if (options.has("random")) {
  			final boolean random = (Boolean) options.valueOf("random");
  			simulation.getFactory().setRandomEnabled(random);
  		}
  		
  		if (options.has("alwaysCopy")) {
  			final boolean copy = (Boolean) options.valueOf("alwaysCopy");
  			simulation.getFactory().setBatchModeEnabled(!copy);
  		}
  		
  		/**
  		 * MODEL VERSION SETTINGS
  		 */
  		
  		if (options.has("java")) {
  			if (! options.has("version")) {
  				simulation.setModelVersion(0);
  			} else {
  				System.err.println("Error: Java and OpenCL implementation can't be used at the same time.");
  				System.exit(1);
  			}
  		} else {
  			simulation.setModelVersion((Integer) options.valueOf("version"));
  		}
  		
  		/**
  		 * OTHER PARAMETERS
  		 */
  		
  		if (options.has("gui")) {
  			simulation.setGuiEnabled((Boolean) options.valueOf("gui"));
  		} else if (simulation.getFactory().getGroupSize() == 0) {
  			simulation.setGuiEnabled(true);
  		}
  		
  		simulation.setTopologyOnly((Boolean) options.valueOf("topoOnly"));
  		simulation.setOutputFile((String) options.valueOf("output"));
  		simulation.setPrefix((String) options.valueOf("prefix"));
  		
  		final int nbMM = (Integer) options.valueOf("mm");
  		final int nbOM = (Integer) options.valueOf("om");
  		final int scale = (Integer) options.valueOf("scale");
  		
  		simulation.start(nbMM, nbOM, scale);
  	}
  
  }