/*
     * This is free software; you can redistribute it and/or modify it
     * under the terms of the GNU Lesser General Public License as
     * published by the Free Software Foundation; either version 2.1 of
     * the License, or (at your option) any later version.
     *
     * This software is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    * Lesser General Public License for more details.
    *
    * You should have received a copy of the GNU Lesser General Public
    * License along with this software; if not, write to the Free
    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
    */
  
  package installtoolkit;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.IOException;
  import java.io.StringReader;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.Task;
  import org.apache.tools.ant.taskdefs.Copy;
  import org.apache.tools.ant.types.FileSet;
  import org.dom4j.Document;
  import org.dom4j.DocumentException;
  import org.dom4j.Element;
  import org.dom4j.io.SAXReader;
  import org.xml.sax.SAXException;
  
  /**
   * Base class for installer-builder tasks. <br/>
   * This class holds common functions for all install-builder 
   * tasks and handles the reading of the descriptorfile.
   *
   * 
   * @author Christian Elberfeld <elberfeld@web.de>
   *
   */
  public abstract class InstallerGeneratorTask extends Task {
  
  	/** The XML Namespace of the desriptor file */
  	public static final String DESCRIPTOR_NAMESPACE = "http://install-toolkit.sourceforge.net/InstallerDescription";
  	
  	protected boolean debug = false;
  	protected String version;
  	protected File descriptor;
  	protected File destdir;
  	protected File workdir;
  	protected boolean validate = true;
  	protected File schema;
  	
  	protected String packageName;
  	protected String manufacturer;
  	protected String email;
  	protected String shortDescription;
  	protected List<String> longDescription;
  	protected List<String> license;
  	
  	
  	// -- [ Task execution ] -------------------------------------------
  		
  	/**
  	 * The execute method reads the descriptor file and executes the 
  	 * logic of the concrete class by calling the build() method.
  	 * 
  	 * @see Task#execute()
  	 */
  	@Override
  	public void execute() throws BuildException {
  
  		try {
  			
  			if (debug) handleOutput("Starting execute()");
  			
  			if (this.version == null) throw new BuildException("Attribute \"version\" must be set");		
  			if (this.descriptor == null) throw new BuildException("Attribute \"descriptor\" must be set");		
  			if (this.destdir == null) throw new BuildException("Attribute \"destdir\" must be set");		
  			if (this.workdir == null) throw new BuildException("Attribute \"workdir\" must be set");		
  			if (this.schema == null) throw new BuildException("Attribute \"schema\" must be set");		
  				
  			readDescriptorFile();
  			build();
  	 
  			if (debug) handleOutput("execute() finished");
  			
  		} catch (Exception e) {
  			
  			e.printStackTrace();
  			throw new BuildException(e.getMessage(),e);
  		}
 		
 	} // excecute()
 
 	/**
 	 * The build() method must be overridden by the concrete install-builder 
 	 * classes.
 	 * 
 	 * @throws Exception
 	 */
 	protected abstract void build() throws Exception;
 
 
 	// -- [ Decriptor file reading ] -------------------------------------------
 	
 	private void readDescriptorFile() throws SAXException, DocumentException, IOException, ParserConfigurationException  {
 	
 		
 		if (debug) handleOutput("Reading Descriptor file: "+this.descriptor);
 		
 		SAXReader reader = new SAXReader();
 		reader.setFeature("http://apache.org/xml/features/validation/schema", this.validate);
 		reader.setProperty("http://apache.org/xml/properties/schema/external-schemaLocation", DESCRIPTOR_NAMESPACE + " " + this.schema.getAbsolutePath());
 		Document doc = reader.read(descriptor);
 		 
 		Element root = doc.getRootElement();
 		if (debug) handleOutput("Reading Tag <Installer> ...");
 		
 		for (Object obj : root.elements()) {
 			
 			Element element = (Element) obj;
 			
 			if (element.getName() == "Package") {
 				
 				this.packageName = element.attributeValue("Name");
 				if (debug) handleOutput("Package -> Name: "+this.packageName);
 				
 				 this.manufacturer = element.attributeValue("Manufacturer");
 				 if (debug) handleOutput("Package -> Manufacturer: "+this.manufacturer);
 
 				 this.email = element.attributeValue("Email");
 				 if (debug) handleOutput("Package -> Email: "+this.email);
 
 			}
 			
 			
 			if (element.getName() == "Description") {
 
 				if (debug) handleOutput("Reading Tag: Description ...");
 				readDescription(element);
 			}
 			
 			
 			if (element.getName() == "License") {
 				
 				 
 				 BufferedReader license_reader = new BufferedReader(new StringReader(element.getText()));
 				
 				 this.license = new ArrayList<String>();
 				 
 				 String line = license_reader.readLine();		 
 				 
 				 while(line != null) {
 					 
 					 String l = line.trim();				 
 					 if (debug) handleOutput("License (Line): "+l);
 					 this.license.add(l);
 									
 					 line = license_reader.readLine();
 				 }
 				 
 			} // if
 						
 			if (element.getName() == "Windows") {
 				
 				if (debug) handleOutput("Reading Tag: Windows ...");
 				readWindowsTag(element);
 			}
 			
 			if (element.getName() == "Deb") {
 				
 				if (debug) handleOutput("Reading Tag: Deb ...");
 				readDebTag(element);
 			}
 			
 		} // for
 				 
 		if (debug) handleOutput("Finished reading Descriptor file");
 	}
 	
 	/**
 	 * Helper method to read the &lt;Description&gt; tag.
 	 * 
 	 * @param root The &lt;Description&gt; element.
 	 * @throws IOException 
 	 */
 	private void readDescription(Element root) throws IOException {
 		
 		for (Object obj : root.elements()) {
 		
 			Element element = (Element) obj;
 			
 			if (element.getName() == "Short") {
 				
 				 this.shortDescription = element.getText();
 				 if (debug) handleOutput("Short Description: "+this.shortDescription);
 			}
 			
 			if (element.getName() == "Long") {
 				
 				 BufferedReader desc_reader = new BufferedReader(new StringReader(element.getText()));
 				 
 				 this.longDescription = new ArrayList<String>();
 				 
 				 String line = desc_reader.readLine();
 				 while(line != null) {
 					 
 					 String l = line.trim();
 					 
 					 if (l.length() > 0) {
 				
 						 if (debug) handleOutput("Long Description (Line): "+l);
 						 this.longDescription.add(l);
 					 }
 					 
 					 line = desc_reader.readLine();
 				 }
 				 
 			} // if
 			
 		} // for
 		
 	} // readDescription()
 	
 	/**
 	 * This method should be overridden if the task needs 
 	 * informations from the &lt;Win&gt; element of the
 	 * descriptor file.
 	 * 
 	 * @param root
 	 */
 	protected void readWindowsTag(Element root) {};
 	
 	/**
 	 * This method should be overridden if the task needs 
 	 * informations from the &lt;Deb&gt; element of the
 	 * descriptor file.
 	 * 
 	 * @param root
 	 */
 	protected void readDebTag(Element root) {}
 
 	
 	// -- [ Common functions ] -----------------------------------------------------
 	
 	/**
 	 * Read patterns from the descriptor file
 	 * 
 	 * @param root The element containig &lt;Include&gt; and &lt;Exclude&gt; Elements as childs
 	 * @returns The patterns as list of Pattern classes
 	 * 
 	 */
 	protected List<Pattern> readPatterns(Element root) {
 
 		List<Pattern> patterns = new ArrayList<Pattern>();
 		
 		for (Object obj : root.elements()) {
 
 			Element element = (Element) obj;
 			
 			if (element.getName() == "Include") {
 				
 				Pattern pattern = new Pattern(element.getText(),false);
 			    if (debug) handleOutput("Include Pattern: "+pattern);
 			    patterns.add(pattern);
 			}
 			
 			if (element.getName() == "Exclude") {
 				
 				Pattern pattern = new Pattern(element.getText(),true);
 				if (debug) handleOutput("Exclude Pattern: "+pattern);
 				patterns.add(pattern);
 			}
 			
 		} // for
 			
 		return patterns;
 		
 	} // readPatterns()
 	
 		
 	/**
 	 * Create an Ant FileSet from a list of patterns
 	 * 
 	 * @param patterns List of Patterns
 	 * @param dir The basedirectory for the fileset
 	 * @return 
 	 */
 	protected FileSet createFilesetFromPatterns(List<Pattern> patterns,File dir) {
 		
 		FileSet fileset = new FileSet();
 		
 		if (debug) handleOutput("Creating FileSet [Basedir: "+dir.getAbsolutePath()+"]");
 		fileset.setDir(dir);
 		
 		for (Pattern p : patterns) {
 			
 			if (p.isInvert()) {
 				
 				if (debug) handleOutput("Adding Exclude: "+p.getPattern());
 				fileset.createExclude().setName(p.getPattern());
 			
 			} else {
 				
 				if (debug) handleOutput("Adding Include: "+p.getPattern());
 				fileset.createInclude().setName(p.getPattern());
 				
 			} // if else
 			
 		} // for
 				
 		return fileset;
 		
 	} //createConfigsFileset()
 	
 	
 	/**
 	 * Copy a file
 	 * 
 	 * @param src Source file
 	 * @param dst Destination file
 	 */
 	protected void copy(File src, File dst) {
 		
 		Copy copy_task = new Copy();
 		copy_task.setProject(getProject());
 		copy_task.setTaskName("copy");
 		copy_task.setVerbose(this.debug);
 		copy_task.setFile(src);
 		copy_task.setTofile(dst);
 		copy_task.execute();		
 		
 	} //copy()
 
 
 	// -- [ Getter/Setter ] -------------------------------------------
 	
 	/**
 	 * Enable debug output
 	 * 
 	 * @param debug
 	 */
 	public void setDebug(boolean debug) {
 		this.debug = debug;
 	}
 
 
 	/**
 	 * The descriptor file to read
 	 * 
 	 * @param descriptor
 	 */
 	public void setDescriptor(File descriptor) {
 		this.descriptor = descriptor;
 	}
 
 
 	/**
 	 * The version number of the generatd installer package
 	 * 
 	 * @param version
 	 */
 	public void setVersion(String version) {
 		this.version = version;
 	}
 
 	/**
 	 * The XML Schema for the descriptor file
 	 * 
 	 * @param schema
 	 */
 	public void setSchema(File schema) {
 		this.schema = schema;
 	}
 
 	/**
 	 * If false, the descriptor file will not be validated
 	 * 
 	 * @param validate
 	 */
 	public void setValidate(boolean validate) {
 		this.validate = validate;
 	}
 
 	/**
 	 * The directory where the installer packge will be created
 	 * 
 	 * @param destdir
 	 */
 	public void setDestdir(File destdir) {
 		this.destdir = destdir;
 	}
 
 	/**
 	 * The directory to compile the installer package
 	 * 
 	 * @param workdir
 	 */
 	public void setWorkdir(File workdir) {
 		this.workdir = workdir;
 	}
 
 
 }