package org.whatsitcalled.webflange.engine;
   
   import java.io.ByteArrayInputStream;
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.StringWriter;
   import java.util.ArrayList;
   import java.util.Calendar;
  import java.util.List;
  import java.util.Properties;
  
  import net.grinder.Grinder;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.log4j.Logger;
  import org.apache.velocity.VelocityContext;
  import org.apache.velocity.app.Velocity;
  import org.apache.velocity.exception.MethodInvocationException;
  import org.apache.velocity.exception.ParseErrorException;
  import org.apache.velocity.exception.ResourceNotFoundException;
  import org.whatsitcalled.spring.SpringContextUtil;
  import org.whatsitcalled.webflange.ResourceFactory;
  import org.whatsitcalled.webflange.file.FileManager;
  import org.whatsitcalled.webflange.model.LoadTest;
  import org.whatsitcalled.webflange.model.LoadTestRun;
  import org.whatsitcalled.webflange.model.LoadTestRunDAO;
  import org.whatsitcalled.webflange.model.LoadTestSummary;
  import org.whatsitcalled.webflange.model.LoadTestSummaryDAO;
  import org.whatsitcalled.webflange.service.LoadTestService;
  
  /*
   * TODO use services not DAOs
   */
  public class GrinderTestRunner {
  	private static final Logger LOGGER = Logger
  			.getLogger(GrinderTestRunner.class);
  
  	private FileManager fileManager;
  
  	private TestScheduler scheduler;
  
  	private LoadTestSummaryDAO summaryDAO;
  
  	private LoadTestRunDAO runDAO;
  
  	private LoadTestService loadTestService;
  
  	private List<String> grinderJars;
  
  	private VelocityContext velocityContext;
  
  	public void init() {
  		//TODO It would be great to have a module for context variables that has defaults configured via spring, but allows other vars to be set at a global level
  		// Add the file path var for velocity
  		velocityContext = new VelocityContext();
  		String filePath = fileManager.getUploadFolder().getAbsolutePath();
  		filePath = filePath.replaceAll("\\\\", "/");
  		velocityContext.put("filePath", filePath);
  		try {
  			Velocity.init();
  		} catch (Exception e) {
  			LOGGER.error("Problem initializing Velocity", e);
  		}
  
  	}
  
  	public void run(LoadTest loadTest) {
  		loadTest.setRunning(true);
  		loadTestService.saveLoadTest(loadTest);
  		// Get the time
  		long time = Calendar.getInstance().getTimeInMillis();
  		saveRuntimeProperties(loadTest, loadTestService.getGrinderHostId(loadTest, time));
  
  		LOGGER.debug("Grinder CLASSPATH=" + System.getenv("CLASSPATH"));
  		LOGGER.debug("Grinder JAVA_OPTS=" + System.getenv("JAVA_OPTS"));
  
  		String path = fileManager.getPropertyFile(loadTest).getAbsolutePath();
  		String[] args = { path };
  		try {
  			LOGGER.debug("Executing test: " + loadTest.getName());
  			Grinder.main(args);
  			loadStats(loadTest.getId(), time);
  			// GrinderReportGenerator.generateDefaultReport(loadTest, time);
  		} catch (Exception e) {
  			LOGGER.error("Execution of test: " + loadTest + " failed!", e);
  		} finally {
  			loadTest.setRunning(false);
  			loadTestService.saveLoadTest(loadTest);
  		}
  
  	}
  
  	public void saveRuntimeProperties(LoadTest loadTest, String grinderHostId) {
  		// add the default properties
  		String path = fileManager.getPropertyFile(loadTest).getAbsolutePath();
  		File file = new File(path);
  		java.util.Properties props = new Properties();
  
 		// Run the props through velocity
 		StringWriter writer = new StringWriter();
 		try {
 			Velocity.evaluate(velocityContext, writer, "property-evaluator",
 					loadTest.getProperties());
 			String velOut = writer.toString();
 			LOGGER.debug("Properties after Velocity:" + velOut);
 			InputStream in = new ByteArrayInputStream(velOut.getBytes());
 			props.load(in);
 			props.putAll(scheduler.getProperties());
 
 			// convert the classpath
 			String libFolder = SpringContextUtil.getWebApplicationContext()
 					.getServletContext().getRealPath("/WEB-INF/lib");
 			LOGGER.debug("libFolder=" + libFolder);
 
 			StringBuffer classpathBuf = new StringBuffer();
 			for (String jar : grinderJars) {
 				LOGGER.debug("Adding jar: " + jar + " to grinder classpath.");
 				classpathBuf.append(libFolder);
 				classpathBuf.append("/");
 				classpathBuf.append(jar);
 				classpathBuf.append(System.getProperty( "path.separator" ));
 			}
 			String classpath = classpathBuf.toString();
 			LOGGER.debug("classpath=" + classpath);
 			// Set other properties
 			props.setProperty("grinder.jvm.classpath", classpath);
 			props.setProperty("grinder.script", fileManager.getScriptFile(
 					loadTest.getScript()).getAbsolutePath());
 			props.setProperty("grinder.hostID", grinderHostId);
 			props.setProperty("grinder.logDirectory", fileManager
 					.getDataFolder().getAbsolutePath());
 			props.setProperty("grinder.logProcessStreams", "false");
 			props.store(FileUtils.openOutputStream(file), null);
 
 		} catch (ParseErrorException e) {
 			LOGGER.error("Unable to load runtime properties", e);
 		} catch (MethodInvocationException e) {
 			LOGGER.error("Unable to load runtime properties", e);
 		} catch (ResourceNotFoundException e) {
 			LOGGER.error("Unable to load runtime properties", e);
 		} catch (IOException e) {
 			LOGGER.error("Unable to load runtime properties", e);
 		}
 	}
 
 	public List<String> getContextVars() {
 		Object[] vars = velocityContext.getKeys();
 		List<String> varList = new ArrayList<String>();
 
 		for (int i = 0; i < vars.length; i++) {
 			String var = (String) vars[i];
 			varList.add(var);
 		}
 		return varList;
 	}
 
 	public static String[] splitLine(String line) {
 
 		String[] fields = new String[12];
 		// First 11 fields are 14 chars long
 		int beginIndex = 0;
 		int endIndex = 13;
 		for (int i = 0; i < 11; i++) {
 			if (endIndex > line.length())
 				endIndex = line.length();
 			fields[i] = line.substring(beginIndex, endIndex);
 			LOGGER.debug("fields[" + i + "]: " + fields[i]);
 			fields[i] = fields[i].replaceAll("^\\s+", "");
 			fields[i] = fields[i].replaceAll("\\s+$", "");
 			if (fields[i].equals("?"))
 				fields[i] = "0";
 
 			beginIndex = endIndex;
 			endIndex = beginIndex + 13;
 		}
 
 		fields[11] = line.substring(beginIndex);
 
 		return fields;
 	}
 
 	public void loadStats(Long loadTestId, long time) {
 
 		// TODO put in service layer
 		// Get the loadtest
 		LoadTest test = loadTestService.getLoadTest(loadTestId);
 
 		// create and store the run and its associated LoadTest
 		LoadTestRun run = new LoadTestRun(test, time);
 
 		// Store references to the Grinder files in the Run
 		setRunFiles(run);
 
 		File file = loadTestService.getSummaryFile(run);
 		List lines = null;
 		try {
 			lines = FileUtils.readLines(file);
 		} catch (IOException e) {
 			LOGGER.error("Trouble opening Grinder Summary File: "
 					+ file.getAbsolutePath(), e);
 		}
 		String[] fields = new String[12];
 		LoadTestSummary sum = null;
 		for (Object line : lines) {
 			String s = (String) line;
 			fields = splitLine(s);
 			if (!fields[0].equals("") && !fields[10].equals("")) {
 				sum = new LoadTestSummary();
 				sum.setTestName(fields[0]);
 				sum.setTests(parseLong(fields[1]));
 				sum.setErrors(parseLong(fields[2]));
 				sum
 						.setMeanTestTime(parseDouble(fields[3]));
 				sum.setTestTimeStandardDeviation(parseFloat(fields[4]));
 				sum.setMeanResponseLength(parseDouble(fields[5]));
 				sum.setResponseBytesPerSecond(parseDouble(fields[6]));
 				sum.setResponseErrors(parseLong(fields[7]));
 				sum.setMeanTimeToResolveHost(parseDouble(fields[8]));
 				sum.setMeanTimeToEstablishConnection(parseDouble(fields[9]));
 				sum.setMeanTimeToFirstByte(parseDouble(fields[10]));
 				sum.setTestUri(fields[11]);
 				sum.setRun(run);
 				LOGGER.debug("Adding Summary...\n" + sum.toString());
 				if (sum.getTestName().equals("Totals")) {
 					sum.setSummaryType(LoadTestSummary.TOTALS_SUMMARY_TYPE);
 				}
 				//summaryDAO.saveLoadTestSummary(sum);
 				run.getSummaries().add(sum);
 
 			}
 
 		}
 		test.getRuns().add(run);
 		loadTestService.saveLoadTest(test);
 	}
 
 	private long parseDouble(String sd) {
 		if (!sd.matches("[0-9\\.]*")) return 0;
 		long l = 0;
 		try {
 			l = Math.round(Double.parseDouble(sd));
 		} catch (NumberFormatException e) {
 			LOGGER.error(e);
 		}
 		return l;
 	}
 
 	private long parseFloat(String sf) {
 		long l = 0;
 		try {
 			l = Math.round(Float.parseFloat(sf));
 		} catch (NumberFormatException e) {
 			LOGGER.error(e);
 		}
 		return l;
 	}
 	
 	private Long parseLong(String sd) {
 		Long d = new Long(0);
 		try {
 			d = Long.parseLong(sd);
 		} catch (NumberFormatException e) {
 			LOGGER.error(e);
 		}
 
 		return d;
 	}
 	private void setRunFiles(LoadTestRun run) {
 		File summaryFile = loadTestService.getSummaryFile(run);
 		if (summaryFile.exists())
 			run.setSummaryFile(summaryFile.getName());
 
 		File dataFile = loadTestService.getDataFile(run);
 		if (dataFile.exists())
 			run.setDataFile(dataFile.getName());
 
 		File errorFile = loadTestService.getErrorFile(run);
 		if (errorFile.exists())
 			run.setErrorFile(errorFile.getName());
 	}
 
 	public FileManager getFileManager() {
 		return fileManager;
 	}
 
 	public void setFileManager(FileManager fileManager) {
 		this.fileManager = fileManager;
 	}
 
 	public LoadTestRunDAO getRunDAO() {
 		return runDAO;
 	}
 
 	public void setRunDAO(LoadTestRunDAO runDAO) {
 		this.runDAO = runDAO;
 	}
 
 	public TestScheduler getScheduler() {
 		return scheduler;
 	}
 
 	public void setScheduler(TestScheduler scheduler) {
 		this.scheduler = scheduler;
 	}
 
 	public LoadTestSummaryDAO getSummaryDAO() {
 		return summaryDAO;
 	}
 
 	public void setSummaryDAO(LoadTestSummaryDAO summaryDAO) {
 		this.summaryDAO = summaryDAO;
 	}
 
 	public List getGrinderJars() {
 		return grinderJars;
 	}
 
 	public void setGrinderJars(List grinderJars) {
 		this.grinderJars = grinderJars;
 	}
 
 	public LoadTestService getLoadTestService() {
 		return loadTestService;
 	}
 
 	public void setLoadTestService(LoadTestService loadTestService) {
 		this.loadTestService = loadTestService;
 	}
 
 	public void runAsThread(LoadTest test) {
 		// Create the object with the run() method
 		Runnable runnable = new RunNow(test);
 
 		// Create the thread supplying it with the runnable object
 		Thread thread = new Thread(runnable);
 
 		// Start the thread
 		thread.start();
 	}
 
 	class RunNow implements Runnable {
 		private LoadTest loadTest;
 
 		RunNow(LoadTest test) {
 			this.loadTest = test;
 
 		}
 
 		public void run() {
 			ResourceFactory.getGrinderTestRunner().run(loadTest);
 		}
 	}
 }