package net.sf.jpkgmk.prototype;
   
   
   import java.io.File;
   import java.io.FileNotFoundException;
   
   import net.sf.jpkgmk.AbstractLineProvider;
   import net.sf.jpkgmk.ParseException;
   import net.sf.jpkgmk.util.VariableResolver;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * The prototype entry command
   * 
   * @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 PrototypeEntryCommand extends AbstractLineProvider implements PrototypeEntry 
  {
  	private PrototypeEntryType type = PrototypeEntryType.COMMAND;
  	private CommandType commandType;
  	/**
  	 * Defines whether or not the "!" symbol is separated with a whitespace from the rest of the line.
  	 * Is needed to create the line as it was originally when parsing an existing prototype file.
  	 */
  	private boolean hasWhitespaceSeparator = true;
  
  	private Log log = LogFactory.getLog(PrototypeEntryCommand.class);
  	
  	
  	/**
  	 * @param commandType
  	 */
  	public PrototypeEntryCommand(CommandType commandType)
  	{
  		if(commandType == null) {
  			throw new NullPointerException("The parameter 'commandType' must not be null");
  		}
  		this.commandType = commandType;
  	}
  
  	/**
  	 * @return
  	 */
  	public boolean isHasWhitespaceSeparator() {
  		return hasWhitespaceSeparator;
  	}
  
  	/**
  	 * @param hasWhitespaceSeparator If the "!" is separated by a whitespace from the rest of the line or not.
  	 */
  	public void setHasWhitespaceSeparator(boolean hasWhitespaceSeparator) {
  		this.hasWhitespaceSeparator = hasWhitespaceSeparator;
  	}
  
  	/**
  	 * @return Returns the part of the line that is specific for the implementation of the command. This includes everything
  	 * after the '! cmdType' string
  	 */
  	protected abstract String getCommandLinePart();
  	
  	
  	/**
  	 * @see net.sf.jpkgmk.LineProvider#getLine()
  	 */
  	public String getLine() {
  		log.debug("<Entering> getLine()");
  			
  		StringBuffer sb = new StringBuffer();
  		sb.append(this.type.getKey());
  		if(this.hasWhitespaceSeparator) {
  			sb.append(" ");
  		}
  		
  		if(this.commandType.getIdName() != null) {
  			// Add command type and blank
  			sb.append(this.commandType.getIdName());
  			// Append separator
  			sb.append(" ");
  		}
  		
  		String commandLinePart = getCommandLinePart();
  		sb.append(commandLinePart);
  		
  		return sb.toString();
  	}
  
  	public PrototypeEntryType getType() {
  		return this.type;
  	}
  
  
      @Override
  	public String toString() {
  		StringBuffer sb = new StringBuffer();
 		sb.append(this.getClass().getName()).append("[");
 		sb.append("type=").append(this.type);
 		sb.append(",commandType=").append(this.commandType);
 		sb.append(",hasWhitespaceSeparater=").append(this.hasWhitespaceSeparator);
 		sb.append("]");
 		return sb.toString();
 	}
 	
 	
 	
 	/**
 	 * Class for parsing a prototype 'command' line
 	 * 
 	 */
 	public static class PrototypeEntryCommandParser implements PrototypeEntryParser
 	{
 
 		public PrototypeEntry parse(String line, PrototypeEntryCommandDefault entryCommandDefault) 
 		{
 			if (line == null) {
 				throw new NullPointerException(
 						"The parameter 'line' must not be null");
 			}
 			
 			String[] items = PrototypeParser.getLineItems(line);
 			// After the exclamation mark the whitespace is not required, e.g. "!PROJDIR=/usr/proj" is a valid command
 			if(items.length <= 0) {
 				throw new ParseException("Invalid line: " + line);
 			}
 			
 			String firstItem = items[0];
 			
 			boolean hasWhitespaceSeparator;
 			// Build the parameters of the command excluding the prefixed "!"
 			String[] commandParams = null;
 			if(firstItem.equals(PrototypeEntryType.COMMAND.getKey())) {
 				commandParams = new String[items.length-1];
 				System.arraycopy(items, 1, commandParams, 0, commandParams.length);
 				hasWhitespaceSeparator=true;
 			}
 			// No whitespace between the exclamation mark and the command key
 			else if(firstItem.startsWith(PrototypeEntryType.COMMAND.getKey())) {
 				// We have to cut of the starting exclamation mark in front of the first string
 				commandParams = new String[items.length];
 				commandParams[0] = firstItem.substring(1);
 				System.arraycopy(items, 1, commandParams, 1, commandParams.length-1);
 				hasWhitespaceSeparator=false;
 			}
 			else {
 				throw new IllegalArgumentException("The line '" + line + "' must start with the character '" + PrototypeEntryType.COMMAND.getKey() + "'");
 			}
 			
 			PrototypeEntryCommand entryCommand = this.parse(commandParams);
 			// To ensure that the "getLine()" method returns the same format of the line as the original has
 			entryCommand.setHasWhitespaceSeparator(hasWhitespaceSeparator);
 			return entryCommand;
 		}
 
 		
 		/**
 		 * @param commandParams
 		 * @return
 		 */
 		private PrototypeEntryCommand parse(String[] commandParams) 
 		{
 			if(commandParams.length <= 0) {
 				throw new ParseException("The given command parameter array must not be empty!");
 			}
 			
 			// First get the type of command
 			CommandType commandType = CommandType.findTypeByName(commandParams[0]);
 			PrototypeEntryCommand entry = commandType.getParser().parse(commandParams);
 			return entry;
 		}
 		
 	}
 
 	/**
 	 * Resolves the file for the given path and expands potential variables within the string path. If the file
 	 * cannot be found, a {@link FileNotFoundException} is thrown.
 	 * @param filePath
 	 * @param variableResolver
 	 * @return
 	 * @throws FileNotFoundException
 	 */
 	protected File resolveFile(String filePath, VariableResolver variableResolver) throws FileNotFoundException {
 		String expandedPath = variableResolver.expand(filePath);
 		File file = new File(expandedPath);
 		if(!file.exists()) {
 			throw new FileNotFoundException("The file " + file.getAbsolutePath() + " does not exist.");
 		}
 		return file;
 	}
 	
 	
 }