package net.sf.jpkgmk.prototype;
   
   import net.sf.jpkgmk.pkgmap.PkgMapEntryType;
   import net.sf.jpkgmk.prototype.PrototypeEntryBlockDevice.PrototypeEntryBlockDeviceParser;
   import net.sf.jpkgmk.prototype.PrototypeEntryCharacterDevice.PrototypeEntryCharacterDeviceParser;
   import net.sf.jpkgmk.prototype.PrototypeEntryCommand.PrototypeEntryCommandParser;
   import net.sf.jpkgmk.prototype.PrototypeEntryComment.PrototypeEntryCommentParser;
   import net.sf.jpkgmk.prototype.PrototypeEntryDirectory.PrototypeEntryDirectoryParser;
   import net.sf.jpkgmk.prototype.PrototypeEntryDirectoryExclusive.PrototypeEntryDirectoryExclusiveParser;
  import net.sf.jpkgmk.prototype.PrototypeEntryFile.PrototypeEntryFileParser;
  import net.sf.jpkgmk.prototype.PrototypeEntryFileEditable.PrototypeEntryFileEditableParser;
  import net.sf.jpkgmk.prototype.PrototypeEntryFileVolatile.PrototypeEntryFileVolatileParser;
  import net.sf.jpkgmk.prototype.PrototypeEntryInfo.PrototypeEntryInfoParser;
  import net.sf.jpkgmk.prototype.PrototypeEntryLink.PrototypeEntryLinkParser;
  import net.sf.jpkgmk.prototype.PrototypeEntryPipe.PrototypeEntryPipeParser;
  import net.sf.jpkgmk.prototype.PrototypeEntrySymbolicLink.PrototypeEntrySymbolicLinkParser;
  import net.sf.jpkgmk.util.StringUtil;
  
  
  /**
   * Typesafe enumeration for the filetypes that can be used for prototype lines
   * @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 PrototypeEntryType
  {
  	public static final PrototypeEntryType COMMAND = new PrototypeEntryType("!", null, new PrototypeEntryCommandParser(),
  			"COMMAND - An exclamation point (!) at the beginning of a line indicates that the line contains a command. " +
  			"These commands are used to incorporate files in other directories, to locate objects on a host machine, and to set permanent defaults.") {
  	    @Override
  		public boolean matches(String key) {
  			// A command can start with exclamationmark followed by the command directly without whitespace, e.g. "!PROJDIR=/root/tut/gut"
  			if(key.startsWith(this.getKey())) {
  				return true;
  			}
  			return false;
  		}
  	};
  	
  	public static final PrototypeEntryType COMMENT = new PrototypeEntryType("#", PkgMapEntryType.COMMENT, new PrototypeEntryCommentParser(),
  			"COMMENT - Comment lines begin with a '#' and are ignored.") {
  	    @Override
  		public boolean matches(String key) {
  			// A comment can start with '#' followed by the comment directly without whitespace, e.g. "#My beautiful comment"
  			if(key.startsWith(this.getKey())) {
  				return true;
  			}
  			return false;
  		}
  	};
  	
  	public static final PrototypeEntryType B = new PrototypeEntryType("b", PkgMapEntryType.BLOCK_SPECIAL, new PrototypeEntryBlockDeviceParser(), "block special device");
  	public static final PrototypeEntryType C = new PrototypeEntryType("c", PkgMapEntryType.CHARACTER_SPECIAL, new PrototypeEntryCharacterDeviceParser(), "character special device");
  	public static final PrototypeEntryType D = new PrototypeEntryType("d", PkgMapEntryType.DIRECTORY, new PrototypeEntryDirectoryParser(), "directory");
  	public static final PrototypeEntryType E = new PrototypeEntryType("e", PkgMapEntryType.FILE_EDITABLE, new PrototypeEntryFileEditableParser(), "a file to be edited upon installation or removal (may be shared by several packages)");
  	public static final PrototypeEntryType F = new PrototypeEntryType("f", PkgMapEntryType.FILE, new PrototypeEntryFileParser(), "a standard executable or data file");
  	public static final PrototypeEntryType I = new PrototypeEntryType("i", PkgMapEntryType.FILE_INFO, new PrototypeEntryInfoParser(), "installation script or information file");
  	public static final PrototypeEntryType L = new PrototypeEntryType("l", PkgMapEntryType.FILE_LINKED, new PrototypeEntryLinkParser(), "linked file");
  	public static final PrototypeEntryType P = new PrototypeEntryType("p", PkgMapEntryType.PIPE, new PrototypeEntryPipeParser(), "named pipe");
  	public static final PrototypeEntryType S = new PrototypeEntryType("s", PkgMapEntryType.SYMBOLIC_LINK, new PrototypeEntrySymbolicLinkParser(), "symbolic link");
  	public static final PrototypeEntryType V = new PrototypeEntryType("v", PkgMapEntryType.FILE_VOLATILE, new PrototypeEntryFileVolatileParser(), "volatile file (one whose contents are expected to change, like a log file)");
  	public static final PrototypeEntryType X = new PrototypeEntryType("x", PkgMapEntryType.DIRECTORY_EXCLUSIVE, new PrototypeEntryDirectoryExclusiveParser(), "an exclusive directory accessible only by this package");
  	
      public static PrototypeEntryType[] VALUES = new PrototypeEntryType[] {
      	COMMAND,
      	COMMENT,
          B, 
          C, 
          D,
          E,
          F,
          I,
          L,
          P,
          S,
          V,
          X
      };
  
  	private String key;
  	private String description;
  	/**
  	 * The corresponding entry type for the pkgmap file.
  	 */
  	private PkgMapEntryType pkgMapEntryType;
  	/**
  	 * The parser that is used to create a PrototypeEntry object from a input line
  	 */
  	private PrototypeEntryParser parser;
  	
  	/**
  	 * Private constructor
  	 * @param key
  	 * @param pkgMapEntryType
  	 * @param parser
  	 * @param description
  	 */
 	private PrototypeEntryType(String key, PkgMapEntryType pkgMapEntryType, PrototypeEntryParser parser, String description)
 	{
 		if(key==null) {
 			throw new NullPointerException("The parameter 'id' must not be null");
 		}
 		this.key=key;
 		this.pkgMapEntryType=pkgMapEntryType;
 		this.parser=parser;
 		this.description=description;
 	}
 	
 	public PkgMapEntryType getPkgMapEntryType() 
 	{
 		return this.pkgMapEntryType;
 	}
 
 	/**
 	 * @return Returns the identifier for this entry type, for example a "!" for a command.
 	 */
 	public String getKey() {
 		return key;
 	}
 
 	public String getDescription() {
 		return description;
 	}
 
 	public PrototypeEntryParser getParser() 
 	{
 		return this.parser;
 	}
 
 	public boolean matches(String key) {
 		return this.key.equals(key);
 	}
 	
     @Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + key.hashCode();
 		return result;
 	}
 
     @Override
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		if (this.getClass() != obj.getClass())
 			return false;
 		final PrototypeEntryType other = (PrototypeEntryType) obj;
 		if (!key.equals(other.key))
 			return false;
 		return true;
 	}
 
     @Override
 	public String toString() {
 		StringBuffer sb = new StringBuffer();
 		sb.append(this.getClass().getName()).append("[");
 		sb.append("key=").append(key);
 		sb.append(",pkgMapEntryType=").append(pkgMapEntryType);
 		sb.append(",parser=").append(parser);
 		sb.append(",description=").append(StringUtil.truncateToMaxLength(this.description, 20));
 		sb.append("]");
 		return sb.toString();
 	}
 	
     public static PrototypeEntryType findType(String key) {
         for(int i=0; i<VALUES.length; i++) {
             if(VALUES[i].matches(key))
                 return VALUES[i];
         }
         // The type was not found. Return null.
         return null;
     }
 
 
 }