package org.musicontroller.gui.importer;
   
   import java.util.Collection;
   import java.util.Date;
   import java.util.HashSet;
   import java.util.List;
   import java.util.Set;
   
   import org.apache.hivemind.util.PropertyUtils;
  import org.apache.tapestry.IExternalPage;
  import org.apache.tapestry.IPage;
  import org.apache.tapestry.IRequestCycle;
  import org.apache.tapestry.annotations.EventListener;
  import org.apache.tapestry.annotations.InjectObject;
  import org.apache.tapestry.engine.ExternalServiceParameter;
  import org.apache.tapestry.engine.IEngineService;
  import org.apache.tapestry.engine.ILink;
  import org.apache.tapestry.event.BrowserEvent;
  import org.apache.tapestry.event.PageBeginRenderListener;
  import org.apache.tapestry.event.PageEvent;
  import org.apache.tapestry.html.BasePage;
  import org.apache.tapestry.services.ServiceMap;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.importer.Importer;
  import org.musicontroller.importer.ImporterException;
  import org.musicontroller.importer.MusicArchiveBean;
  import org.musicontroller.importer.MusicArchiveEntryBean;
  import org.musicontroller.importer.PlaylistImportProperties;
  import org.musicontroller.service.McService;
  import org.varienaja.util.coverart.CoverArtSearchResult;
  
  /**
   * Screen for showing music archive contents, editing properties and 
   * keywords and importing the archive contents into the MusiController database.
   * <p>The functions of this screen:
   * <ul>
   * <li> Set the playlist name, artist, keywords and release date on any song in the music archive.
   * <li> Select or deselect entries in the music archive for import.
   * <li> Propose a cover art image; Let the user select a different cover art image.
   * <li> Import the selected entries of the music archive into the music controller.
   * </ul>
   * <p>Page properties:
   * <ul>
   * <li>The music archive contains information about the MP3 files in an imported ZIP. It is passed to
   *    this page as the <code>archive</code> property.
   * <li>The <code>importer</code> property holds an object capable of importing music into the musicontroller.
   *     This object implements the <code>importer</code> interface.
   * <li>The <code>feedback</code> property provides a mechanism for giving messages to the user.
   * <li>
   * </ul>
   * 
   * <p>The page attempts to find a suitable cover image:
   * <ol>
   * <li> If the music archive contains a cover art URL, that URL is used.
   * <li> If a persistent playlist with the same name and artist exist, the cover art of that playlist is used.
   * <li> A cover art search is performed, using search criteria derived from the information in the music archive.
   *      The first result of that search is suggested as the cover art.
   * </ol>
   * 
   * @see MusicArchiveBean
   * 
   * @author Hans Drexler
   * @revision $Id: MusicArchive.java,v 1.1 2010/03/16 18:55:43 varienaja Exp $
   */
  public abstract class MusicArchive extends BasePage implements IExternalPage, PageBeginRenderListener {
  
  	@InjectObject("engine-service:page") public abstract IEngineService getPageService(); 
  	@InjectObject("engine-service:external") public abstract IEngineService getExternalService();
  	
  	public abstract ServiceMap getServiceMap();
  
  	public abstract McService getMcService();
  	
  	/**
  	 * This property holds the bean with information about the
  	 * songs in the archive.
  	 */
  	public abstract MusicArchiveBean getArchive();
  
  	/**
  	 * Sets a message for the user. The message will be shown in bold face.
  	 * @param message The message to show.
  	 */
  	public abstract void setFeedback(String message);
  	
  	/**
  	 * The importer object knows how to import music into the
  	 * database.
  	 * @return The importer object.
  	 */
  	public abstract Importer getImporter();
  
  	/**
  	 * Getter for the property that iterates over the playlist entries in the archive.
  	 * @return The value of the <tt>playlistEntry</tt> property.
  	 */
  	public abstract PlaylistImportProperties getPlaylistEntry();
  	
  	/**
 	 * Interpret parameters from other pages. This pages uses the <code>CoverArtEdit</code> page to select a cover
 	 * art image. That page returns the selected cover art by calling back to this page with three
 	 * parameters. The first is the playlist id (which is null in this case). The second is the
 	 * selected CoverArtSearchResult. The third is the playlist name that was passed to the <code>CoverArtEdit</code> page.
 	 *  Test if this second parameter is non-null, and set the selected cover art if it is.
 	 */
 	public void activateExternalPage(Object[] args, IRequestCycle cycle) {
 		CoverArtSearchResult cover = null;
 		if(args.length>1 && args[1]!=null) {
 			cover = (CoverArtSearchResult) args[1];
 			String playlistName = (String) args[2];
 			PlaylistImportProperties props = getArchive().getPlaylistProperties(playlistName);
 			if(props!=null) {
 				props.setCoverArt(cover.getURI().toString());
 			}
 		}
 	}
 
 	/**
 	 * Prepare rendering the page. Detect persistent playlists with the same name.
 	 * Repeat the cover art search only once per hour.
 	 */
 	public void pageBeginRender(PageEvent event) {
 		for(String playlistName : getArchive().getPlaylistNames()) {
 			PlaylistImportProperties props = getArchive().getPlaylistProperties(playlistName);
 			long MillisInHour = 1000L * 3600;
 			if(!props.isCoverArtSearchDone() && 
 					(props.getTimeOfLastCoverArtSearch()==null || new Date().getTime() - props.getTimeOfLastCoverArtSearch().getTime()>MillisInHour) ) {
 				String url = guessUrl(playlistName);
 				if(url!=null && url.length()>0) {
 					props.setCoverArt(url);
 					props.setCoverArtSearchDone(true);
 				}
 				props.setTimeOfLastCoverArtSearch(new Date());
 			}
 		}
 	}
 
 
 	/**
 	 * Guess a cover art URL, if possible. Else, return "".
 	 * @return The cover art url, if possible.
 	 */
 	private String guessUrl(String playlistName) {
 		// Step 1: Use URL of persistent playlist that might be the same.
 		Set<Playlist> candidates = getMcService().guessPlaylistsInArchive(getArchive());
 		if(candidates.size()>0) {
 			Playlist takeThis = candidates.iterator().next();
 			ILink link = getServiceMap().getService("coverart").getLink(false,new Object[]{takeThis.getId(),200});
 			return "http:"+link.getURL();
 		}
 		// Step 2: Try a cover art search.
 		String guessedBandName = getMcService().guessBandNameOfArchive(getArchive());
 		String guessedPlaylistName = playlistName;
 		if(guessedPlaylistName==null) {
 			Set<String> playlistNames = new HashSet<String>();
 			for(MusicArchiveEntryBean entry: getArchive().getEntrySet()) {
 				if(entry.getPlaylistName()!=null && entry.getPlaylistName().trim().length()>0) {
 					playlistNames.add(entry.getPlaylistName());
 					break;
 				}
 			}
 			if(playlistNames.size()>0) {
 				guessedPlaylistName = playlistNames.iterator().next();
 			}
 		}
 		Collection<CoverArtSearchResult> coverArtList = getMcService().getCoverArtList(guessedBandName, guessedPlaylistName);
 		if(coverArtList.size()>0) {
 			return coverArtList.iterator().next().getURI().toString();
 		}
 		// Nothing found...
 		return "";
 	}
 
 	/**
 	 * Goto the EditCoverArt page. The playlist is not persistent, so we must specify the band name and 
 	 * playlist name using the 3rd and 4th argument. Guess the band name and playlist name. It is possible
 	 * that this is a partial import of an already persistent playlist. Try to retrieve a persistent
 	 * playlist with the same playlist name as the name in the first song entry.
 	 * If this yields no result, guess the band name and playlist name from the first song entry. 
 	 * The first argument to the CoverArtEdit page must be null to indicate a non persistent playlist.
 	 * The second argument is the name of the page the CoverArtEdit page should return to ("MusicArchive").
 	 */
 	public ILink editCoverArt(IRequestCycle cycle) {
 		IEngineService service = getExternalService();
 		// Guess the band and playlist name. Both must be set in order to use the Covert art selection page.
 		String bandName = getMcService().guessBandNameOfArchive(getArchive());
 		String playlistName = null;
 		// Is there a persistent playlist with the same name?
 		List<Playlist> candidates = getMcService().findImportedPlaylist(getArchive());
 		if(candidates.size()>0) {
 			Playlist candidate = candidates.iterator().next();
 			playlistName = candidate.getName();
 		}
 		MusicArchiveBean bean = getArchive();
 		for (MusicArchiveEntryBean entry : bean.getEntrySet()) {
 			if(playlistName==null&&(entry.getPlaylistName()!=null && entry.getPlaylistName().length()>0)) {
 				playlistName = entry.getPlaylistName();
 			}
 		}
 		if(bandName!=null && playlistName!=null) {
 			ExternalServiceParameter parameter = new ExternalServiceParameter("CoverArtEdit", new Object[]{null,"MusicArchive",bandName,playlistName});
 			ILink link = service.getLink(false, parameter);
 			return link;
 		} else {
 			IPage page = cycle.getPage("MusicArchive");
 			PropertyUtils.write(page,"archive",bean);
 			PropertyUtils.write(page,"feedback","Please set band name and playlist name before selecting cover art.");
 			ILink pageLink = getPageService().getLink(false, page); 
 			return pageLink;
 		}
 	}
 
 	/**
 	 * Returns true if a persistent playlist with the same name as <tt>playlistEntry</tt> exists or false otherwise. 
 	 * @return True if a persistent playlist with the same name exists or false otherwise.
 	 */
 	public boolean isExistingPlaylist() {
 		PlaylistImportProperties entry = getPlaylistEntry();
 		List<Playlist> hits = getMcService().searchPlaylistByName(entry.getPlaylistName());
 		return hits.size()>0;
 	}
 	
 	/**
 	 * Imports the MusicArchiveBean into the database. Errors while importing are reported.
 	 * Upon successful import, the User is redirected to the ImportProgress-page, where he
 	 * can select another MusicArchiveBean to import.
 	 * @param cycle The Tapestry MVC cycle
 	 * @param bean The MusicArchiveBean to import into the database
 	 */
 	public void importArchive(IRequestCycle cycle, MusicArchiveBean bean) {
 		try {
 			getImporter().importMusic(bean);
 			/* This time-consuming method is blocking. Although the importMusic-procedure
 			 * is not as slow as is hat been, it still takes a while. I (Varienaja) choose
 			 * to keep this method blocking, as the User gets immediate feedback. 
 			 */
 			IPage page = cycle.getPage("ImportProgress");
 			PropertyUtils.write(page,"feedback","Archive "+bean.getArchiveName()+" imported without errors.");
 			cycle.activate(page);
 		} catch (ImporterException e) {
 			IPage page = cycle.getPage("MusicArchive");
 			PropertyUtils.write(page,"archive",bean);
 			PropertyUtils.write(page,"feedback","Error while importing: "+e.getLocalizedMessage());
 			cycle.activate(page);
 		}
 	}
 	
 	/**
 	 * Fill the song entries without a song index with a reasonable
 	 * song index value.
 	 * 
 	 * @param cycle The tapestry MVC cycle.
 	 * @param bean The MusicArchive bean that holds the information
 	 *             about the songs in the archive.
 	 */
 	public void fillSongIndex(IRequestCycle cycle, MusicArchiveBean bean) {
 		int index = 1;
 		for (MusicArchiveEntryBean entry : bean.getEntrySet()) {
 			if (entry.getSongIndex()<1) {
 				entry.setSongIndex(index);
 				index = index + 1;
 			} else {
 				index = entry.getSongIndex() + 1;
 			}
 		}
 	}
 	
 	/**
 	 * Fill the song entries without a playlist name with the name
 	 * inserted into the first row. Updates the list of playlists
 	 * shown in the screen.
 	 * 
 	 * @param cycle The tapestry MVC cycle.
 	 * @param bean The MusicArchive bean that holds the information
 	 *             about the songs in the archive.
 	 */
 	public void fillPlaylistName(IRequestCycle cycle, MusicArchiveBean bean) {
 		String fillValue = null;
 		for (MusicArchiveEntryBean entry : bean.getEntrySet()) {
 			if (fillValue==null) {
 				// use the value in this entry as the fillValue, if it is non-null. Trim the value.
 				fillValue = entry.getPlaylistName()==null ? null : entry.getPlaylistName().trim();
 			} else {
 				entry.setPlaylistName(fillValue);
 			}
 		}
 		getArchive().analyseMusicArchive();
 		cycle.getResponseBuilder().updateComponent("archiveForm");
 	}
 	
 	/**
 	 * Fill the song entries with a band name with the name entered into the first row.
 	 * 
 	 * @param cycle The tapestry MVC cycle.
 	 * @param bean The MusicArchive bean that holds the information
 	 *             about the songs in the archive.
 	 */
 	public void fillBandName(IRequestCycle cycle, MusicArchiveBean bean) {
 		String fillValue = null;
 		for (MusicArchiveEntryBean entry : bean.getEntrySet()) {
 			if (fillValue==null) {
 				// use the value in this entry as the fillValue, if it is non-null. Trim the value.
 				fillValue = entry.getBandName()==null ? null : entry.getBandName().trim();
 			} else {
 				entry.setBandName(fillValue);
 			}
 		}
 	}
 
 	/**
 	 * Fill the song entries with keywords the same as entered into the first row.
 	 * 
 	 * @param cycle The tapestry MVC cycle.
 	 * @param bean The MusicArchive bean that holds the information
 	 *             about the songs in the archive.
 	 */
 	public void fillKeywords(IRequestCycle cycle, MusicArchiveBean bean) {
 		String fillValue = null;
 		for (MusicArchiveEntryBean entry : bean.getEntrySet()) {
 			if (fillValue==null) {
 				// use the value in this entry as the fillValue, if it is non-null.
 				fillValue = entry.getKeywordString()==null ? null : entry.getKeywordString().trim();
 			} else {
 				entry.setKeywordString(fillValue);
 			}
 		}
 	}
 
 	@EventListener(targets="playlistNameEditBox", events="onchange", autoSubmit=true)
 	/**
 	 * Re-ananlyse the contents of the music archive if the user changed a playlist name.
 	 * @param event The Tapestry Dojo event that fired.
 	 */
 	public void playlistNameChangedListener(BrowserEvent event) {
 		getArchive().analyseMusicArchive();
 		getRequestCycle().getResponseBuilder().updateComponent("archiveForm");
 	}
 	
 	@EventListener(targets="addToExistingPlaylist", events="onchange", autoSubmit=true)
 	/**
 	 * When the "add to existing playlist" check box is on, disable the release date edit box
 	 * and rerender the form. 
 	 */
 	public void addToExistingPlaylistChangedListener(BrowserEvent event) {
 		getRequestCycle().getResponseBuilder().updateComponent("archiveForm");
 	}
 }