package net.sf.jpkgmk.prototype;
   
   import java.io.File;
   import java.io.IOException;
   import java.security.NoSuchAlgorithmException;
   import java.util.Arrays;
   
   import net.sf.jpkgmk.PackageException;
   import net.sf.jpkgmk.pkgmap.PkgMapEntry;
  import net.sf.jpkgmk.pkgmap.PkgMapEntryFile;
  import net.sf.jpkgmk.pkgmap.PkgMapEntryType;
  import net.sf.jpkgmk.util.ChecksumUtil;
  import net.sf.jpkgmk.util.FileUtil;
  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;
  
  /**
   * @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 PrototypeEntryFile extends AbstractPrototypeEntry {
  
  	private Log logger = LogFactory.getLog(PrototypeEntryFile.class);
  	
  	/**
  	 * Constructor taking the mandatory arguments to create a prototype file entry
  	 * @param entryPath
  	 */
  	public PrototypeEntryFile(String entryPath)
  	{
  		this(null, null, entryPath, null, null, null, null, null);
  	}
  
  	/**
  	 * Full constructor taking all arguments supported for this entry type
  	 * @param fileClass
  	 * @param entryPath path to the file or directory
  	 * @param entryPathSource the target path in that this file should have in the package
  	 * @param perm
  	 * @param owner
  	 * @param group
  	 */
  	public PrototypeEntryFile(Integer part, String fileClass, String entryPath, String entryPathSource, String perm, String owner, String group, PrototypeEntryCommandDefault entryCommandDefault)
  	{
  		this(part, PrototypeEntryType.F, fileClass, entryPath, entryPathSource, perm, owner, group, entryCommandDefault);
  	}
  	
  	/**
  	 * Full constructor taking all arguments supported for this entry type
  	 * @param part
  	 * @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 perm
  	 * @param owner
  	 * @param group
  	 */
  	protected PrototypeEntryFile(Integer part, PrototypeEntryType type, String fileClass, String entryPath, String entryPathSource, String perm, String owner, String group, PrototypeEntryCommandDefault entryCommandDefault)
  	{
  		super(part, type, fileClass, entryPath, entryPathSource, perm, owner, group, entryCommandDefault);
  		
  		validate();
  	}
  
  
  	private void validate() {
  		// Mandatory parameter check
  		if(getEntryPath() == null) {
  			throw new NullPointerException("The parameter 'entryPath' must not be null");
  		}
  
  //		if(getMode() == null) {
  //			throw new NullPointerException("The parameter 'mode' must not be null");
  //		}
  //		if(getOwner() == null) {
  //			throw new NullPointerException("The parameter 'owner' must not be null");
  //		}
  //		if(getGroup() == null) {
  //			throw new NullPointerException("The parameter 'group' must not be null");
  //		}
  	}
  
  	
  	@Override
  	protected void create(File targetDir, String entryPathExpanded,
  			String entryPathSourceExpanded) throws IOException {
  
  		File target = buildAbsolutePath(targetDir, entryPathExpanded);
  		
  		// the entry path must be in the target dir
  		if(!FileUtil.isSubdir(target, targetDir)) {
  			throw new IllegalStateException("The target file " + target + " must be in the target dir '" + targetDir + "'");
  		}
  
 		File sourceFile;
 		if(entryPathSourceExpanded != null) {
 			logger.debug("Using the entryPathSource '" + entryPathSourceExpanded + "' for copying source file(s) into target directory");
 			sourceFile = new File(entryPathSourceExpanded);
 //			sourceFile = buildAbsolutePath(workingDir, entryPathSourceExpanded);
 		}
 		else {
 			logger.debug("Using the entryPath '" + entryPathExpanded + "' for copying source file(s) into target directory - no explicit source path available");
 			sourceFile = new File(entryPathExpanded);
 //			sourceFile = buildAbsolutePath(workingDir, entryPathExpanded);
 		}
 		
 		FileUtil.copyFile(sourceFile, target);
 
 //		File target = resolveTarget(targetDir);
 //		
 //		// the entry path must be in the target dir
 //		if(!FileUtil.isSubdir(target, targetDir)) {
 //			throw new IllegalStateException("The entryPath " + getEntryPath() + " must be in the target dir '" + targetDir + "'");
 //		}
 //
 //		File sourceFile;
 //		if(this.getEntryPathSource() != null) {
 //			sourceFile = new File(this.getEntryPathSource());
 ////			sourceFile = new File(targetDir, this.entryPathSource);
 //		}
 //		else {
 //			sourceFile = target;
 //		}
 //		FileUtil.copyFile(sourceFile, target);
 	}
 
 
 	@Override
 	protected PkgMapEntry createPkgMapEntry(Integer part,
 			PkgMapEntryType resultType, String entryClass, String entryPath, String entryPathSource,
 			Integer major, Integer minor, String mode, String owner, String group, File targetDir) {
 		PkgMapEntryFile pkgMapEntry = new PkgMapEntryFile(part, resultType, entryClass, entryPath, mode, owner, group);
 		
 		File target = buildAbsolutePath(targetDir, entryPath);
 		if(!target.exists()) {
 			throw new PackageException("The target file '" + target + "' does not exist. Cannot create PkgMapEntry.");
 		}
 		pkgMapEntry.setFilesize(getFileSize(target));
 		pkgMapEntry.setChecksum(getChecksum(target));
 		pkgMapEntry.setModtime(getLastModifiedTime(target));
 		return pkgMapEntry;
 	}
 	
 	/**
 	 * Append file size (not specified for named pipes, special devices, directories or linked files)
 	 * @param filePath
 	 * @return Returns the file size. If this type has no file size null is returned.
 	 */
 	public Long getFileSize(File filePath) {
 		if(filePath == null) {
 			throw new NullPointerException("The parameter 'filePath' must not be null");
 		}
 		
 		return Long.valueOf(filePath.length());
 	}
 	
 	/**
 	 * This field is not specified for named pipes, special devices, directories, or linked files.
 	 * @param filePath
 	 * @return
 	 */
 	public Long getChecksum(File filePath) {
 		if(filePath == null) {
 			throw new NullPointerException("The parameter 'filePath' must not be null");
 		}
 
 		try {
 			return Long.valueOf(ChecksumUtil.createUnixCksum(filePath));
 		} catch (NoSuchAlgorithmException e) {
 			throw new PackageException("Exception while computing MD5 checksum.", e);
 		} catch (IOException e) {
 			throw new PackageException("Exception while computing MD5 checksum.", e);
 		}
 	}
 	
 	public Long getLastModifiedTime(File filePath) {
 		if(filePath == null) {
 			throw new NullPointerException("The parameter 'filePath' must not be null");
 		}
 
 		return Long.valueOf(filePath.lastModified());
 	}
 	
 	
 	/**
 	 * Parser to create a prototype file object from a string array
 	 */
 	public static class PrototypeEntryFileParser extends AbstractPrototypeEntryParser implements PrototypeEntryParser
 	{
 
 		public PrototypeEntryFileParser()
 		{
 			super();
 		}
 		
 		@Override
 		protected PrototypeEntry parseItems(String[] items, Integer part, PrototypeEntryType type, int currentIndex, PrototypeEntryCommandDefault entryCommandDefault)
 		{
 			
 			if(items.length < 3) {
 				throw new IllegalArgumentException("The given array must contain at least 3 items to be a valid file: " + Arrays.asList(items));
 			}
 
 			String fileClass = items[currentIndex++];
 			String path = items[currentIndex++];
 			
 			KeyValuePair keyValue = StringUtil.resolveKeyValue(path);
 			String entryPath = keyValue.getKey();
 			String entryPathSource = keyValue.getValue();
 			
 			String mode = getArrayValue(items, currentIndex++);
 			String owner = getArrayValue(items, currentIndex++);
 			String group = getArrayValue(items, currentIndex++);
 
 			return createEntry(part, fileClass, entryPath, entryPathSource, mode, owner, group, entryCommandDefault);
 		}
 
 		protected PrototypeEntry createEntry(Integer part, String fileClass, String entryPath,
 				String entryPathSource, String mode, String owner, String group, PrototypeEntryCommandDefault entryCommandDefault) {
 			PrototypeEntry entry = new PrototypeEntryFile(part, fileClass, entryPath, entryPathSource, mode, owner, group, entryCommandDefault);
 			return entry;
 		}
 
 	}
 
 
 }