/***
    * Created on Aug 5, 2005, Copyright UC Regents
    */
   package wise2.converter.converters;
   
   import java.io.ByteArrayInputStream;
   import java.io.ByteArrayOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Properties;
  import java.util.logging.Logger;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  
  import net.sf.sail.core.beans.Pod;
  import net.sf.sail.core.entity.Rim;
  
  import org.telscenter.pas.beans.PasStep;
  import org.telscenter.pas.pedagogica.PedagogicaStep;
  
  import wise2.converter.util.HTMLUtils;
  
  /***
   * @author turadg
   */
  public class ConcordModelSaveJarConverter extends AbstractHtmlStepConverter {
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger
  			.getLogger(ConcordModelSaveJarConverter.class.getName());
  
  	private PedagogicaStep step;
  	private HashMap rimMap = new HashMap();
  
  	@Override
  	protected PasStep getTypedPasStep() {
  		step = new PedagogicaStep();
  		setUrlToIntroductionHtml(step);
  		String saveJarName = stepNode.selectSingleNode("parameters/saveJar")
  				.getText();
  
  		try {
  			InputStream upload = uploadProvider.getProjectUpload(saveJarName);
  			URL saveJarUrl = addToArchive(saveJarName, upload);
  			step.setUrl(saveJarUrl);
  			loadPropertyFiles(saveJarName);
  		} catch (Exception e) {
  			logger.severe("exception: " + e); //$NON-NLS-1$
  		}
  
  		String html = stepNode.selectSingleNode("parameters/htmlIntro")
  				.getText();
  
  		html = HTMLUtils.tidyHtml(html);
  
  		step.setIntroductionHtml(html);
  
  		String codebase = stepNode.selectSingleNode("parameters/codebase")
  				.getText();
  		step.setCodeBase(codebase);
  
  		// TODO write test launching class that provides necessary classes as
  		// provided by JWS curnit extension
  
  		return step;
  	}
  
  	protected Class getShape(Object value) {
  		Class shape = String.class;
  		// The value here will either be either a class name or
  		// a Java-style variable name. If the latter, this method
  		// should always return String.class
  		String className = shape.getName();
  		if (value instanceof String) {
  			try {
  				className = (String) value;
  				// Make sure the string is non-empty and has one or more "." in it
  				// as a regular class name would. Otherwise it will be assumed that
  				// it is a variable name. Default package classes can't be used for
  				// shapes in this case.
  				shape = Class.forName(className);
  			} catch (ClassNotFoundException e) {
  				logger.warning("Could not find rim shape " + className);
  			}
  		}
  		return shape;
  	}
  
  	public void checkImportedClasses(Properties properties) {
  		// separate out the string of imported classes...importedClasses is a
  		// string of file names separated by ";"
  		String importedClassesString = properties
  				.getProperty("imported.classes");
  		String patternString = ";";
 		String[] importedClasses = importedClassesString.split(patternString);
 
 		// try to load each imported classes and throw an error if a class
 		// cannot be loaded.
 		String className = null;
 		for (int i = 0; i < importedClasses.length; i++) {
 			try {
 				className = importedClasses[i];
 				Class.forName(className);
 			} catch (ClassNotFoundException e) {
 				logger.severe("Cannot load imported class: " + className);
 				e.printStackTrace();
 			}
 		}
 	}
 
 	public void createRims(Properties properties) {
 		Iterator rimEntries = properties.entrySet().iterator();
 		Pod pod = getPod();
 		Map rimMap = step.getRimMap();
 		while (rimEntries.hasNext()) {
 			Map.Entry rimEntry = (Map.Entry) rimEntries.next();
 			String rimName = (String) rimEntry.getKey();
 			Rim rim = new Rim();
 			rim.setName(rimName);
 			rim.setShape(getShape(rimEntry.getValue()));
 			step.setRim(rimName, rim);
 			pod.add(rim);
 		}
 		step.setRimMap(rimMap);
 		pod.add(rimMap);
 	}
 
 	/***
 	 * Verify that all imported classes in Pedagogica state jar are available on
 	 * the static classpath
 	 * 
 	 * @param saveJarName
 	 *            name of the jar file
 	 * 
 	 */
 	public void loadPropertyFiles(String saveJarName) {
 		try {
 			InputStream input = uploadProvider.getProjectUpload(saveJarName);
 			ZipInputStream zipInput = new ZipInputStream(input);
 			Properties properties = getProperties(zipInput, "classes/state.properties");
 			properties.list(System.out);
 			createRims(properties);
 			
 			input = uploadProvider.getProjectUpload(saveJarName);
 			zipInput = new ZipInputStream(input);
 			properties = getProperties(zipInput, "classes/classes.properties");
 			properties.list(System.out);
 			checkImportedClasses(properties);
 		} catch (IOException e) {
 			logger.severe("Could not load properties files from " + saveJarName);
 			return;
 		}
 	}
 
 	/***
 	 * Returns Properties [] object of the *.properties files in the jar
 	 * @param input ZipInputStream object to look inside
 	 * @param path String [] of path names
 	 * @return Properties [] representation of *.properties data
 	 */
 	public Properties getProperties(ZipInputStream input, String path) {
 		Properties props = new Properties();
 		try {
 			ZipEntry entry = input.getNextEntry();
 			while (entry != null) {
 				if (entry.getName().equals(path)) {
 					InputStream byteStream = getByteInputStream(input, entry);
 					if (byteStream != null)
 						props.load(byteStream);
 				}
 				entry = input.getNextEntry();
 			}
 		} catch (IOException ioe) {
 
 		}
 		return props;
 	}
 
 	public InputStream getByteInputStream(ZipInputStream input, ZipEntry entry) {
 		byte[] buffer = new byte[1024];
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		try {
 			int n = input.read(buffer, 0, 1024);
 			while (n > 0) {
 				out.write(buffer, 0, n);
 				n = input.read(buffer, 0, 1024);
 			}
 			byte[] bytes = out.toByteArray();
 			return new ByteArrayInputStream(bytes);
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		return null;
 	}
 }