package com.flexiblewebsolutions.xdriveunit;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.lang.reflect.Constructor;
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   
   import junit.framework.Test;
  import junit.framework.TestSuite;
  
  import com.flexiblewebsolutions.io.util.FileUtils;
  import com.flexiblewebsolutions.xml.util.XMLStringParser;
  
  /***
   * Builds a TestSuite based on XML configuration information
   * 
   * @author Donavon Buss
   */
  class TestSuiteLoader {
  	private final static String METHOD_TAG = "testmethod";
  
  	public final static String DECORATOR_TAG = "decorator";
  
  	public final static String ALL_METHODS_TAG = "allmethods";
  
  	private File _RunDir = null;
  
  	private StringBuffer _TestOptions = null;
  
  	private String _ClassName = null;
  
  	private String _ThreadName = null;
  
  	/***
  	 * Create a TestSuite using an xml configuration
  	 * 
  	 * @param pConfigInfo -
  	 *            XML configuration information
  	 * @param pThreadName -
  	 *            Name of this instance of the test
  	 * @param pClassName -
  	 *            Class that contains tests to be run
  	 * @param pRunDir -
  	 *            Base directory for running the tests
  	 * @return TestSuite containing any number of tests
  	 * @throws FileNotFoundException
  	 */
  	public Test buildSuite(StringBuffer pConfigInfo, String pThreadName,
  			String pClassName, File pRunDir) throws FileNotFoundException {
  		_RunDir = pRunDir;
  		_ClassName = pClassName;
  		_ThreadName = pThreadName;
  		TestConfigurationLoader configLoader = new TestConfigurationLoader(
  				pConfigInfo);
  		// configuration file can have info for multiple classes
  		String configXML = configLoader.parseConfigurationForClass(pClassName);
  
  		FileUtils fu = new FileUtils();
  
  		if (configXML != null) {
  			StringBuffer tcBuffer = new StringBuffer(configXML);
  			// testOptionsFilename contains different flags that can be set for
  			// test
  			String testOptionsFilename = XMLStringParser.getValueForTag(
  					tcBuffer, "testOptionsFileName");
  			tcBuffer = null;
  			if (testOptionsFilename != null
  					&& (!testOptionsFilename.equals(""))) {
  				File testOptionsFile = new File(pRunDir, testOptionsFilename);
  				System.err.println("test file: "
  						+ testOptionsFile.getAbsolutePath());
  				if (!testOptionsFile.exists()) {
  					throw new FileNotFoundException("File "
  							+ testOptionsFile.getAbsolutePath() + " not found.");
  				}
  
  				_TestOptions = fu.loadXMLFileToString(testOptionsFile);
  				testOptionsFilename = null;
  			}
  		}
  
  		TestCollection tc = new TestCollection();
  
  		if (configXML != null) {
  			String entryTag = "tests";
  			String methodsXML = XMLStringParser.getValueForTag(
  					new StringBuffer(configXML), entryTag);
  
  			parseNestedTests(tc, methodsXML);
  			methodsXML = null;
  		}
  		fu = null;
  		return (tc.getTest());
  	}
  
  	/***
  	 * If xml string contains test methods, drill down to get data
  	 * 
 	 * @param pSuite
 	 *            Stores the test data until ready to run
 	 * @param pXmlString
 	 *            Configuration information for single test
 	 */
 	private void parseNestedTests(TestCollection pSuite, String pXmlString) {
 		//		 Get all nested tag values
 		// if tag is decorator, then get all nested tag values
 		//     then add completed decorator to suite
 		// if tag is test, add test to suite
 		String[] nestedTags = XMLStringParser.getAllNestedTags(pXmlString);
 		for (int i = 0; i < nestedTags.length; i++) {
 			String thisTag = nestedTags[i];
 			if (thisTag.startsWith("<test")) {
 				thisTag = XMLStringParser.getValueForTag(new StringBuffer(
 						thisTag), "test");
 			}
 
 			Test thisTest = null;
 			//			String thisTag = nestedTags[i];
 			if (thisTag.startsWith("<" + METHOD_TAG)) {
 				try {
 					thisTest = buildTestFromMethod(new StringBuffer(thisTag));
 					pSuite.addTest(thisTest);
 				} catch (FileNotFoundException e) {
 					System.err.println("TEst omitted");
 					// TODO Auto-generated catch block
 					e.printStackTrace();
 				}
 
 			} else if (thisTag.startsWith("<" + ALL_METHODS_TAG)) {
 				try {
 					thisTest = buildAllTestsForClass(new StringBuffer(thisTag));
 					pSuite.addTest(thisTest);
 				} catch (FileNotFoundException e) {
 					// TODO Auto-generated catch block
 					e.printStackTrace();
 				}
 
 			} else if (thisTag.startsWith("<" + DECORATOR_TAG + ">")) {
 				String decTagVal = XMLStringParser.getValueForTag(
 						new StringBuffer(thisTag), DECORATOR_TAG);
 				TestCollection decSuite = new TestCollection();
 				parseNestedTests(decSuite, decTagVal);
 				TestDecoratorLoader tdl = new TestDecoratorLoader();
 				Test newTest = tdl.wrapTestWithDecorator(new StringBuffer(
 						decTagVal), decSuite.getTest());
 				pSuite.addTest(newTest);
 			} else {
 				System.err.println("ignoring tag: " + thisTag);
 			}
 		}
 	}
 
 	/***
 	 * Load the inputFileName tag from the method xml and load contents to
 	 * stringbuffer
 	 * 
 	 * @param pXMLString
 	 *            XML string for method definition
 	 * @return File Contents
 	 * @throws FileNotFoundException
 	 *             If filename was supplied but does not exist
 	 */
 	private StringBuffer loadInputFile(StringBuffer pXMLString)
 			throws FileNotFoundException {
 		FileUtils fu = new FileUtils();
 		String inputFilename = XMLStringParser.getValueForTag(pXMLString,
 				"inputFileName");
 		StringBuffer inputXML = null;
 		if (inputFilename != null && (!inputFilename.trim().equals(""))) {
 			File inputFile = new File(_RunDir, inputFilename);
 			if (!inputFile.exists()) {
 				throw new FileNotFoundException("File "
 						+ inputFile.getAbsolutePath() + " not found.");
 			}
 			inputXML = fu.loadXMLFileToString(inputFile);
 		}
 		inputFilename = null;
 		return (inputXML);
 	}
 
 	/***
 	 * Adds all tests from class to suite to be returned.
 	 * 
 	 * @param allTestsString
 	 *            XML string parameter containing alltest data
 	 * @return TestSuite of tests contained in class
 	 * @throws FileNotFoundException
 	 *             If filename was supplied but does not exist
 	 */
 	private Test buildAllTestsForClass(StringBuffer allTestsString)
 			throws FileNotFoundException {
 		StringBuffer inputXML = loadInputFile(allTestsString);
 		String testString = XMLStringParser.getValueForTag(allTestsString,
 				ALL_METHODS_TAG);
 		String[] excludes = XMLStringParser.getMatchingNestedTags(testString,
 				"excludemethod");
 
 		TestSuite testSuite = new TestSuite();
 		try {
 			Class thisClass = Class.forName(_ClassName);
 			Method[] allmethods = thisClass.getMethods();
 			for (int i = 0; i < allmethods.length; i++) {
 				Method thisMethod = allmethods[i];
 				if (thisMethod.getName().startsWith("test")) {
 					boolean excluded = false;
 					if (excludes != null) {
 						for (int y = 0; y < excludes.length && (!excluded); y++) {
 							String excludeMethodName = XMLStringParser
 									.getValueForTag(new StringBuffer(
 											excludes[y]), "excludemethod");
 							if (thisMethod.getName().equals(excludeMethodName)) {
 								excluded = true;
 							}
 							excludeMethodName = null;
 						}
 					}
 					if (!excluded) {
 						Test thisTest = buildTestFromMethod(thisMethod
 								.getName(), inputXML);
 						testSuite.addTest(thisTest);
 					}
 				}
 			}
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		} catch (ClassNotFoundException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		return (testSuite);
 	}
 
 	/***
 	 * Takes in an xml string and builds a test case
 	 * 
 	 * @param methodsString
 	 *            XML Configuration for method
 	 * @return TestCase object that can be added to the suite.
 	 * @throws FileNotFoundException
 	 */
 	private Test buildTestFromMethod(StringBuffer methodsString)
 			throws FileNotFoundException {
 		String methodName = XMLStringParser.getValueForTag(methodsString,
 				"testmethodname");
 		StringBuffer inputXML = loadInputFile(methodsString);
 		return (buildTestFromMethod(methodName, inputXML));
 	}
 
 	/***
 	 * Uses the method name and test input string to build test
 	 * 
 	 * @param methodName
 	 *            Name of test method in class
 	 * @param inputXML
 	 *            Input parameters used by the test.
 	 * @return Newly created Testcase using parameters.
 	 */
 	private Test buildTestFromMethod(String methodName, StringBuffer inputXML) {
 		Test thisTest = null;
 		try {
 			Class thisClass = Class.forName(_ClassName);
 			Constructor constructor = thisClass.getConstructor(new Class[] {
 					String.class, StringBuffer.class, StringBuffer.class,
 					String.class });
 			thisTest = (Test) constructor.newInstance(new Object[] {
 					methodName, inputXML, _TestOptions, _ThreadName });
 		} catch (SecurityException e) {
 			e.printStackTrace();
 		} catch (IllegalArgumentException e) {
 			e.printStackTrace();
 		} catch (ClassNotFoundException e) {
 			e.printStackTrace();
 		} catch (NoSuchMethodException e) {
 			e.printStackTrace();
 		} catch (InstantiationException e) {
 			e.printStackTrace();
 		} catch (IllegalAccessException e) {
 			e.printStackTrace();
 		} catch (InvocationTargetException e) {
 			e.printStackTrace();
 		}
 		// return empty test suite
 		//TODO throw exception
 		if (thisTest == null) {
 			thisTest = new TestSuite();
 		}
 		return (thisTest);
 	}
 }