package net.sf.jpkgmk.pkgmap;
   
   import net.sf.jpkgmk.AbstractLineProvider;
   import net.sf.jpkgmk.util.ObjectUtils;
   import net.sf.jpkgmk.util.StringUtil;
   import net.sf.jpkgmk.util.StringUtil.KeyValuePair;
   
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
  
  /**
   * Abstract class that can be used for the most of the pkgmap 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 AbstractPkgMapEntry extends AbstractLineProvider implements PkgMapEntry, Comparable<AbstractPkgMapEntry>
  {
  	private Log log = LogFactory.getLog(AbstractPkgMapEntry.class);
  	
  	/**
  	 * 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 PkgMapEntryType type;
  	private String entryPath;
  	private String entryPathSource;
  	private String entryClass;
  	private Integer major;
  	private Integer minor;
  	private String mode;
  	private String owner;
  	private String group;
  
  	// Only for files
  	private Long modtime;
  	private Long checksum;
  	private Long filesize;
  	
  	/**
  	 * Constructor taking the mandatory arguments to create a pkgmap entry
  	 * @param fileType
  	 * @param value
  	 */
  	public AbstractPkgMapEntry(PkgMapEntryType fileType, String entryPath)
  	{
  		this(fileType, null, entryPath, null, null, null, null);
  	}
  
  	/**
  	 * @param fileType
  	 * @param entryClass
  	 * @param entryPath the target path in that this file/directory should have in the package
  	 * @param mode
  	 * @param owner
  	 * @param group
  	 */
  	public AbstractPkgMapEntry(PkgMapEntryType fileType, String entryPath, String mode, String owner, String group)
  	{
  		this(fileType, null, entryPath, null, mode, owner, group);
  	}
  	
  	/**
  	 * @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 AbstractPkgMapEntry(PkgMapEntryType fileType, String fileClass, String entryPath, String entryPathSource, String mode, String owner, String group)
  	{
  		this(null, fileType, fileClass, entryPath, entryPathSource, null, null, mode, owner, group);
  	}
  
  	
  	/**
  	 * Full constructor taking all possible arguments
  	 * @param part Optional part number
  	 * @param type
  	 * @param entryClass
  	 * @param entryPath the target path in that this file/directory should have in the package
  	 * @param entryPathSource
  	 * @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
  	 */
  	public AbstractPkgMapEntry(Integer part, PkgMapEntryType type, String entryClass, String entryPath, String entryPathSource, Integer major, Integer minor, String mode, String owner, String group)
  	{
  		// Mandatory parameter check
  		if(type == null) {
  			throw new NullPointerException("The parameter 'fileType' must not be null");
 		}
 		if(entryPath == null) {
 			throw new NullPointerException("The parameter 'entryPath' must not be null");
 		}
 
 		
 		int maxClassLength = 12;
 		if(entryClass != null) {
 			if(entryClass.length() > maxClassLength) {
 				throw new IllegalArgumentException("The given class '" + entryClass + "' exceeds the maximum allowed length of " + maxClassLength);
 			}
 			// Check if class is alphanumeric
 			if(!StringUtil.isAlphaNumeric(entryClass)) {
 				throw new IllegalArgumentException("The given class '" + entryClass + "' is not alphanumeric.");
 			}
 		}
 		
 		if(mode != null) {
 			StringUtil.validateMode(mode);
 		}
 		int maxOwnerLength = 14;
 		if(owner != null && owner.length() > maxOwnerLength) {
 			throw new IllegalArgumentException("The given owner '" + owner + "' exceeds the maximum allowed length of " + maxOwnerLength);
 		}
 		
 		int maxGroupLength = 14;
 		if(group != null && group.length() > maxGroupLength) {
 			throw new IllegalArgumentException("The given group '" + group + "' exceeds the maximum allowed length of " + maxGroupLength);
 		}
 		
 		this.part = part;
 		this.type = type;
 		this.entryClass = entryClass;
 		this.entryPath = entryPath;
 		this.entryPathSource = entryPathSource;
 		this.mode = mode;
 		this.owner = owner;
 		this.group = group;
 		this.major = major;
 		this.minor = minor;
 	}
 
 	/**
 	 * @return The pkgmap line
 	 */
 	public String createLine()
 	{
 		log.debug("<entering> createLine()");
 		
 		StringBuffer sb = new StringBuffer();
 		
 		if(this.part != null) {
 			sb.append(this.part);
 			sb.append(" "); // add separator
 		}
 		
 		sb.append(this.type.getKey());
 		
 		if(this.entryClass != null) {
 			sb.append(" ").append(this.entryClass);
 		}
 
 		sb.append(" ").append(this.entryPath);
 		if(!StringUtil.isNullOrEmpty(entryPathSource)) {
 			sb.append(KeyValuePair.ASSIGNMENT_CHAR).append(entryPathSource);
 		}
 		
 		if(!StringUtil.isNullOrEmpty(mode)) {
 			sb.append(" ").append(mode);
 		}
 		if(!StringUtil.isNullOrEmpty(owner)) {
 			sb.append(" ").append(owner);
 		}
 		if(!StringUtil.isNullOrEmpty(group)) {
 			sb.append(" ").append(group);
 		}
 	
 		if(filesize!=null) {
 			sb.append(" ").append(filesize);
 		}
 		if(checksum!=null) {
 			sb.append(" ").append(checksum);
 		}
 		if(modtime!=null) {
 			sb.append(" ").append(modtime);
 		}
 
 		return sb.toString();
 	}
 
 	public String getLine()
 	{
 		return this.createLine();
 	}
 	
 	public Integer getPart() {
 		return part;
 	}
 
 	/**
 	 * @return Returns the type of this entry
 	 */
 	public PkgMapEntryType getType()
 	{
 		return this.type;
 	}
 	
 	public String getEntryPath() {
 		return entryPath;
 	}
 
 	public String getEntryPathSource() {
 		return entryPathSource;
 	}
 
 	public String getEntryClass() {
 		return entryClass;
 	}
 
 	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;
 	}
 
 	public Long getModtime() {
 		return modtime;
 	}
 
 	public void setModtime(Long modtime) {
 		this.modtime = modtime;
 	}
 
 	public Long getChecksum() {
 		return checksum;
 	}
 
 	public void setChecksum(Long checksum) {
 		this.checksum = checksum;
 	}
 
 	public Long getFilesize() {
 		return filesize;
 	}
 
 	public void setFilesize(Long filesize) {
 		this.filesize = filesize;
 	}
 
 	/**
 	 * Compares this object with the given {@link AbstractPkgMapEntry} using the {@ink #entryClass}
 	 * or the {@link #entryPath} if the classes are equal. Needed for sorting the pkgmap entries.
 	 * <p>
 	 * As defined in the sun docs:
 	 * &quot;The package objects in pkgmap are listed in alphabetical order by class and by path name to
 	 * reduce the time it takes to install the package.&quot;
 	 * 
 	 * @see java.lang.Comparable#compareTo(java.lang.Object)
 	 */
 	public int compareTo(AbstractPkgMapEntry o) {
 		int classCompare = StringUtil.compare(this.entryClass, o.getEntryClass());
 		if(classCompare != 0)
 			return classCompare;
 		
 		int pathCompare = StringUtil.compare(this.entryPath, o.getEntryPath());
 		return pathCompare;
 	}
 
 	@Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result
 				+ ((checksum == null) ? 0 : checksum.hashCode());
 		result = prime * result
 				+ ((entryClass == null) ? 0 : entryClass.hashCode());
 		result = prime * result
 				+ ((entryPath == null) ? 0 : entryPath.hashCode());
 		result = prime * result
 				+ ((entryPathSource == null) ? 0 : entryPathSource.hashCode());
 		result = prime * result
 				+ ((filesize == null) ? 0 : filesize.hashCode());
 		result = prime * result + ((group == null) ? 0 : group.hashCode());
 		result = prime * result + ((major == null) ? 0 : major.hashCode());
 		result = prime * result + ((minor == null) ? 0 : minor.hashCode());
 		result = prime * result + ((mode == null) ? 0 : mode.hashCode());
 		result = prime * result + ((modtime == null) ? 0 : modtime.hashCode());
 		result = prime * result + ((owner == null) ? 0 : owner.hashCode());
 		result = prime * result + ((part == null) ? 0 : part.hashCode());
 		result = prime * result + ((type == null) ? 0 : type.hashCode());
 		return result;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		return this.equals(obj, false);
 	}
 
 	public boolean equals(Object obj, boolean ignoreLastModified)
 	{
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		if (getClass() != obj.getClass())
 			return false;
 		final AbstractPkgMapEntry other = (AbstractPkgMapEntry) obj;
 
 		if(!ObjectUtils.areObjectsEqual(this.checksum, other.checksum))
 			return false;
 
 		if(!ObjectUtils.areObjectsEqual(this.entryClass, other.entryClass))
 			return false;
 
 		if(!ObjectUtils.areObjectsEqual(this.entryPath, other.entryPath))
 			return false;
 
 		if(!ObjectUtils.areObjectsEqual(this.entryPathSource, other.entryPathSource))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.filesize, other.filesize))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.group, other.group))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.major, other.major))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.minor, other.minor))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.mode, other.mode))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.entryPath, other.entryPath))
 			return false;
 		
 		if(!ignoreLastModified) {
 			if(!ObjectUtils.areObjectsEqual(this.modtime, other.modtime))
 				return false;
 		}
 		
 		if(!ObjectUtils.areObjectsEqual(this.owner, other.owner))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.part, other.part))
 			return false;
 		
 		if(!ObjectUtils.areObjectsEqual(this.type, other.type))
 			return false;
 
 		return true;
 	}
 
 	
 	@Override
 	public String toString()
 	{
 		StringBuffer sb = new StringBuffer();
 		sb.append("part=").append(part);
 		sb.append(",type=").append(type);
 		sb.append(",entryPath=").append(entryPath);
 		sb.append(",entryPathSource=").append(entryPathSource);
 		sb.append(",fileClass=").append(entryClass);
 		sb.append(",major=").append(major);
 		sb.append(",minor=").append(minor);
 		sb.append(",mode=").append(mode);
 		sb.append(",owner=").append(owner);
 		sb.append(",group=").append(group);
 		return sb.toString();
 	}
 	
 }