package net.sf.jpkgmk.prototype;
   
   import java.util.Arrays;
   
   import net.sf.jpkgmk.util.StringUtil;
   import net.sf.jpkgmk.util.StringUtil.KeyValuePair;
   
   /**
    * Typesafe enumeration CommandType
   * @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 CommandType implements java.io.Serializable {
      /**
  	 * 
  	 */
  	private static final long serialVersionUID = 1L;
  
  	public static final CommandType SEARCH = new CommandType(1, "search", new CommandTypeSearchParser(), "search - Specifies a list of directories (separated by white space) to search for when looking for file contents on the host  machine. The base  name  of the path field is appended to each directory in the ordered list until the file is located. Searches are not recursive.");
      public static final CommandType INCLUDE = new CommandType(2, "include", new CommandTypeIncludeParser(), "include - Specifies a pathname which points to another prototype file to include. Note that search requests do not span include files.");
      public static final CommandType DEFAULT = new CommandType(3, "default", new CommandTypeDefaultParser(), "default - Specifies a list of attributes (mode, owner, and  group) to be used by default if attribute information is not provided for  prototype entries which require the information. The defaults do not apply to entries in include prototype files.");
      public static final CommandType PARAM_VALUE = new CommandType(4, null, new CommandTypeParamValueParser(), "param=value - Places the indicated parameter in the current environment. Spans to subsequent included prototype files.");
      public static CommandType[] VALUES = new CommandType[] {
          SEARCH, 
          INCLUDE, 
          DEFAULT, 
          PARAM_VALUE
      };
  
      private int id;
      private String idName;
      private String description;
      private CommandTypeParser parser;
  
      
      private CommandType(int id, String idName, CommandTypeParser typeParser, String description) {
          this.id = id;
          this.idName = idName;
          this.parser = typeParser;
          this.description = description;
      }
  
      /**
       * @return Returns the unique name of this command type to be used for writing it into the prototype file
       */
      public String getIdName()
      {
      	return this.idName;
      }
      
      /**
       * Returns true if the given command name matches this command.
       * @param commandName
       * @return
       */
      public boolean matches(String commandName)
      {
      	if(this.idName != null) {
      		return this.idName.equals(commandName);
      	}
      	else {
      		return (commandName == null);
      	}
      }
      
  	public CommandTypeParser getParser() {
  		return this.parser;
  	}
  
      
      /**
       * Resolves the command type by the surrogate id
       * @param searchedId
       * @return Returns the command for the given ID or null if it was not found.
       */
      public static CommandType findType(int searchedId) {
          for(int i=0; i<VALUES.length; i++) {
              if(VALUES[i].id == searchedId)
                  return VALUES[i];
          }
          // The type was not found. Return null.
          return null;
      }
  
      /**
       * Resolves the command type by the given name. If no command key matches we
       * assume that it is a "Param=value" command and return {@link #PARAM_VALUE}.
       * @param commandName The name of the command to be found, e.g. "search"
       * @return The found command or {@link #PARAM_VALUE} if it could not be resolved.
       */
      public static CommandType findTypeByName(String commandName) {
          for(int i=0; i<VALUES.length; i++) {
              if(VALUES[i].matches(commandName)) {
              	return VALUES[i];
              }
          }
          // The type was not found. It must be a "param=value" command.
         return CommandType.PARAM_VALUE;
     }
 
     // See http://www.javaworld.com/javaworld/javatips/jw-javatip122.html?page=2 for reasons why to implement readResolve
     private Object readResolve() throws java.io.ObjectStreamException {
         return findType(this.id);
     }
 
 	@Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + id;
 		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 CommandType other = (CommandType) obj;
 		if (id != other.id)
 			return false;
 		return true;
 	}
 
     @Override
 	public String toString() {
     	StringBuffer sb = new StringBuffer();
     	sb.append(this.getClass().getName()).append("[");
     	sb.append("id=").append(id);
     	sb.append(",idName=").append(idName);
     	sb.append(",description=").append(StringUtil.truncateToMaxLength(this.description, 20));
     	sb.append("]");
     	return sb.toString();
     }
 
     
     
     
     public static interface CommandTypeParser
     {
     	public PrototypeEntryCommand parse(String[]commandTypeEntries);
     }
     
     public static class CommandTypeSearchParser implements CommandTypeParser
     {
 
 		public PrototypeEntryCommand parse(String[] commandTypeEntries) {
 			String searchString = commandTypeEntries[0];
 			// Just a sanity check
 			if(!CommandType.SEARCH.matches(searchString)) {
 				throw new IllegalArgumentException("The given array is wrong. First element '" + searchString + "' must be a '" + CommandType.SEARCH + "'. Array=" + Arrays.asList(commandTypeEntries));
 			}
 
 			String[] searchPaths = new String[commandTypeEntries.length-1];
 			System.arraycopy(commandTypeEntries, 1, searchPaths, 0, searchPaths.length);
 			
 			PrototypeEntryCommand prototypeEntry = new PrototypeEntryCommandSearch(searchPaths);
 			return prototypeEntry;
 		}
     	
     }
     
     public static class CommandTypeIncludeParser implements CommandTypeParser
     {
 
 		public PrototypeEntryCommand parse(String[] commandTypeEntries) {
 			String includeString = commandTypeEntries[0];
 			// Just a sanity check
 			if(!CommandType.INCLUDE.matches(includeString)) {
 				throw new IllegalArgumentException("The given array is wrong. First element '" + includeString + "' must be a '" + CommandType.INCLUDE + "'. Array=" + Arrays.asList(commandTypeEntries));
 			}
 
 			// Merge all entries again, but exclude the first one which is the "include" string
 			String includePath = StringUtil.createString(commandTypeEntries, 1, PrototypeParser.DEFAULT_LINE_DELIMITER);
 			
 			PrototypeEntryCommand entry = new PrototypeEntryCommandInclude(includePath);
 			return entry;
 		}
     	
     }
 
     public static class CommandTypeDefaultParser implements CommandTypeParser
     {
 
 		public PrototypeEntryCommand parse(String[] commandTypeEntries) {
 			String defaultString = commandTypeEntries[0];
 			// Just a sanity check
 			if(!CommandType.DEFAULT.matches(defaultString)) {
 				throw new IllegalArgumentException("The given array is wrong. First element '" + defaultString + "' must be a '" + CommandType.DEFAULT + "'. Array=" + Arrays.asList(commandTypeEntries));
 			}
 			
 			String mode = commandTypeEntries[1];
 			String owner = commandTypeEntries[2];
 			String group = commandTypeEntries[3];
 			PrototypeEntryCommand entry = new PrototypeEntryCommandDefault(mode, owner, group);
 			return entry;
 		}
     	
     }
 
     public static class CommandTypeParamValueParser implements CommandTypeParser
     {
 		public PrototypeEntryCommand parse(String[] commandTypeEntries) {
 			
 			// Merge all entries again, but exclude the first one which is the "include" string
 			String paramValueString = StringUtil.createString(commandTypeEntries, PrototypeParser.DEFAULT_LINE_DELIMITER);
 
 			KeyValuePair keyValue = StringUtil.resolveKeyValue(paramValueString);
 			String entryPath = keyValue.getKey();
 			String entryPathSource = keyValue.getValue();
 			
 			PrototypeEntryCommand command = new PrototypeEntryCommandVariable(entryPath, entryPathSource);
 			return command;
 		}
     	
     }
 
 }