package net.sf.jpkgmk.prototype;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.StringWriter;
   import java.io.Writer;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  
  import net.sf.jpkgmk.AbstractFileCreatorAdapter;
  import net.sf.jpkgmk.DefaultFileHandler;
  import net.sf.jpkgmk.DuplicateEntryException;
  import net.sf.jpkgmk.FileHandler;
  import net.sf.jpkgmk.PackageException;
  import net.sf.jpkgmk.PkgInfo;
  import net.sf.jpkgmk.pkgmap.PkgMap;
  import net.sf.jpkgmk.pkgmap.PkgMapEntry;
  import net.sf.jpkgmk.pkgmap.PkgMapEntryHeader;
  import net.sf.jpkgmk.util.FileUtil;
  import net.sf.jpkgmk.util.VariableMap;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Pure java impl for the creation of a prototype which is normally done with "pkgproto" on unix.
   * Used for "pkgmk" on unix
   * 
   * @author gommma (gommma AT users.sourceforge.net)
   * @author Last changed by: $Author: gommma $
   * @version $Revision: 2 $ $Date: 2008-08-20 21:14:19 +0200 (Mi, 20 Aug 2008) $
   * @since 1.0
   */
  public class Prototype extends AbstractFileCreatorAdapter
  {
  	public static final String PROTOTYPE="prototype";
  	private Log log = LogFactory.getLog(Prototype.class);
  	private List<PrototypeEntry> prototypeEntryList = new ArrayList<PrototypeEntry>();
  	
  	/** 
  	 * variableMap for creating the PkgMap entries later
  	 */
  	private VariableMap variableMap = new VariableMap();
  
  	
  	/**
  	 * Default constructor
  	 */
  	public Prototype() {
  		super();
  	}
  
  	
  	public VariableMap getVariableMap() {
  		return variableMap;
  	}
  
  	public void setVariableMap(VariableMap variableMap) {
  		this.variableMap = variableMap;
  	}
  
  
  	public void writeContent(Writer writer) throws IOException 
  	{
  		for(Iterator<PrototypeEntry> iter=this.prototypeEntryList.iterator(); iter.hasNext(); ) {
  			PrototypeEntry entry = iter.next();
  			writer.write(entry.getLine());
  			writer.write(PkgInfo.LINE_SEPARATOR);
  		}
  		writer.flush();
  	}
  
  
      @Override
  	public FileHandler getFileHandler(File targetDir) {
  		DefaultFileHandler fileCreator = new DefaultFileHandler(targetDir, PROTOTYPE);
  		return fileCreator;
  	}
  
      
  	/**
  	 * Adds a prototype entry. Does <b>not</b> create the physical file yet
  	 * @param entry New entry to add
  	 */
  	public void add(PrototypeEntry entry) {
  		log.debug("Adding entry: " + entry);
  		this.add(this.prototypeEntryList.size(), entry);
  	}
  
  	/**
  	 * Adds a prototype entry. Does <b>not</b> create the physical file yet
  	 * @param insertIndex The index where to insert the given entry
  	 * @param entry New entry to add
  	 */
  	public void add(int insertIndex, PrototypeEntry entry) {
  		log.debug("Adding entry: " + entry + ", index=" + insertIndex);
 		if(prototypeEntryList.contains(entry)) {
 			int index = prototypeEntryList.indexOf(entry);
 			Object existingPrototypeEntry = prototypeEntryList.get(index);
 			throw new DuplicateEntryException("The prototype already contains an entry that equals the given one: existing='" + existingPrototypeEntry + "', given='" + entry + "'.");
 		}
 		else {
 			/*boolean success = */prototypeEntryList.add(insertIndex, entry);
 //			if(!success) {
 //				throw new IllegalStateException("Failed to add entry to list. Entry=" + entry);
 //			}
 			
 			variableMap.registerInVariablesMap(entry);
 		}
 	}
 
 
 	public boolean remove(PrototypeEntry entry) {
 		variableMap.unregisterFromVariablesMap(entry);
 		return this.prototypeEntryList.remove(entry);
 	}
 	
 	public boolean contains(PrototypeEntry entry) {
 		return prototypeEntryList.contains(entry);
 	}
 
 	/**
 	 * @return Returs the list of prototype entries in the order they were added before
 	 */
 	public List<PrototypeEntry> getPrototypeEntryList()
 	{
 		return Collections.unmodifiableList(this.prototypeEntryList);
 	}
 	
 	/**
 	 * Creates the package which includes the creation of all files that contain to the package
 	 * as well as the java object {@link PkgMap}. Note that the physical pkgmap file is not created.
 	 * @param targetDir The directory where all target files are copied to/created in.
 	 * @return The object representation {@link PkgMap} of the pkgmap file. 
 	 * @throws IOException
 	 */
 	public PkgMap createPackage(File targetDir) throws IOException {
 		// create files
 		this.createFiles(targetDir);
 		// Create the pkgmap java object
 		PkgMap pkgMap = this.createPkgMap(targetDir);
 		return pkgMap;
 	}
 
 	
 	/**
 	 * @param targetDir The directory in which the physical files for the pkgMapEntries are located
 	 * @return The result pkgmap object
 	 */
 	public PkgMap createPkgMap(File targetDir) {
 		log.debug("<Entering> addPrototypeEntriesToPkgMap()");
 
 		PkgMap pkgMap = new PkgMap();
 		
 		List<PrototypeEntry> prototypeEntryList = this.getPrototypeEntryList();
 		for(Iterator<PrototypeEntry> iter=prototypeEntryList.iterator(); iter.hasNext();) {
 			PrototypeEntry entry = iter.next();
 			
 			try {
 				// Create a pkgmap entry from the prototype entry
 				List<PkgMapEntry> pkgMapEntryList = entry.createPkgMapEntry(targetDir, this.variableMap);
 				if(pkgMapEntryList != null)
 					pkgMap.addAll(pkgMapEntryList);
 			}
 			catch(Exception e) {
 				throw new PackageException("Exception while creating pkgmap entry for prototype entry " + entry + ". " +
 						"Make sure you created the physical files before creating the package via Prototype.createFiles().", e);
 			}
 		}
 
 		PkgMapEntryHeader header = createHeader(targetDir, pkgMap);
 		pkgMap.setHeader(header);
 
 		return pkgMap;
 	}
 
 	private PkgMapEntryHeader createHeader(File targetDir, PkgMap pkgMap) {
 		// Create the header dynamically from the lines
 		Integer numberOfParts = pkgMap.getNumberOfParts();
 		Long maximumPartSize = FileUtil.getBlockCount(targetDir);
 		return new PkgMapEntryHeader(numberOfParts, maximumPartSize);
 	}
 
 
 
 	public void createFiles(File targetDir) throws IOException {
 		if(!targetDir.isDirectory()) {
 			throw new IllegalStateException("The given target dir '" + targetDir + "' does not exist.");
 		}
 		
 		List<PrototypeEntry> prototypeEntryList = this.getPrototypeEntryList();
 		for(Iterator<PrototypeEntry> iter=prototypeEntryList.iterator(); iter.hasNext();) {
 			PrototypeEntry entry = iter.next();
 			try {
 				// Create the files for the entry
 				entry.create(targetDir, this.variableMap);
 			}
 			catch(Exception e) {
 				throw new PackageException("Exception while creating package. Failed to create files for prototype entry '" + entry + "'", e);
 			}
 		}
 	}
 
 	
 	public String toPrettyString()
 	{
 		StringBuffer sb = new StringBuffer();
 		sb.append(getClass().getName()).append("[");
 
 		StringWriter writer = new StringWriter();
 		try {
 			this.writeContent(writer);
 			sb.append("\n");
 			sb.append(writer.toString());
 			sb.append("\n");
 		} catch (IOException e) {
 			String msg = "Exception while creating pretty string";
 			log.warn(msg, e);
 			sb.append(msg);
 		}
 		
 		sb.append("]");
 		return sb.toString();
 	}
 	
     @Override
 	public String toString()
 	{
 		StringBuffer sb = new StringBuffer();
 		sb.append(getClass().getName()).append("[");
 		sb.append("prototypeEntryList=").append(prototypeEntryList);
 		sb.append("]");
 		return sb.toString();
 	}
 	
 	
 	/**
 	 * Sorts the PrototypeEntryFile objects so that the directories are before all other entries
 	 */
 	protected static class PrototypeEntryFileSorter implements Comparator<PrototypeEntry>
 	{
 
 		public int compare(PrototypeEntry arg0, PrototypeEntry arg1) {
 			if(arg0 == null) {
 				return -1;
 			}
 			if(arg1 == null) {
 				return 1;
 			}
 			
 			if(arg0.getType() == PrototypeEntryType.D) {
 				if(arg1.getType() == PrototypeEntryType.D) {
 					return 0;
 				}
 				else {
 					return -1;
 				}
 			}
 			else {
 				if(arg1.getType() == PrototypeEntryType.D) {
 					return 1;
 				}
 				else {
 					return 0;
 				}
 			}
 		}
 		
 	}
 
 }