package net.sf.jpkgmk.prototype;
   
   import java.io.File;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   
   import net.sf.jpkgmk.AbstractLineProvider;
   import net.sf.jpkgmk.pkgmap.PkgMapEntry;
  import net.sf.jpkgmk.pkgmap.PkgMapEntryType;
  import net.sf.jpkgmk.util.FileUtil;
  import net.sf.jpkgmk.util.StringUtil;
  import net.sf.jpkgmk.util.VariableMap;
  import net.sf.jpkgmk.util.VariableResolver;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Abstract class that can be used for the most of the prototype entries, for example files, directories, links ...
   * @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 abstract class AbstractPrototypeEntry extends AbstractLineProvider implements PrototypeEntry
  {
  	private Log log = LogFactory.getLog(AbstractPrototypeEntry.class);
  	
  	public static final String DEFAULT_FILE_CLASS = "none";
  
  	/**
  	 * An optional field designating the part number in which the object resides. 
  	 * A part is a collection of files and is the atomic unit by which a package is processed. 
  	 * A developer can choose criteria for grouping files into a part (for example, based on class). 
  	 * If this field is not used, part 1 is assumed. (field is omitted in prototype file)
  	 */
  	private Integer part;
  	private PrototypeEntryType type;
  	private String entryPath;
  	private String entryPathSource;
  	private String fileClass;
  	private Integer major;
  	private Integer minor;
  	private String mode;
  	private String owner;
  	private String group;
  	/**
  	 * The "DEFAULT" command that can provide default values for mode/owner/group if not set in this entry
  	 */
  	private PrototypeEntryCommandDefault entryCommandDefault;
  	
  	
  	/**
  	 * Constructor taking the mandatory arguments to create a prototype file entry
  	 * @param fileType
  	 * @param value
  	 */
  	public AbstractPrototypeEntry(PrototypeEntryType fileType, String entryPath)
  	{
  		this(fileType, null, entryPath, null, null, null, null, null);
  	}
  
  	/**
  	 * @param fileType
  	 * @param fileClass
  	 * @param entryPath the target path in that this file/directory should have in the package
  	 * @param mode
  	 * @param owner
  	 * @param group
  	 */
  	public AbstractPrototypeEntry(PrototypeEntryType fileType, String entryPath, String mode, String owner, String group)
  	{
  		this(fileType, null, entryPath, null, mode, owner, group, null);
  	}
  	
  	/**
  	 * @param fileType
  	 * @param fileClass
  	 * @param entryPath the target path in that this file/directory should have in the package
  	 * @param entryPathSource path to the local source file
  	 * @param mode
  	 * @param owner
  	 * @param group
  	 */
  	public AbstractPrototypeEntry(PrototypeEntryType fileType, String fileClass, String entryPath, String entryPathSource, String mode, String owner, String group, PrototypeEntryCommandDefault entryCommandDefault)
  	{
  		this(null, fileType, fileClass, entryPath, entryPathSource, null, null, mode, owner, group, entryCommandDefault);
  	}
  
  	
  	/**
  	 * @param part
  	 * @param fileType
  	 * @param fileClass
  	 * @param entryPath the target path that this file/directory should have in the created package
  	 * @param entryPathSource path to the local source file
  	 * @param mode
  	 * @param owner
 	 * @param group
 	 */
 	public AbstractPrototypeEntry(Integer part, PrototypeEntryType fileType, String fileClass, String entryPath, String entryPathSource, String mode, String owner, String group, PrototypeEntryCommandDefault entryCommandDefault)
 	{
 		this(part, fileType, fileClass, entryPath, entryPathSource, null, null, mode, owner, group, entryCommandDefault);
 	}
 
 	/**
 	 * Full constructor taking all possible arguments
 	 * @param part Optional part number
 	 * @param fileType
 	 * @param fileClass
 	 * @param entryPath the target path in that this file/directory should have in the package
 	 * @param entryPathSource path to the local source file
 	 * @param major The major device number. The field is only specified for block or character special devices.
 	 * @param minor The minor device number. The field is only specified for block or character special devices.
 	 * @param mode
 	 * @param owner
 	 * @param group
 	 * @param entryCommandDefault
 	 */
 	public AbstractPrototypeEntry(Integer part, PrototypeEntryType fileType, String fileClass, String entryPath, String entryPathSource, Integer major, Integer minor, String mode, String owner, String group, PrototypeEntryCommandDefault entryCommandDefault)
 	{
 		// Mandatory parameter check
 		if(fileType == null) {
 			throw new NullPointerException("The parameter 'fileType' must not be null");
 		}
 		if(entryPath == null) {
 			throw new NullPointerException("The parameter 'entryPath' must not be null");
 		}
 		
 		if(fileClass != null) {
 			validateFileClass(fileClass);
 		}
 		
 		if(mode!=null && !VariableMap.containsVariable(mode)) {
 			StringUtil.validateMode(mode);
 		}
 		
 		if(owner!=null && !VariableMap.containsVariable(owner)) {
 			validateOwner(owner);
 		}
 		if(group!=null && !VariableMap.containsVariable(group)) {
 			validateGroup(group);
 		}
 
 		
 		
 		this.part = part;
 		this.type = fileType;
 		this.fileClass = fileClass;
 		this.entryPath = entryPath;
 		this.entryPathSource = entryPathSource;
 		this.mode = mode;
 		this.owner = owner;
 		this.group = group;
 		this.major = major;
 		this.minor = minor;
 		this.entryCommandDefault = entryCommandDefault;
 	}
 
 	private void validateOwner(String owner) {
 		int maxOwnerLength = 14;
 		if(owner.length() > maxOwnerLength) {
 			throw new IllegalArgumentException("The given owner '" + owner + "' exceeds the maximum allowed length of " + maxOwnerLength);
 		}
 	}
 
 	private void validateGroup(String group) {
 		int maxGroupLength = 14;
 		if(group.length() > maxGroupLength) {
 			throw new IllegalArgumentException("The given group '" + group + "' exceeds the maximum allowed length of " + maxGroupLength);
 		}
 	}
 
 	private void validateFileClass(String fileClassToValidate) {
 		int maxClassLength = 12;
 		if(fileClassToValidate.length() > maxClassLength) {
 			throw new IllegalArgumentException("The given class '" + fileClassToValidate + "' exceeds the maximum allowed length of " + maxClassLength);
 		}
 		// Check if class is alphanumeric
 		if(!StringUtil.isAlphaNumeric(fileClassToValidate)) {
 			throw new IllegalArgumentException("The given class '" + fileClassToValidate + "' is not alphanumeric.");
 		}
 
 		// ("admin" and all classes beginning with capital letters are reserved class names.)
 		if(fileClassToValidate.equals("admin")) {
 			throw new IllegalArgumentException("The given class '" + fileClassToValidate + "' is a reserved word and must not be used ('admin' is a reserved word).");
 		}
 		if(Character.isUpperCase(fileClassToValidate.charAt(0))) {
 			throw new IllegalArgumentException("The given class '" + fileClassToValidate + "' is a reserved word and must not be used (it begins with a capital letter).");
 		}
 	}
 
 	/**
 	 * @param fileType
 	 * @param fileClass
 	 * @param value Key=Value pair or directory path
 	 * @param perm
 	 * @param owner
 	 * @param group
 	 * @return
 	 * @throws IOException
 	 */
 	private String createLine()
 	{
 		StringBuffer completeLine = new StringBuffer();
 		
 		if(this.part != null) {
 			completeLine.append(this.part);
 		}
 		
 		if(completeLine.length()>0) {
 			completeLine.append(" "); // add separator
 		}
 		completeLine.append(type.getKey());
 
 		// Class
 		if(!StringUtil.isNullOrEmpty(fileClass)) {
 			completeLine.append(" ").append(fileClass);
 		}
 		// Pathname
 		completeLine.append(" ").append(entryPath);
 		if(!StringUtil.isNullOrEmpty(entryPathSource)) {
 			completeLine.append("=").append(entryPathSource);
 		}
 		if(major != null) {
 			completeLine.append(" ").append(major);
 		}
 		if(minor != null) {
 			completeLine.append(" ").append(minor);
 		}
 		if(!StringUtil.isNullOrEmpty(mode)) {
 			completeLine.append(" ").append(mode);
 		}
 		if(!StringUtil.isNullOrEmpty(owner)) {
 			completeLine.append(" ").append(owner);
 		}
 		if(!StringUtil.isNullOrEmpty(group)) {
 			completeLine.append(" ").append(group);
 		}
 		return completeLine.toString();
 	}
 	
 	
 	public String getLine()
 	{
 		return this.createLine();
 	}
 
 	public PrototypeEntryType getType() {
 		return this.type;
 	}
 	
 	public String getEntryPath() {
 		return entryPath;
 	}
 
 	public String getEntryPathSource() {
 		return entryPathSource;
 	}
 
 	public String getFileClass() {
 		return fileClass;
 	}
 
 	public String getMode() {
 		return mode;
 	}
 
 	public String getOwner() {
 		return owner;
 	}
 
 	public String getGroup() {
 		return group;
 	}
 
 	
 	public Integer getMajor() {
 		return major;
 	}
 
 	public Integer getMinor() {
 		return minor;
 	}
 
 	protected final String resolveMode() {
 		if(!StringUtil.isNullOrEmpty(this.mode)) {
 			return this.mode;
 		}
 		else if(entryCommandDefault != null){
 			return entryCommandDefault.getMode();
 		}
 		else {
 			return null;
 		}
 	}
 
 	protected final String resolveOwner() 
 	{
 		if(!StringUtil.isNullOrEmpty(this.owner)) {
 			return this.owner;
 		}
 		else if(entryCommandDefault != null){
 			return entryCommandDefault.getOwner();
 		}
 		else {
 			return null;
 		}
 	}
 
 	protected final String resolveGroup() 
 	{
 		if(!StringUtil.isNullOrEmpty(this.group)) {
 			return this.group;
 		}
 		else if(entryCommandDefault != null){
 			return entryCommandDefault.getGroup();
 		}
 		else {
 			return null;
 		}
 	}
 
 //	protected File resolveTarget(File targetDir) {
 //		File target;
 //		// Is relocatable? (relocatable=relative path)
 //		if(FileUtil.isRelocatable(this.entryPath)) {
 ////		if(!new File(entryPath).isAbsolute()) {
 //			target = new File(targetDir, this.entryPath);
 //		}
 //		else {
 //			target = new File(this.entryPath);
 //		}
 //		return target;
 //	}
 
 	protected File buildAbsolutePath(File targetDir, String prototypeEntryPath)
 	{
 		File target;
 		// Is relocatable? (relocatable=relative path)
 		if(FileUtil.isRelocatable(prototypeEntryPath)) {
 			target = new File(targetDir, prototypeEntryPath);
 		}
 		else {
 			target = new File(prototypeEntryPath);
 		}
 		return target;
 	}
 	
 	/**
 	 * Copies the file of this prototype entry into the target directory
 	 * @see net.sf.jpkgmk.prototype.PrototypeEntry#create(java.io.File, VariableResolver)
 	 */
 	public final void create(File targetDir, VariableResolver variableResolver) throws IOException
 	{
 		String expandedEntryPath = variableResolver.expand(entryPath);
 		String expandedEntryPathSource = variableResolver.expand(entryPathSource);
 		this.create(targetDir, expandedEntryPath, expandedEntryPathSource);
 	}
 	
 	/**
 	 * Copies the file of this prototype entry into the target directory
 	 */
 	protected abstract void create(File targetDir, String entryPathExpanded, String entryPathSourceExpanded) throws IOException;
 
 
 	/**
 	 * @see net.sf.jpkgmk.prototype.PrototypeEntry#createPkgMapEntry(java.io.File, net.sf.jpkgmk.util.VariableResolver)
 	 */
 	public List<PkgMapEntry> createPkgMapEntry(File targetDir, VariableResolver variableResolver) {
 
 		if (variableResolver == null) {
 			throw new NullPointerException("The parameter 'variableResolver' must not be null");
 		}
 		
 		PkgMapEntryType resultType = this.type.getPkgMapEntryType();
 		
 		String expandedEntryPath = variableResolver.expand(entryPath);
 		String expandedEntryPathSource = variableResolver.expand(entryPathSource);
 		
 		String entryClass = null;
 		if(StringUtil.isNullOrEmpty(this.fileClass)) {
 			entryClass = DEFAULT_FILE_CLASS;
 			log.debug("entryClass is null. Defaulting the file class to " + fileClass + "' for entry " + this);
 		}
 		else {
 			entryClass =this.fileClass;
 		}
 		
 		// mode, owner, group can have variables as well
 		String mode = resolveMode();
 		mode = variableResolver.expand(mode);
 		String owner = resolveOwner();
 		owner = variableResolver.expand(owner);
 		String group = resolveGroup();
 		group = variableResolver.expand(group);
 		
 		if(mode!=null)
 			StringUtil.validateMode(mode);
 		if(owner!=null)
 			validateOwner(owner);
 		if(group!=null)
 			validateGroup(group);
 
 		
 		// Invoke the abstract implementation
 		PkgMapEntry resultEntry = createPkgMapEntry(this.part, resultType, entryClass, expandedEntryPath, expandedEntryPathSource, major, minor, mode, owner, group, targetDir);
 
 		List<PkgMapEntry> result = new ArrayList<PkgMapEntry>();
 		result.add(resultEntry);
 		return result;
 	}
 
 	protected abstract PkgMapEntry createPkgMapEntry(Integer part,
 			PkgMapEntryType resultType, String entryClass, String entryPath, String entryPathSource,
 			Integer major, Integer minor, String mode, String owner, String group, File targetDir);
 	
 	
 	
 	//TODO needed for PrototypeEntryLink and PrototypeEntryLinkSymbolic?
 //	private String buildPathForPkgMap() {
 //		// only links may have the "=" assignment
 //		String path = this.entryPath;
 //		if(this.entryPathSource != null) {
 //			if(this.type == PrototypeEntryType.L || this.type == PrototypeEntryType.S) {
 //				path += "=" + this.entryPathSource;
 //			}
 //			else {
 //				log.debug("The member entryPathSource='" + entryPathSource + "' is not used. No linked file.");
 //			}
 //		}
 //		else {
 //			log.debug("The member 'entryPathSource' is null. Not added to path");
 //		}
 //		return path;
 //	}
 
 
 
 	@Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result
 				+ ((entryPath == null) ? 0 : entryPath.hashCode());
 		return result;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		if (getClass() != obj.getClass())
 			return false;
 		final AbstractPrototypeEntry other = (AbstractPrototypeEntry) obj;
 		if (entryPath == null) {
 			if (other.entryPath != null)
 				return false;
 		} else if (!entryPath.equals(other.entryPath))
 			return false;
 		return true;
 	}
 
 	@Override
 	public String toString()
 	{
 		return this.getLine();
 	}
 
 }