package org.musicontroller.service;
   
   import java.io.File;
   
   import org.musicontroller.core.MusicDirProvider;
   import org.musicontroller.importer.ImporterException;
   import org.musicontroller.importer.MusicArchiveEntryBean;
   import org.varienaja.util.FileOperations;
   
  /**
   * This class implements utilities for (MP3) file
   * manipulation. This class knows about the conventions
   * MusiController uses for the storage of its MP3 files.
   * 
   * @author drexler
   * @version $Id: FileUtils.java,v 1.1 2010/03/16 18:55:42 varienaja Exp $
   */
  public class FileUtils implements MusicDirProvider {
  
  	/**
  	 * This injected property defines what the baselocation of all files is.
  	 * stored.
  	 */
  	private static String _basedir;
  
  	/**
  	 * No arguments constructor.
  	 */
  	public FileUtils() {
  		_basedir = null;
  	}
  	
  	/**
  	 * Creates a directory if it didn't exist
  	 * @param dir The directory to create.
  	 * @throws Exception, if the directory didn't exist and could not be created.
  	 */
  	private void createDir(String dir) throws Exception {
  		File test = new File(dir);
  		if (!test.exists()) {
  			if (!test.mkdirs()) {
  				throw new Exception("Could not create MusiController-directory: "+dir);
  			}
  		}
  	}
  	
  	/**
  	 * Setter for the music archive directory.
  	 * @param basedir The base directory
  	 */
  	public void setBasedir(String basedir) throws Exception {
  		_basedir = basedir;
  		
  		//Test existence of all directories, and try to create
  		createDir(_basedir);
  		createDir(getArchivedir());
  		createDir(getMyAccountdir());
  		createDir(getCoverdir());
  		createDir(getReviewdir());
  		createDir(getIndexdir());
  		createDir(getUploaddir());
  		createDir(getUnpackdir());
  	}
  	
  	/**
  	 * Getter for the music archive directory. Returns the set basedir
  	 * with "/songs" appended. If the basedir is null then just returns
  	 * "songs".
  	 * 
  	 * @return The music archive directory.
  	 */
  	public static String getArchivedir() {
  		return _basedir==null ? "songs" : _basedir+File.separator+"songs";
  	}
  	
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.core.MusicDirProvider#getMusicDirectory()
  	 */
  	public String getMusicDirectory() {
  		return getArchivedir();
  	}
  	
  	/**
  	 * Getter for the directory containing the myAccount settings.
  	 * @return The directory containing the myaccount settings.
  	 */
  	public static String getMyAccountdir() {
  		return _basedir+File.separator+"myAccount";
  	}
  	
  	/**
  	 * Getter for the directory containing the coverart.
  	 * @return The directory containing the coverart.
  	 */
  	public static String getCoverdir() {
  		return _basedir+File.separator+"covers";
  	}
  	
 	/**
 	 * Getter for the directory containing the reviews.
 	 * @return The directory containing the reviews.
 	 */
 	public static String getReviewdir() {
 		return _basedir+File.separator+"reviews";
 	}
 	
 	/**
 	 * Getter for the directory containing the lucene-index.
 	 * @return The directory containing the lucene-index.
 	 */
 	public static String getIndexdir() {
 		return _basedir+File.separator+"index";
 	}
 	
 	public static String getUploaddir() {
 		return _basedir+File.separator+"upload";
 	}
 
 	/**
 	 * Returns the location of the directory where uploaded music
 	 * archives get unpacked. The returned name does not end in a
 	 * file separator character.
 	 * @return
 	 */
 	public static String getUnpackdir() {
 		return _basedir+File.separator+"unpack";
 	}
 	
 	/**
 	 * Determine the storage hash (directory) name where this MP3 file
 	 * will be written to. This method returns the first letter of the
 	 * band name as the storage hash name. This is consistent with older
 	 * versions of MusiController.
 	 * @param song The music archive entry to find the storage hash name for.
 	 * @return The name of the storage hash (directory) where the song should
 	 *         be written to, or "_" if the song has a null or empty bandname.
 	 */
 	protected static String getStorageHashname(MusicArchiveEntryBean song) {
 		if(song==null) {
 			return "_";
 		}
 		String bandname = song.getBandName();
 		if(bandname==null||bandname.length()<1) {
 			return "_";
 		}
 		bandname = bandname.trim();
 		if(bandname.isEmpty()) {
 			throw new IllegalArgumentException("The songs band name contains no non whitespace characters.");
 		}
 		return FileOperations.translateIllegalFileChars(bandname).substring(0,1);
 	}
 
 	/**
 	 * Returns the location of the MP3 file of a new song.
 	 * The location is splitted into three parts:
 	 * <ol>
 	 * <li>Songs-directory of MusiController</li>
 	 * <li>Relative part of the filename for this song</li>
 	 * <li>filename</li>
 	 * </ol>
 	 * @param song
 	 * @return The location for the new Song. In order to use it, join them
 	 * together with File.separator-characters.
 	 * @throws ImporterException If the song is null.
 	 */
 	public static String[] getNewSongDestination(MusicArchiveEntryBean song) { 
 		if (song==null) {
 			throw new IllegalArgumentException("Song must not be null.");
 		}
 		if(song.getBandName()==null) {
 			throw new IllegalArgumentException("Bandname must not be null.");
 		}
 		if(song.getSongName()==null) {
 			throw new IllegalArgumentException("Songname must not be null.");
 		}
 		if(song.getBandName().trim().length()<1) {
 			throw new IllegalArgumentException("Bandname must not be empty.");
 		}
 		if(song.getSongName().trim().length()<1) {
 			throw new IllegalArgumentException("Songname must not be null.");
 		}
 		
 		String[] result = new String[3];
 		result[0] = getArchivedir();
 		result[1] = getStorageHashname(song) + File.separator + FileOperations.translateIllegalFileChars(song.getBandName());
 		String tmp = FileOperations.translateIllegalFileChars(song.getSongName());
 		result[2] = generateUniqueFilename(result[0] + File.separator + result[1], tmp, ".mp3");
 		
 		return result;
 	}
 	
 	/**
 	 * Generates a unique filename. When a intended filename already exists, new
 	 * names are generated with (1), (2), ... in the filename.
 	 * @param path The path
 	 * @param name The filename (without extension)
 	 * @param extension The extension
 	 * @return The name + extension (but not path) which is unique.
 	 */
 	private static String generateUniqueFilename(String path, String name, String extension) {
 		String testname = name + extension;
 		File testFile = new File(path + File.separator + testname);
 		int counter=1;
 		while(testFile.exists()) {
 			testname = name + " (" + String.valueOf(counter) + ")" + extension;
 			testFile = new File(path + File.separator + testname);
 			counter++;
 		}
 		return testname;
 	}
 	
 }