package org.musicontroller.core.jobs;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.ObjectInputStream;
   import java.io.ObjectOutputStream;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.log4j.Logger;
  import org.musicontroller.importer.ImporterException;
  import org.musicontroller.importer.MP3InspectorJID3Lib;
  import org.musicontroller.importer.MediafileInspector;
  import org.musicontroller.importer.MusicArchiveBean;
  import org.musicontroller.importer.MusicArchiveEntryBean;
  import org.musicontroller.service.FileUtils;
  import org.varienaja.util.FileOperations;
  import org.varienaja.util.wikipedia.WikipediaSearcher;
  
  /**
   * <p>
   * This Job is responsible for extracting and finding metadata from music-files. 
   * Job that must be called periodically. When this Job is run, look in the
   * Unpack-directory for work to do. When there were files to be inspected, they
   * are inspected one by one. Finally, a new MusicArchiveBean is added to the
   * internal collection of beans in this class.</p>
   * 
   * <p>Every once in a while, this Collection should be read and processed.</p>
   * 
   * TODO The 'unpack'-directory should be periodically scanned. Empty directories can be deleted.
   * 
   * @author Varienaja
   * @version $Id: MetadataExtractJob.java,v 1.1 2010/03/16 18:55:42 varienaja Exp $
   */
  public class MetadataExtractJob {
  	private static final Logger log = Logger.getLogger(MetadataExtractJob.class);
  
  	private static final String INSPECTED = "inspected";
  	
  	/**
  	 * All MusicArchives that have been inspected.
  	 * This data is persistent.
  	 */
  	private static List<MusicArchiveBean> _inspected;
  
  	/**
  	 * @return The List of inspected songs in the form of MusicArchiveBeans.
  	 */
  	public static synchronized List<MusicArchiveBean> getMusicArchiveBeanList() {
  		return _inspected;
  	}
  	
  	/**
  	 * Removes a music archive bean from (persistent) storage. All inspected
  	 * music-files are removed too!
  	 * 
  	 * <p>Only directories within the unpack directory can be removed. Path
  	 * specifications containing <tt>..</tt> are forbidden.
  	 * 
  	 * @param archiveBean The archive bean to be removed.
  	 */
  	public static synchronized void removeMusicArchiveBean(MusicArchiveBean archiveBean) throws ImporterException {
  		if (archiveBean==null) return;
  
  		for(MusicArchiveEntryBean entryBean: archiveBean.getEntrySet()) {
  			String filename = entryBean.getEntryName();
  			if(directoryValidForRemoval(filename)) {
  				int sepPos = filename.lastIndexOf(File.separator);
  				if(sepPos>-1) {
  					String dir = filename.substring(0,sepPos);
  					if (FileOperations.deleteDir(new File(dir))) {
  						_inspected.remove(archiveBean);
  						storeInspectedItems();
  					}
  				}
  			}
  		}
  	}
  	
  	/**
  	 * Decides if the directory can be deleted or not. Only subdirectories of the
  	 * MusiController <tt>upload</tt> and <tt>unpack</tt> areas are valid.
  	 * Path specifications containing <tt>..</tt> are forbidden.
  	 * 
  	 * @param dir The name of the directory to test.
  	 * @return True if the directory can be deleted, false otherwise.
  	 */
  	private static boolean directoryValidForRemoval(String dir) {
  		if(dir==null || dir.length()<1) {
  			return false;
  		}
  		// The directory name should match the full path of the unpack
 		// directory plus a directory name within the unpack directory to be valid.
 		StringBuilder regExpSb = new StringBuilder();
 		regExpSb.append("^");
 		regExpSb.append(FileUtils.getUnpackdir());
 		regExpSb.append(File.separator);
 		regExpSb.append(".+$");
 		String regExp = regExpSb.toString();
 		if(dir.matches(regExp)) {
 			return dir.indexOf("..")<0;
 		}
 		return false;
 	}
 
 	protected static synchronized File getPersistentStorage() {
 		return new File(FileUtils.getIndexdir()+File.separator+"beans.dat");
 	}
 	
 	/**
 	 * Creates a new MetadataExtractJob object. On object-creation, the _inspected-property
 	 * is initialized from persistent storage.
 	 */
 	public MetadataExtractJob() {
 		initInspectedArchives();
 	}
 
 	/**
 	 * Reads already inspected Archives from persistent storage.
 	 */
 	@SuppressWarnings("unchecked")
 	private synchronized void initInspectedArchives() {
 		if (_inspected==null) {
 			_inspected = new LinkedList<MusicArchiveBean>();
 		
 			File storage = getPersistentStorage();
 			if (storage.exists()) {
 				try {
 					ObjectInputStream in = new ObjectInputStream(new FileInputStream(storage));
 					_inspected = (List<MusicArchiveBean>) in.readObject();
 					in.close();
 					log.debug("Recovered "+_inspected.size()+" beans from persistent storage");
 				} catch (FileNotFoundException e) {
 					log.error("Error opening beanstorage: "+e);
 				} catch (IOException e) {
 					log.error("Error reading from beanstorage: "+e);
 				} catch (ClassNotFoundException e) {
 					log.error("Error decoding beanstorage: "+e);
 				}
 			}
 		} //else: already initialized
 	}
 	
 	/**
 	 * Call this method to execute the job: scan for work to do, and work!
 	 * @return The amount of files processed
 	 */
 	public int execute() {
 		int result = 0;
 		File unpack = new File(FileUtils.getUnpackdir());
 		String[] files = unpack.list();
 		if (files!=null) {
 			for (String fileName : files) {
 				if (fileName.startsWith(ImportJob.READY_FOR_INSPECTION)) {
 					String fn = FileUtils.getUnpackdir()+File.separator+fileName;
 					result += inspectDirectory(fn);
 
 					//Rename after inspection
 					File dirFile = new File(fn);
 					String renameddirname = FileOperations.createUniqueFilename(
 							FileUtils.getUnpackdir()+File.separator,INSPECTED);
 					File renameddir = new File(renameddirname);
 					if (dirFile.renameTo(renameddir)) {
 						fn += File.separator; //To make sure we're not renaming false matching files
 						renameddirname += File.separator;
 						
 						//Loop through all Beans, and see that the filesystem-links are adjusted to the new location.
 						for (MusicArchiveBean mab : getMusicArchiveBeanList()) {
 							for (MusicArchiveEntryBean maeb : mab.getEntrySet()) {
 								String entryname = maeb.getEntryName();
 								if (entryname.startsWith(fn)) {
 									// Escape all '(' and ')' chars in the file name.
 									String escapedFileName = fn.replaceAll("\\(", "\\\\(").replaceAll("\\)", "\\\\)");									
 									String replaced = escapedFileName.replaceAll("\\+", "\\\\+");
 									String newName = entryname.replaceFirst(replaced,renameddirname);
 									maeb.setEntryName(newName);
 								}
 							}
 						}
 					} else {
 						log.error("Error while renaming directory: "+fn+" to: "+renameddirname);
 					}
 					storeInspectedItems();
 				}
 			}
 		}
 		
 		return result;
 	}
 	
 	/**
 	 * Inspects a directory recursively. It will try to find metadata for
 	 * all files it finds.
 	 * @param directory The dirctory to process
 	 * @return The number of files inspected
 	 */
 	private int inspectDirectory(String directory) {
 		log.debug("inspection of archive "+directory+" started.");
 		int result = 0;
 		File dirFile = new File(directory);
 		String[] files = dirFile.list();
 		if (files!=null) {
 			MusicArchiveBean archiveBean = new MusicArchiveBean();
 			for (String fileName : files) {
 				if (!fileName.startsWith(".")) {
 					String fullname = directory+File.separator+fileName;
 					File inspect = new File(fullname);
 					if (inspect.isDirectory()) {
 						result += inspectDirectory(fullname);
 					} else {
 						MusicArchiveEntryBean bean = inspectFile(fullname,inspect);
 						if (bean!=null) {
 							archiveBean.addEntry(bean);
 							result++;
 						}
 					}
 				}
 			}
 			
 			if (archiveBean.getEntrySet().size()>0) {
 				String name = guessName(archiveBean);
 				archiveBean.setArchiveName(name);
 				getMusicArchiveBeanList().add(archiveBean);
 			}
 		}
 		log.debug("Inspection of archive "+directory+" finished, found "+result+" tracks.");
 		return result;
 	}
 	
 	/**
 	 * Tries to generate a human-readable name for a music archive. It will 
 	 * return something like "Bandname - Playlistname". If there are several bands
 	 * or several playlists in the music archive, the bandname will be "Various" and
 	 * the playlistname will be "Various". If no information whatsoever could be found,
 	 * the result will be "Unknown".
 	 * @param archiveBean The music archive.
 	 * @return A human-readable name.
 	 */
 	protected String guessName(MusicArchiveBean archiveBean) {
 		String bandname = "Unknown";
 		String albumname = "Unknown";
 		
 		String forbiddenCharacters = "[^ -_a-zA-Z0-9]";
 		
 		Set<String> bands = new HashSet<String>();
 		Set<String> albums = new HashSet<String>();
 		if (archiveBean!=null) {
 			for (MusicArchiveEntryBean entry : archiveBean.getEntrySet()) {
 				// Remove any weird characters from the band name and playlist name.
 				if(entry.getBandName()!=null) {
 					bands.add(entry.getBandName().replaceAll(forbiddenCharacters,""));
 				}
 				if(entry.getPlaylistName()!=null) {
 					albums.add(entry.getPlaylistName().replaceAll(forbiddenCharacters,""));
 				}
 			}
 		}
 		
 		if (bands.size()>0) {
 			if (bands.size()==1) {
 				bandname = bands.iterator().next();
 			} else {
 				bandname = "Various";
 			}
 		}
 		if (albums.size()>0) {
 			if (albums.size()==1) {
 				albumname = albums.iterator().next();
 			} else {
 				albumname = "Various";
 			}
 		}
 				
 		return bandname + " - " + albumname;
 	}
 	
 	/**
 	 * Extracts metadata from a file into a MusicArchiveEntryBean
 	 * @param filename The filename
 	 * @param toInspect The File itself
 	 * @return A MusicArchiveEntryBean containing metadata
 	 */
 	private MusicArchiveEntryBean inspectFile(String filename, File toInspect) {
 		log.debug("Analyzing: "+filename);
 		MP3InspectorJID3Lib inspector;
 		try {
 			inspector = new MP3InspectorJID3Lib(toInspect);
 			MusicArchiveEntryBean entryBean = inspectEntry(inspector);
 			entryBean.setEntryName(filename);
 			
 			/* TODO Check the following:
 			 *  1. Does the playlist of this bean already exist? --> set playlist-exists-bit
 			 *  2. Does the band/song-combination already exists? --> set song-exists-bit
 			 *  
 			 *  In the GUI, let users decide for the first: add to playlist OR create new playlist
 			 *                               for the second: don't import song but DO import the new playlist OR import the song
 			 */
 			
 			return entryBean;
 		} catch (IOException e) {
 			log.error("Error analyzing file: "+e);
 		} catch (ImporterException e) {
 			log.error("Error analyzing file: "+e);
 		}
 		
 		return null;
 	}
 	
 	/**
 	 * Inspect the contents of a single entry. Return the
 	 * metadata information in a MusicArchiveEntryBean. 
 	 * <p>Translates all illegal characters in the song name and band name into
 	 * undescore characters "_".
 	 * <p>If the band name is empty or equal to "Various", this method tries to find
 	 * the band name in the song name tag by search for the separator string " / ".
 	 * If found, the first part will be the band name and the second part the song name.
 	 * <p>This method will try to set the song index from the MP3 file name if the song
 	 * index could not be found inside the MP3 file.
 	 * @param inspector The MP3Inspector file. This object knows about the structure
 	 * 					of MP3 files and can retrieve metadata information from it.
 	 * @return A MusicArchiveEntryBean with the metadata information of this entry
 	 * 		   in the music archive.
 	 */
 	private MusicArchiveEntryBean inspectEntry(MediafileInspector inspector) {
 		MusicArchiveEntryBean bean = new MusicArchiveEntryBean();
 		bean.setPlaylistName(translate(inspector.getPlaylistname()));
 		bean.setBandName(translate(inspector.getBandname()));
 		bean.setSongName(translate(inspector.getSongname()));
 		bean.setSongLength(inspector.getSonglength());
 		bean.setSongIndex(inspector.getPlaylistrow());
 		// TODO The Heuristics should move to the jtag-library!
 		// Heuristic : If the bandname is empty or "Various" try to
 		//       find the band name in the song title.
 		if (bean.getBandName()==null || bean.getBandName().equals("")
 				|| bean.getBandName().equalsIgnoreCase("Various")) {
 			if (bean.getSongName()!=null && bean.getSongName().indexOf(" / ")>0) {
 				int index = bean.getSongName().indexOf(" / ");
 				String bandname = bean.getSongName().substring(0, index);
 				String songname = bean.getSongName().substring(index+3);
 				bean.setBandName(bandname);
 				bean.setSongName(songname);
 			} 
 		}
 		// Heuristic: If the File name matches "03 - Dress Rehearsal Rag.mp3", and
 		// The Song name is still empty, then set the song name from the file name.
 		if (bean.getSongName()==null || bean.getSongName().length()<1) {
 			Pattern pattern = Pattern.compile("^\\d+\\s+-(.+).[Mm][Pp]3");
 			Matcher matcher = pattern.matcher(inspector.getFile().getName());
 			if (matcher.find()) {
 				String songName = matcher.group(1).trim();
 				bean.setSongName(songName);
 			}
 		}
 		// Heuristic: If the Song Index is less than 1, try to determine the song
 		// index from the MP3 file name. Most often, the file name starts with the
 		// song index, like: "01 Protection.mp3".
 		if (bean.getSongIndex()<1) {
 			String songname = inspector.getFile().getName();
 			Pattern pattern = Pattern.compile("^\\d+\\s+");
 			Matcher matcher = pattern.matcher(songname);
 			if (matcher.find()) {
 				String songIndexMatch = matcher.group().trim();
 				int songIndex = Integer.parseInt(songIndexMatch);
 				bean.setSongIndex(songIndex);
 			}
 		}
 		Set<String> keyWords = new HashSet<String>();
 
 		
 		/* Don't trust the genre from the read tag, go to wikipedia first
 		 * and try to find out if they have more precise keywords listed.
 		 * We'll be mostly interested in the genre's specified on this song's
 		 * playlist.
 		 */  
 		String id3Keyword = inspector.getKeyword();
 		String[] wikiKeywords = WikipediaSearcher.getKeywords(bean.getBandName(),bean.getPlaylistName());
 		if (wikiKeywords==null || wikiKeywords.length==0) {
 			keyWords.add(id3Keyword);
 		} else {
 			for (String wikiKeyword : wikiKeywords) {
 				keyWords.add(wikiKeyword);
 			}
 		}
 		bean.setKeywords(keyWords);
 		
 		return bean;
 	}
 	
     private String translate(String str) {
     	//TODO Move to the jtag-library
     	if (str==null) {
     		return str;
     	}
         // Remove any quotes.
         str = str.replaceAll("'", "");
 
         // Convert non-ascii characters to similar ascii characters.
         for (char[] chars : _CHAR_MAP) {
             str = str.replace(chars[0], chars[1]);
         }
 
         return str;
     }
 
     /**
      * Maps from miscellaneous accented characters to similar-looking ASCII characters.
      */
     private final char[][] _CHAR_MAP = {
        	//TODO Move to the jtag-library
            {'\u00C0', 'A'}, {'\u00C1', 'A'}, {'\u00C2', 'A'}, {'\u00C3', 'A'}, {'\u00C4', 'A'}, {'\u00C5', 'A'}, {'\u00C6', 'A'},
            {'\u00C8', 'E'}, {'\u00C9', 'E'}, {'\u00CA', 'E'}, {'\u00CB', 'E'}, {'\u00CC', 'I'}, {'\u00CD', 'I'}, {'\u00CE', 'I'},
            {'\u00CF', 'I'}, {'\u00D2', 'O'}, {'\u00D3', 'O'}, {'\u00D4', 'O'}, {'\u00D5', 'O'}, {'\u00D6', 'O'}, {'\u00D9', 'U'},
            {'\u00DA', 'U'}, {'\u00DB', 'U'}, {'\u00DC', 'U'}, {'\u00DF', 'B'}, {'\u00E0', 'a'}, {'\u00E1', 'a'}, {'\u00E2', 'a'},
            {'\u00E3', 'a'}, {'\u00E4', 'a'}, {'\u00E5', 'a'}, {'\u00E6', 'a'}, {'\u00E7', 'c'}, {'\u00E8', 'e'}, {'\u00E9', 'e'},
            {'\u00EA', 'e'}, {'\u00EB', 'e'}, {'\u00EC', 'i'}, {'\u00ED', 'i'}, {'\u00EE', 'i'}, {'\u00EF', 'i'}, {'\u00F1', 'n'},
            {'\u00F2', 'o'}, {'\u00F3', 'o'}, {'\u00F4', 'o'}, {'\u00F5', 'o'}, {'\u00F6', 'o'}, {'\u00F8', 'o'}, {'\u00F9', 'u'},
            {'\u00FA', 'u'}, {'\u00FB', 'u'}, {'\u00FC', 'u'},
     };
     
     /**
      * Stores the content of the _inspected-property on disk, to prevent dataloss whenever the
      * application shuts down or crashes. 
      * @return Whether the operation succeeded or not.
      */
     private static synchronized boolean storeInspectedItems() {
 		File storage = getPersistentStorage();
 		if (_inspected.size()==0) {
 			return (storage.exists()) ? storage.delete() : true;
 		} else {
 			try {
 				ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(storage));
 				out.writeObject(_inspected);
 				out.flush();
 				out.close();
 				return true;
 			} catch (FileNotFoundException e) {
 				log.error("Error opening beanstorage: "+e);
 			} catch (IOException e) {
 				log.error("Error writing to beanstorage: "+e);
 			}
 			return false;
 		}
     }
 
 
 }