package org.musicontroller.importer;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.URISyntaxException;
   import java.util.ArrayList;
   import java.util.Date;
   import java.util.HashMap;
   import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import org.apache.log4j.Logger;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.core.jobs.MetadataExtractJob;
  import org.musicontroller.dao.Dao;
  import org.musicontroller.service.FileUtils;
  import org.musicontroller.service.McService;
  import org.varienaja.util.FileOperations;
  import org.varienaja.util.coverart.CoverArtManager;
  import org.varienaja.util.coverart.CoverArtSearchResult;
  
  /**
   * Implements Importer interface for importing music archives into the music
   * database.
   * 
   * @author Hans Drexler
   * @version $Id: ImporterImpl.java,v 1.1 2010/03/16 18:55:43 varienaja Exp $
   */
  public class ImporterImpl implements Importer {
  
  	/**
  	 * A logger.
  	 */
  	private static Logger log = Logger.getLogger(ImporterImpl.class);
  	
  	/**
  	 * Dao object gets imported by spring.
  	 */
  	private Dao _dao;
  	
  	/**
  	 * The McService gets imported by spring.
  	 */
  	private McService _mcService;
  	
  	/**
  	 * Setter for the Dao.
  	 * @param dao The Dao.
  	 */
  	public void setDao(Dao dao) {
  		_dao = dao;
  	}
  	
  	/**
  	 * Getter for the Dao.
  	 * @return The Dao.
  	 */
  	public Dao getDao() {
  		return _dao;
  	}
  	
  	/**
  	 * Getter for the McService.
  	 * @return The McService.
  	 */
  	public McService getMcService() {
  		return _mcService;
  	}
  	
  	/**
  	 * Setter for the McService.
  	 * @param mcService
  	 */
  	public void setMcService(McService mcService) {
  		_mcService = mcService;
  	}
  	
  	public void importMusic(MusicArchiveBean bean) throws ImporterException {
  		if(bean==null) {
  			return;
  		}
  		if(bean.getArchiveName()==null || bean.getArchiveName().length()<1) {
  			throw new ImporterException("Invalid archive without a name cannot be imported.");
  		}
  		//Use the information stored in the bean to import music into the database.
  		log.debug("Importing music from bean: "+bean.getArchiveName());		
  		// Build a Map of different Playlist names in the archive, and a list of entries for each name.
  		Map<String,List<MusicArchiveEntryBean>> entryMap = new HashMap<String,List<MusicArchiveEntryBean>>();
  		for (MusicArchiveEntryBean entry : bean.getEntrySet()) {
  			if (entry.getInclude()) {
  				String key = entry.getPlaylistName();
  				if(key==null || key.length()<1) {
  					throw new ImporterException("Invalid empty playlist name in an entry.");
  				}
  				if(entryMap.get(key)==null) {
  					entryMap.put(key, new ArrayList<MusicArchiveEntryBean>());
 				}
 				entryMap.get(key).add(entry);
 			}
 		}
 		for(Entry<String,List<MusicArchiveEntryBean>> entry: entryMap.entrySet()) {
 			PlaylistImportProperties properties = bean.getPlaylistProperties(entry.getKey());
 			if(properties==null) {
 				// No properties specified, use defaults
 				properties = new PlaylistImportProperties();
 				properties.setAddToExistingPlaylist(false);
 				properties.setPlaylistName(entry.getKey());
 				properties.setCoverArt(null);
 			}
 			// Import all entries of this playlist name using the same settings.
 			long playlistid = createPlaylist(properties);
 			for(MusicArchiveEntryBean entryBean: entry.getValue()) {
 				importIntoMusiController(bean, entryBean, playlistid);
 			}
 			if(!CoverArtManager.contains(playlistid, 0) && properties.getCoverArt()!=null && properties.getCoverArt().length()>7) {
 				try {
 					CoverArtSearchResult art = new CoverArtSearchResult(properties.getCoverArt(),64,64,64);
 					getMcService().setPlaylistCoverArt(getDao().getPlaylistById(playlistid, null),art);
 				} catch (IOException e) {
 					log.error("Failed to set cover art image: "+e.getLocalizedMessage());
 				} catch (URISyntaxException e) {
 					log.error("Failed to set cover art image: "+e.getLocalizedMessage());
 				}
 			}
 		}
 		MetadataExtractJob.removeMusicArchiveBean(bean);
 	}
 	
 	/**
 	 * Creates an empty playlist with the given name if necessary. A new playlist is
 	 * created if there is no playlist with the same name or if the <code>addToExistingPlaylist</code>
 	 * is false.
 	 * 
 	 * @param playlistName The name of the playlist to add.
 	 * @return The id of the persistent playlist (either created or already existing.)
 	 * @throws ImporterException The playlist name is invalid.
 	 */
 	private long createPlaylist(PlaylistImportProperties properties) throws ImporterException {
 		String playlistname = properties.getPlaylistName();
 		if(playlistname==null||playlistname.length()<1) {
 			throw new ImporterException("Invalid play list name (null or empty).");				
 		}
 		List<Playlist> playlists = getDao().searchPlaylist(playlistname);
 		Playlist playlist = null;
 		if(playlists.size()>0 && properties.isAddToExistingPlaylist()) {
 			// We should use the existing playlist.
 			return playlists.get(0).getId();
 		}
 		log.debug("Creating new playlist: "+properties.getPlaylistName());
 		// Playlist does not exist => create it.
 		playlist = new Playlist();
 		playlist.setName(properties.getPlaylistName());
 		playlist.setReleasedate(properties.getReleaseDate());
 		playlist.setInserted(new Date());
 		getDao().save(playlist);	
 		return playlist.getId();
 	}
 
 	/**
 	 * Copy the MP3 file into the MusiController file system and data base. The MP3 file
 	 * must be copied to its proper position in the MusiController file store and appropriate
 	 * Song/Band/Playlist objects must be added to the MusiController database. The Importer
 	 * does specify the final MP3 file path. We use MusiControllerTools to do the actual work.
 	 * 
 	 * @param archive Contains the music archive.
 	 * @param entryToImport Contains the MP3 meta data to use.
 	 * @param playlistid The id of a persistent playlist. The playlist must already exist.
 	 * @throws ImporterException The band name is null or empty, the play list name is null
 	 * 				or empty.
 	 */
 	private void importIntoMusiController(MusicArchiveBean archive, MusicArchiveEntryBean entryToImport, long playlistid) throws ImporterException {
 		// First, import the band if it isn't there yet.
 		String bandname = entryToImport.getBandName();
 		if(bandname==null||bandname.length()<1) {
 			throw new ImporterException("Invalid band name (null or empty) in song: "+entryToImport.getSongName()+" at index "+
 											String.valueOf(entryToImport.getSongIndex()));
 		}
 		String playlistname = entryToImport.getPlaylistName();
 		if(playlistname==null||playlistname.length()<1) {
 			throw new ImporterException("Invalid play list name (null or empty) in song: "+entryToImport.getSongName()+" at index "+
 					String.valueOf(entryToImport.getSongIndex()));				
 		}
 		String songname = entryToImport.getSongName();
 		if(songname==null||songname.length()<1) {
 			throw new ImporterException("Invalid song name (null or empty) in song: "+entryToImport.getSongName()+" at index "+
 					String.valueOf(entryToImport.getSongIndex()));				
 		}
 		String fileName = entryToImport.getEntryName();
 		if(fileName==null || fileName.length()<1) {
 			throw new ImporterException("Invalid null or empty file name in song: "+entryToImport.getSongName()+" at index"+
 					String.valueOf(entryToImport.getSongIndex()));
 		}
 		Band band = getMcService().addBand(bandname);
 		// Next, create the playlist.
 		Playlist playlist = getDao().getPlaylistById(playlistid, null);
 		if(playlist==null) {
 			throw new ImporterException("The playlist "+playlistname+" should already exist.");
 		}
 		String destination = moveMP3ToLibrary(entryToImport);
 		
 		try {
 			// Add the song to the playlist
 			Song newSong = getMcService().createSong(entryToImport.getSongName(), band, entryToImport.getSongLength(), entryToImport.getKeywords(), destination);
 			getMcService().addSongToPlaylist(newSong, playlist, entryToImport.getSongIndex());
 		} catch (Exception e) {
 			log.error("Error importing beanentry. "+e);
 			// Delete the MP3 file if an exception occured.
 			try {
 				FileOperations.deleteFile(destination);
 			} catch (Exception e1) {
 				// ignore and re-throw the first exception.
 				throw new ImporterException(e.getLocalizedMessage());
 			}
 			throw new ImporterException(e.getLocalizedMessage());
 		}
 	}
 
 	/**
 	 * Moves an entry to its final destination.
 	 * @param entryToImport The entry to import.
 	 * @return The relative name of the File, the entry was moved to.
 	 * @throws ImporterException when the move failed.
 	 */
 	public static String moveMP3ToLibrary(MusicArchiveEntryBean entryToImport)
 			throws ImporterException {
 		// Move the MP3 to its final location.
 		try {
 			String[] location = FileUtils.getNewSongDestination(entryToImport);
 			String dstdir = location[0] + File.separator + location[1];
 			
 			FileOperations.moveFile(entryToImport.getEntryName(), dstdir, location[2]);
 			return location[1] + File.separator + location[2];
 		} catch (Exception e) {
 			throw new ImporterException("Failed to move the MP3 file: "+e.getLocalizedMessage());
 		}
 	}
 
 }