package net.sf.jpkgmk.prototype;
   
   import java.io.File;
   import java.io.FileFilter;
   import java.io.IOException;
   import java.util.Arrays;
   import java.util.Comparator;
   
   import net.sf.jpkgmk.DefaultPermissionProvider;
  import net.sf.jpkgmk.FileHandler;
  import net.sf.jpkgmk.PermissionProvider;
  import net.sf.jpkgmk.util.FileUtil;
  import net.sf.jpkgmk.util.StringUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Utility that helps creating a prototype file.
   * 
   * @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 PrototypeBuilder 
  {
  	private Log log = LogFactory.getLog(PrototypeBuilder.class);
  
  	private String defaultUser="root";
  	private String defaultGroup="other";
  	private PermissionProvider defaultPermissionProvider=new DefaultPermissionProvider();
  
  	private Prototype prototype;
  	
  	private File basedir;
  
  	private Comparator<File> dirFirstComparator = new Comparator<File>() {
  	
  		public int compare(File o1, File o2) {
  			if(o1.isDirectory() && o2.isDirectory()) {
  				return o1.compareTo(o2);
  			}
  			else if(o1.isFile() && o2.isFile()) {
  				return o1.compareTo(o2);
  			}
  			else if(o1.isDirectory()) {
  				return -1;
  			}
  			else if(o2.isDirectory()) {
  				return 1;
  			}
  			return 0;
  		}
  	
  	};
  	
  
  	/**
  	 * @see PrototypeBuilder#PrototypeBuilder(File, String, String, PermissionProvider)
  	 */
  	public PrototypeBuilder()
  	{
  		this(null, null, null, null);
  	}
  	
  	/**
  	 * @see PrototypeBuilder#PrototypeBuilder(File, String, String, PermissionProvider)
  	 */
  	public PrototypeBuilder(File basedir)
  	{
  		this(basedir, null, null, null);
  	}
  
  	/**
  	 * @see PrototypeBuilder#PrototypeBuilder(File, String, String, PermissionProvider)
  	 */
  	public PrototypeBuilder(File basedir, String defaultUser, String defaultGroup)
  	{
  		this(basedir, defaultUser, defaultGroup, null);
  	}
  	
  	/**
  	 * @param basedir The basedirectory in which the prototype file is created after invocation of the create() method.
  	 * @param defaultUser
  	 * @param defaultGroup
  	 * @param defaultPermissionProvider
  	 */
  	public PrototypeBuilder(File basedir, String defaultUser, String defaultGroup, PermissionProvider defaultPermissionProvider)
  	{
  		this.basedir = basedir;
  		
  		if(!StringUtil.isNullOrEmpty(defaultUser)) {
  			this.defaultUser = defaultUser;
  		}
  		if(!StringUtil.isNullOrEmpty(defaultGroup)) {
  			this.defaultGroup = defaultGroup;
  		}
  		if(defaultPermissionProvider != null) {
 			this.defaultPermissionProvider = defaultPermissionProvider;
 		}
 		this.prototype = new Prototype();
 	}
 	
 	public String getDefaultUser() {
 		return defaultUser;
 	}
 
 	public String getDefaultGroup() {
 		return defaultGroup;
 	}
 
 	public Prototype getPrototype()
 	{
 		return this.prototype;
 	}
 	
 	
 	public void add(PrototypeEntry prototypeEntry) {
 		this.prototype.add(prototypeEntry);
 	}
 
 	
 	public void addLink(String linkLocation, PrototypeEntryFile entry) {
 		PrototypeEntryLink link = new PrototypeEntryLink(linkLocation, entry.getEntryPath());
 		this.add(link);
 	}
 
 	public void addFile(File sourceFile) throws IOException
 	{
 		this.addFile(sourceFile, PrototypeEntryType.F, null);
 	}
 	
 	public PrototypeEntryFile addFile(File sourceFile, PrototypeEntryType type) throws IOException
 	{
 		return this.addFile(sourceFile, type, null);
 	}
 
 	public PrototypeEntryFile addFile(File sourceFile, PrototypeEntryType type, String targetPathForPackage) throws IOException
 	{
 		if (sourceFile == null) {
 			throw new NullPointerException(
 					"The parameter 'sourceFile' must not be null");
 		}
 		if (type == null) {
 			throw new NullPointerException(
 					"The parameter 'type' must not be null");
 		}
 		
 		if(!sourceFile.isFile()) {
 			throw new IllegalArgumentException("The file '" + sourceFile + "' must be a file");
 		}
 		
 		PrototypeEntryFile entry = addFileInternal(sourceFile, targetPathForPackage, this.defaultUser, this.defaultGroup, this.defaultPermissionProvider, type);
 		return entry;
 	}
 	
 	
 	/**
 	 * Adds the given directory recursively to this prototype file.
 	 * All files/subfiles and subdirs are included.
 	 * @param directory
 	 */
 	public void addDirectory(File directory)
 	{
 		this.addDirectory(directory, true);
 	}
 
 	/**
 	 * Adds the given directory recursively to this prototype file.
 	 * All files/subfiles and subdirs are included.
 	 * @param directory
 	 * @param recurse
 	 */
 	public void addDirectory(File directory, boolean recurse)
 	{
 		this.addDirectory(directory, null, null, null, null, null, recurse);
 	}
 
 	/**
 	 * Adds the given directory recursively to this prototype file.
 	 * All files/subfiles and subdirs are included.
 	 * @param directory
 	 * @param targetPathDir
 	 */
 	public void addDirectory(File directory, String targetPathDir)
 	{
 		this.addDirectory(directory, targetPathDir, null, null, null);
 	}
 	
 	/**
 	 * Adds the given directory recursively to this prototype file.
 	 * All files/subfiles and subdirs are included.
 	 * @param directory
 	 * @param owner
 	 * @param group
 	 * @param permissionProvider
 	 * @param targetPathDir
 	 */
 	public void addDirectory(File directory, String targetPathDir, String owner, String group, PermissionProvider permissionProvider)
 	{
 		this.addDirectory(directory, targetPathDir, owner, group, permissionProvider, null, true);
 	}
 	
 	/**
 	 * Adds the given directory recursively to this prototype file.
 	 * All files/subfiles and subdirs are included.
 	 * @param directory The directory to be added to the prototype
 	 * @param targetPathDir Path for this directory on the target machine. Can be null
 	 * @param owner Owner of the directory and the child files. Can be null
 	 * @param group Group of the directory and the child files. Can be null
 	 * @param permissionProvider Permission provider for the given directory and the child files. Can be null
 	 * @param fileFilter Can be null. Filters out some unwished files.
 	 * @param recurse If subdirectories should be included
 	 */
 	public void addDirectory(File directory, String targetPathDir, String owner, String group, PermissionProvider permissionProvider, FileFilter fileFilter, boolean recurse)
 	{
 		log.debug("adding directory '" + directory + "'");
 		
 		if(directory == null) {
 			throw new NullPointerException("The parameter 'directory' must not be null");
 		}
 		if(!directory.isDirectory()) {
 			throw new IllegalArgumentException("The given directory '" + directory + "' is not a directory.");
 		}
 		
 		if(StringUtil.isNullOrEmpty(owner)) {
 			owner = this.defaultUser;
 		}
 		if(StringUtil.isNullOrEmpty(group)) {
 			group = this.defaultGroup;
 		}
 		if(permissionProvider == null) {
 			permissionProvider = this.defaultPermissionProvider;
 		}
 		
 		addDirectoryInternal(directory, targetPathDir, owner, group, permissionProvider, fileFilter, recurse);
 	}
 	
 	
 	protected void addDirectoryInternal(File directory, String targetPathDir, String owner, String group, PermissionProvider permissionProvider, FileFilter fileFilter, boolean recurse)
 	{
 		log.debug("adding directory '" + directory + "'");
 	
 		if(!directory.isDirectory()) {
 			throw new IllegalArgumentException("The given file must be a directory: '" + directory + "'");
 		}
 
 		// TODO is it possible to use a "Handler" interface so that the user can implement his own class for adding dirs/files? Think about it - similar to PrototypeCommandSearch
 
 		File[] children = null;
 		if(fileFilter == null) {
 			children = directory.listFiles();
 		}
 		else {
 			children = directory.listFiles(fileFilter);
 		}
 		
 		if(children != null) {
 			Arrays.sort(children, this.dirFirstComparator);
 			
 			// Iterate over the children
 			for (int i = 0; i < children.length; i++) {
 				File currentFile = children[i];
 				// Build the target path for the current dir/file on the unix system
 				String currentPathForTarget;
 				if(targetPathDir==null) {
 					currentPathForTarget = currentFile.getName();
 				}
 				else {
 					// Ensure that the target path dir also exists as entry in the prototype - otherwise the parent dir will be missing
 					String perm = permissionProvider.getMode(directory);
 					PrototypeEntry entry = new PrototypeEntryDirectory(null, AbstractPrototypeEntry.DEFAULT_FILE_CLASS, targetPathDir, perm, owner, group, null);
 					if(!this.prototype.contains(entry)) {
 						this.prototype.add(entry);
 					}
 					currentPathForTarget = targetPathDir + FileUtil.UNIX_FILE_SEPARATOR + currentFile.getName();
 				}
 				
 				if(currentFile.isDirectory()) {
 					// 1. add directory
 					createAndAddDirEntry(currentFile, currentPathForTarget, owner, group, permissionProvider, PrototypeEntryType.D);
 					// 2. recurse this directory
 					if(recurse) {
 						log.debug("Recursive call for subdir '" + currentFile + "'");
 						addDirectoryInternal(currentFile, currentPathForTarget, owner, group, permissionProvider, fileFilter, recurse);
 					}
 					else {
 						log.debug("No recursive call is done for subdir '" + currentFile + "'");
 					}
 				}
 				else {
 					addFileInternal(currentFile, currentPathForTarget, owner, group, permissionProvider, PrototypeEntryType.F);
 				}
 			}
 		}
 	}
 	
 
 	private String resolveFilePathOnTarget(String inputFilePathOnTarget, File currentFile) {
 		if(inputFilePathOnTarget == null) {
 			inputFilePathOnTarget = currentFile.getName();
 			log.debug("No 'filePathOnTarget' specified - defaulting to '" + inputFilePathOnTarget + "'.");
 		}
 		return inputFilePathOnTarget;
 	}
 
 	private void createAndAddDirEntry(File currentFile, String filePathOnTarget, String owner, String group, PermissionProvider permissionProvider, PrototypeEntryType entryType)
 	{
 		String perm = permissionProvider.getMode(currentFile);
 		filePathOnTarget = resolveFilePathOnTarget(filePathOnTarget,currentFile);
 		
 		PrototypeEntry entry;
 		if(entryType == PrototypeEntryType.D) {
 			entry = new PrototypeEntryDirectory(null, AbstractPrototypeEntry.DEFAULT_FILE_CLASS, filePathOnTarget, perm, owner, group, null);
 		}
 		else if(entryType == PrototypeEntryType.X) {
 			entry = new PrototypeEntryDirectoryExclusive(null, AbstractPrototypeEntry.DEFAULT_FILE_CLASS, filePathOnTarget, perm, owner, group, null);
 		}
 		else {
 			throw new IllegalArgumentException("The entryType '" + entryType + "' is not yet supported");
 		}
 
         this.prototype.add(entry);
 	}
 
 	
 	protected PrototypeEntryFile addFileInternal(File currentFile, String filePathOnTarget, String owner, String group, PermissionProvider permissionProvider, PrototypeEntryType entryType) 
 	{
 		String perm = permissionProvider.getMode(currentFile);
 		String sourceFile = currentFile.getAbsolutePath();
 		filePathOnTarget = resolveFilePathOnTarget(filePathOnTarget,currentFile);
 
 		PrototypeEntryFile entry;
 		if(entryType == PrototypeEntryType.F) {
 			entry = new PrototypeEntryFile(null, AbstractPrototypeEntry.DEFAULT_FILE_CLASS, filePathOnTarget, sourceFile, perm, owner, group, null);
 		}
 		else if(entryType == PrototypeEntryType.E) {
 			entry = new PrototypeEntryFileEditable(null, AbstractPrototypeEntry.DEFAULT_FILE_CLASS, filePathOnTarget, sourceFile, perm, owner, group, null);
 		}
 		else if(entryType == PrototypeEntryType.V) {
 			entry = new PrototypeEntryFileVolatile(null, AbstractPrototypeEntry.DEFAULT_FILE_CLASS, filePathOnTarget, sourceFile, perm, owner, group, null);
 		}
 		else if(entryType == PrototypeEntryType.I) {
 			entry = new PrototypeEntryInfo(null, filePathOnTarget, sourceFile);
 		}
 //		else if(entryType == PrototypeEntryType.S) {
 //			entry = new PrototypeEntrySymbolicLink(null, filePathOnTarget, sourceFile);
 //		}
 //		else if(entryType == PrototypeEntryType.L) {
 //			throw new IllegalArgumentException("Cannot add a physical file as link. You must add the file first and then the link using strings.");
 //			entry = new PrototypeEntryLink(null, filePathOnTarget, sourceFile);
 //		}
 		else {
 			throw new IllegalArgumentException("The entryType '" + entryType + "' is not yet supported");
 		}
 		
 		// Ensure that a file class is set
 		// TODO is it possible to use a "Handler" interface so that the user can implement his own class for adding dirs/files? Think about it - similar to PrototypeCommandSearch
 
         this.prototype.add(entry);
         return entry;
 	}
 
 
 	private void checkBasedirIsSet(){
 		if (basedir == null) {
 			throw new NullPointerException("The attribute 'basedir' must not be null");
 		}
 	}
 
 	public File clean() {
 		checkBasedirIsSet();
 		getPrototype().clean(basedir);
 		return getFile();
 	}
 
 	public File create() throws IOException {
 		checkBasedirIsSet();
 		getPrototype().create(basedir);
 		return getFile();
 	}
 	
 	public File getFile(){
 		checkBasedirIsSet();
 		FileHandler fileHandler = getPrototype().getFileHandler(basedir);
 		return fileHandler.getFile();
 	}
 	
     @Override
 	public String toString()
 	{
 		StringBuffer sb = new StringBuffer();
 		sb.append(getClass().getName()).append("[");
 		sb.append("basedir=").append(basedir);
 		sb.append(",defaultUser=").append(defaultUser);
 		sb.append(",defaultGroup=").append(defaultGroup);
 		sb.append(",defaultPermissionProvider=").append(defaultPermissionProvider);
 		sb.append(",prototype=").append(this.prototype);
 		sb.append("]");
 		return sb.toString();
 	}
 
 }