package org.musicontroller.service;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.URI;
   import java.net.URL;
   import java.net.URLConnection;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.Map.Entry;
  
  import org.apache.log4j.Logger;
  import org.musicontroller.DJ;
  import org.musicontroller.core.AIBag;
  import org.musicontroller.core.AIRelation;
  import org.musicontroller.core.Artist;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Contract_PS;
  import org.musicontroller.core.Keyword;
  import org.musicontroller.core.KeywordCycleException;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Link;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.dao.BagAndKeywordUtils;
  import org.musicontroller.dao.Dao;
  import org.musicontroller.gui.edit.PlaylistMergeBean;
  import org.musicontroller.gui.edit.SongBean;
  import org.musicontroller.gui.edit.TrackList;
  import org.musicontroller.importer.MusicArchiveBean;
  import org.musicontroller.importer.MusicArchiveEntryBean;
  import org.musicontroller.security.IUser;
  import org.musicontroller.security.User;
  import org.musicontroller.streaming.StreamMaster;
  import org.varienaja.comments.Comment;
  import org.varienaja.comments.CommentService;
  import org.varienaja.util.coverart.CoverArtManager;
  import org.varienaja.util.coverart.CoverArtProcessor;
  import org.varienaja.util.coverart.CoverArtSearchResult;
  import org.varienaja.util.coverart.ICoverArtFinder;
  
  /**
   * Deliver services for adding and removing Musicians to songs.
   * 
   * @author Hans Drexler
   * @version $Id: McServiceImpl.java,v 1.1 2010/03/16 18:55:42 varienaja Exp $
   */
  public class McServiceImpl implements McService {
  
  	private Dao _dao;
  	/**
  	 * Getter for the DAO.
  	 * @return The DAO.
  	 */
  	public Dao getDao() {
  		return _dao;
  	}
  		
  	/**
  	 * Setter for the DAO.
  	 * @param dao The DAO.
  	 */
  	public void setDao(Dao dao) {
  		_dao = dao;
  	}
  
  	public Band addBand(String bandName) {
  		if (bandName == null) {
  			return null;
  		}
  		if(bandName.trim().length()==0) {
  			return null;
  		}
  		Band result = getDao().searchBand(bandName);
  		if(result==null) {
  			result = new Band();
  			result.setName(bandName);
  			result.setInserted(new Date());
  			getDao().save(result);
  		}
  		return result;
  	}
  	
  	public void addMusician(Playlist playlist, String artistfirstname, String artistlastname, String instruments, String tracks) {
  		if(artistlastname==null) {
  			return;
  		}
  		if(instruments==null || "".equals(instruments)) {
  			return;
 		}
 		if(playlist==null) {
 			return;
 		}
 		TrackList tracklist = null;
 		if(tracks==null) {
 			tracklist = TrackList.createInstance(playlist);
 		} else { 	
 			tracklist = TrackList.createInstance(tracks);
 		}
 		Set<AIRelation> relationsToAdd = BagAndKeywordUtils.createRelations(artistfirstname,artistlastname,null,instruments);
 
 		/*
 		 * Construct a map of all PS contracts in the playlist sharing the same set of AI relations. We will
 		 * use this map to retrieve the AIBag for each different set of AI relations only once and then setting
 		 * it in all songs with that set of AI relations. This is needed because getAIBag() is implemented
 		 * inefficiently. Songs that are not in the track list are ignored.
 		 */
 		Map<Set<AIRelation>,Set<Contract_PS>> songRelationMap = new HashMap<Set<AIRelation>,Set<Contract_PS>>();
 		for(Contract_PS contract : playlist.getSongs()) {
 			if(tracklist.contains(contract.getRowno())) {
 				Song song = contract.getSong();
 				Set<AIRelation> relations = new HashSet<AIRelation>();
 				if (song.getAibag()!=null) {
 					relations.addAll(song.getAibag().getRelations());
 				}
 				Set<Contract_PS> songSet = null;
 				if(songRelationMap.containsKey(relations)) {
 					songSet = songRelationMap.get(relations);
 				} else {
 					songSet = new HashSet<Contract_PS>();
 					songRelationMap.put(relations, songSet);
 				}
 				songSet.add(contract);
 			}
 		}
 		
 		for(Entry<Set<AIRelation>,Set<Contract_PS>> entry : songRelationMap.entrySet()) {
 			Set<AIRelation> targetSet = new HashSet<AIRelation>();
 			targetSet.addAll(entry.getKey());
 			targetSet.addAll(relationsToAdd);
 			AIBag bagForThisSet = BagAndKeywordUtils.getAIBag(targetSet);
 			for(Contract_PS contract : entry.getValue()) {
 				Song song = contract.getSong();
 				song.setAibag(bagForThisSet);
 				_dao.save(song);
 			}
 		}		
 	}
 	
 	public void addMusician(Song song, String artistfirstname, String artistlastname, String instruments) {
 		if(song==null) {
 			return;
 		}
 		if(artistlastname==null) {
 			return;
 		}
 		if(instruments==null || "".equals(instruments)) {
 			return;
 		}
 		Set<AIRelation> relations = BagAndKeywordUtils.createRelations(artistfirstname,artistlastname,song.getBand(),instruments);
 		// Merge with already existing relations.
 		if (song.getAibag()!=null) {
 			for(AIRelation existingRelation : song.getAibag().getRelations()) {
 				relations.add(existingRelation);
 			}
 		}
 		AIBag newBag = BagAndKeywordUtils.getAIBag(relations);
 		song.setAibag(newBag);
 		_dao.save(song);	
 	}
 
 	public Artist getArtistById(long artistId) {
 		return getDao().getArtistById(artistId);
 	}
 	
 	public void addSongToPlaylist(Song song, Playlist playlist, int songIndex) {
 		if(playlist==null) {
 			return;
 		}
 		playlist.addSong(song, songIndex);
 		_dao.save(playlist);
 	}
 	
 	public void deleteMusician(Playlist playlist, String artistfirstname, String artistlastname, String instruments, String tracks) {
 		if(artistlastname==null) {
 			return;
 		}
 		if(instruments==null || "".equals(instruments)) {
 			return;
 		}
 		if(playlist==null) {
 			return;
 		}
 		TrackList tracklist = null;
 		if(tracks==null) {
 			tracklist = TrackList.createInstance(playlist);
 		} else { 	
 			tracklist = TrackList.createInstance(tracks);
 		}
 		// Check the existence of the artist before building the relations, because this method
 		// should never create an artist.
 		Artist removedArtist = getDao().searchArtist(artistfirstname, artistlastname);
 		if(removedArtist==null) {
 			return;
 		}
 		Set<AIRelation> relationsToDelete = BagAndKeywordUtils.createRelations(artistfirstname,artistlastname,null,instruments);
 		
 		/*
 		 * Construct a map of all PS contracts in the playlist sharing the same set of AI relations. We will
 		 * use this map to retrieve the AIBag for each different set of AI relations only once and then setting
 		 * it in all songs with that set of AI relations. This is needed because getAIBag() is implemented
 		 * inefficiently. Songs that are not in the track list are ignored.
 		 */
 		Map<Set<AIRelation>,Set<Contract_PS>> songRelationMap = new HashMap<Set<AIRelation>,Set<Contract_PS>>();
 		for(Contract_PS contract : playlist.getSongs()) {
 			if(tracklist.contains(contract.getRowno())) {
 				Song song = contract.getSong();
 				Set<AIRelation> relations = new HashSet<AIRelation>();
 				if (song.getAibag()!=null) {
 					relations.addAll(song.getAibag().getRelations());
 				}
 				Set<Contract_PS> songSet = null;
 				if(songRelationMap.containsKey(relations)) {
 					songSet = songRelationMap.get(relations);
 				} else {
 					songSet = new HashSet<Contract_PS>();
 					songRelationMap.put(relations, songSet);
 				}
 				songSet.add(contract);
 			}
 		}
 
 		for(Entry<Set<AIRelation>,Set<Contract_PS>> entry : songRelationMap.entrySet()) {
 			Set<AIRelation> targetSet = new HashSet<AIRelation>();
 			targetSet.addAll(entry.getKey());
 			targetSet.removeAll(relationsToDelete);
 			AIBag bagForThisSet = BagAndKeywordUtils.getAIBag(targetSet);
 			for(Contract_PS contract : entry.getValue()) {
 				Song song = contract.getSong();
 				song.setAibag(bagForThisSet);
 				_dao.save(song);
 			}
 		}		
 	}	
 
 	public void deleteMusician(Song song, String artistfirstname, String artistlastname, String instruments) {
 		Artist artist = _dao.searchArtist(artistfirstname, artistlastname);
 		if(artist == null) {
 			return;
 		}
 		if(instruments==null || "".equals(instruments)) {
 			return;
 		}
 		if(song == null) {
 			return;
 		}
 		Set<AIRelation> relationsToDelete = BagAndKeywordUtils.createRelations(artistfirstname,artistlastname,null,instruments);
 		
 		
 		if(song.getAibag()!=null) {
 			List<AIRelation> songRelations = song.getAibag().getRelations();
 			Set<AIRelation> targetRelations = new HashSet<AIRelation>();
 			targetRelations.addAll(songRelations);
 			for(AIRelation delrel: relationsToDelete) {
 				long artistid = delrel.getArtist_id();
 				long instsrid = delrel.getInstrument_id();
 				for(AIRelation testrel: targetRelations) {
 					if (testrel.getArtist_id()==artistid && testrel.getInstrument_id()==instsrid) {
 						targetRelations.remove(testrel);
 						break;
 					}
 				}
 			}
 			AIBag newBag = BagAndKeywordUtils.getAIBag(targetRelations);
 			song.setAibag(newBag);
 			_dao.save(song);
 		}		
 	}
 
 	public void editSongsOfPlaylist(Playlist playlist,List<SongBean> songbeans) {
 		Map<Long,SongBean> beanMap = new HashMap<Long, SongBean>();
 		for(SongBean songbean: songbeans) {
 			long songid = songbean.getSongId();
 			beanMap.put(songid,songbean);
 			Song song = getDao().getSongById(songid);
 			song.setName(songbean.getSongname());
 			song.setLength(songbean.getSonglength() * 1000);
 			Keywordbag targetBag = BagAndKeywordUtils.getKeywordBag(songbean.getSongKeywords());
 			song.setKeywordbag(targetBag);
 			getDao().save(song);
 		}
 		// Update the song indexes
 		if(playlist!=null) {
 			for (Contract_PS contract: playlist.getSongs()) {
 				Song song = contract.getSong();
 				SongBean bean = beanMap.get(song.getId());
 				if(bean!=null) {
 					contract.setRowno(bean.getSongIndex());
 				}
 			}
 			getDao().save(playlist);
 		}
 	}
 
 	public void addKeywordsToPlaylist(Playlist playlist, String keywords, TrackList tracks) {
 		if(playlist==null) {
 			return;
 		}
 		for(Contract_PS contract : playlist.getSongs()) {
 			if(tracks==null || tracks.contains(contract.getRowno())) {
 				Song song = contract.getSong();
 				Keywordbag oldBag = song.getKeywordbag();
 				if(oldBag==null) {
 					song.setKeywordbag(BagAndKeywordUtils.getKeywordBag(keywords));
 				} else {
 					// Do not alter the keyword bag of the song, because the bag may be shared
 					// with other songs. Instead, make a copy of the keywords.
 					List<Keyword> songKeywords = new ArrayList<Keyword>(); 
 					songKeywords.addAll(oldBag.getKeywords());
 					List<Keyword> newKeywords = BagAndKeywordUtils.getKeywordList(keywords);
 					songKeywords.addAll(newKeywords);
 					song.setKeywordbag(BagAndKeywordUtils.getKeywordBag(songKeywords));
 				}
 				getDao().save(song);
 			}
 		}
 	}
 
 	public void removeKeywordsFromPlaylist(Playlist playlist, String keywords, TrackList tracks) {
 		if(playlist==null) {
 			return;
 		}
 		for(Contract_PS contract : playlist.getSongs()) {
 			if(tracks==null || tracks.contains(contract.getRowno())) {
 				Song song = contract.getSong();
 				Keywordbag oldBag = song.getKeywordbag();
 				if(oldBag==null) {
 					// nothing to do...
 					break;
 				} else {
 					// Do not alter the keyword bag of the song, because the bag may be shared
 					// with other songs. Instead, make a copy of the keywords.
 					List<Keyword> songKeywords = new ArrayList<Keyword>(); 
 					songKeywords.addAll(oldBag.getKeywords());
 					List<Keyword> removeKeywords = BagAndKeywordUtils.getKeywordList(keywords);
 					songKeywords.removeAll(removeKeywords);
 					song.setKeywordbag(BagAndKeywordUtils.getKeywordBag(songKeywords));
 				}
 				getDao().save(song);
 			}
 		}
 	}
 
 	public void setPlaylistProperties(Playlist playlist, String playlistName, Date releaseDate) {
 		if(playlistName!=null && playlistName.length()>0) {
 			playlist.setName(playlistName.trim());
 		}
 		if(releaseDate!=null) {
 			playlist.setReleasedate(releaseDate);
 		}
 		getDao().save(playlist);
 	}
 	
 	public Playlist createPlaylist(String playlistname) {
 		if(playlistname==null) {
 			return null;
 		}
 		if(playlistname.trim().length()==0) {
 			return null;
 		}
 		Playlist playlist = new Playlist();
 		playlist.setName(playlistname);
 		playlist.setInserted(new Date());
 		getDao().save(playlist);
 		return playlist;
 	}
 
 
 	public Playlist getPlaylistById(long playlistid) {
 		return getDao().getPlaylistById(playlistid, null);
 	}
 
 	public void mergePlaylist(Playlist playlist, IUser user, List<PlaylistMergeBean> mergeBeanList) {
 		// Merge this playlist with others, if requested.
 		for (PlaylistMergeBean bean: mergeBeanList) {
 			if (bean.getMergeIndicator()) {
 				Playlist mergeThis = getDao().getPlaylistById(bean.getPlaylistId(), user);
 				getDao().mergePlaylists(playlist,mergeThis);
 			}
 		}
 	}
 	
 	public List<SongBean> constructSongBeanList(Playlist playlist) {
 		List<SongBean> result = new ArrayList<SongBean>();
 		if(playlist==null) {
 			return result;
 		}
 		for (Contract_PS contract: playlist.getSongs()) {
 			Song song = contract.getSong();
 			SongBean bean = new SongBean();
 			bean.setSongId(song.getId());
 			bean.setSongIndex(contract.getRowno());
 			bean.setBandname(song.getBand().getName());
 			bean.setBandId(song.getBand().getId());
 			bean.setSongname(song.getName());
 			bean.setSonglength(song.getLength() / 1000);
 			bean.setSongKeywords(song.listKeywords());
 			result.add(bean);
 		}
 		return result;
 	}
 	
 	public List<PlaylistMergeBean> constructMergeBeanList(Playlist playlist) {
 		List<PlaylistMergeBean> result = new ArrayList<PlaylistMergeBean>();
 		if(playlist==null) {
 			return result;
 		}
 		List<Playlist> sameNamePlaylists = getDao().searchPlaylist(playlist.getName());
 		sameNamePlaylists.remove(playlist);
 		for(Playlist mergePlaylist: sameNamePlaylists) {
 			PlaylistMergeBean bean = new PlaylistMergeBean();
 			bean.setPlaylistId(mergePlaylist.getId());
 			bean.setPlaylistDescription(mergePlaylist.getId()+": "+mergePlaylist.getName());
 			bean.setMergeIndicator(false);
 			result.add(bean);
 		}
 		return result;
 	}
 	
 	public Collection<CoverArtSearchResult> getCoverArtList(Playlist playlist) {
 		if(playlist==null) {
 			return new ArrayList<CoverArtSearchResult>();
 		}
     	ICoverArtFinder p = new CoverArtProcessor();
     	String band;
     	try {
     		band = playlist.getSongs().iterator().next().getSong().getBand().getName();
     	} catch (Exception e) {
     		band = "Various";
     	}
     	Collection<CoverArtSearchResult> covers = p.findCoverURLs(band, playlist.getName());
     	
 		return covers;
 	}
 	
 	public Collection<CoverArtSearchResult> getCoverArtList(String bandName, String playlistName) {
 		if(bandName==null||bandName.length()<1||playlistName==null||playlistName.length()<1) {
 			return new ArrayList<CoverArtSearchResult>();
 		}
     	ICoverArtFinder p = new CoverArtProcessor();
     	Collection<CoverArtSearchResult> covers = p.findCoverURLs(bandName, playlistName);
 		return covers;		
 	}
 	
 	public Song createSong(String songname, Band band, int length, Set<String> keywords, String destination) {
 		if(songname==null) {
 			return null;
 		}
 		if(songname.trim().length()==0) {
 			return null;
 		}
 		if(band==null) {
 			return null;
 		}
 		if(keywords==null) {
 			keywords = new HashSet<String>();
 		}
 		if(destination==null) {
 			return null;
 		}
 		Link newlink = new Link();
 		newlink.setUrl(destination);
 		getDao().save(newlink);
 		Song newSong = new Song();
 		newSong.setName(songname);
 		newSong.setBand(band);
 		newSong.setLink(newlink);
 		newSong.setLength(length);
 		newSong.setInserted(new Date());
 		for(String keywordtext : keywords) {
 			Keyword kw = getDao().searchKeyword(keywordtext);
 			if (kw==null) {
 				kw = new Keyword();
 				kw.setName(keywordtext);
 				try {
 					kw.setParent(null);
 				} catch (KeywordCycleException e) {
 					// Ignore. setParent(null) must never throw an exception.
 				}
 				getDao().save(kw);
 			}
 			BagAndKeywordUtils.addKeywordToSong(newSong,kw);
 		}
 		getDao().save(newSong);
 		return newSong;
 	}
 	
 	public Song getSongById(long songid) {
 		return getDao().getSongById(songid);
 	}
 	
 	public Playlist getUpcoming(long userid) {
 		Playlist playlist = new Playlist();
 		DJ dj = StreamMaster.getDJByUser(userid);
 		if(dj!=null) {
 			int counter=0;
 			for (long songid : dj.peek(6)) {
 				playlist.addSong(getDao().getSongById(songid),++counter);
 			}
 		}		
 		return playlist;
 	}
 	
 	public void setSongProperties(Song song, String name, String bandName, int msecs, String keywords) {
 		if(song==null) {
 			return;
 		}
 		if(name!=null) {
 			name = name.trim();
 			if(name.length()>0) {
 				song.setName(name);
 			}
 		}
 		if(msecs>0) {
 			song.setLength(msecs);
 		}
 		// Compare typed band name with current. Change if necessary.
 		if(bandName!=null) {
 			bandName = bandName.trim();
 			if(bandName.length()>0) {
 				if(!song.getBand().getName().equals(bandName)) {
 					Band targetBand = getDao().searchBand(bandName);
 					if (targetBand == null) {
 						targetBand = new Band();
 						targetBand.setName(bandName);
 						getDao().save(targetBand);
 					}
 					song.setBand(targetBand);
 				}				
 			}
 		}
 		// Save changed keywords
 		Keywordbag targetBag = BagAndKeywordUtils.getKeywordBag(keywords);
 		song.setKeywordbag(targetBag);
 		getDao().save(song);
 	}
 
 	public List<Playlist> getSongPlaylists(Song song) {
 		return getDao().listPlaylists(song);
 	}
 
 	public Playlist getSongNeighbours(Song song, IUser user) {
 		if(song==null) {
 			return new Playlist();
 		}
 		return getDao().getNeighbours(song.getId(), user);
 	}
 
 	public Playlist getSongsByBand(Band band) {
 		if(band==null) {
 			return new Playlist();
 		}
 		return getDao().songsByBand(band.getId());
 	}
 
 	public Band getBandById(long bandid) {
 		return getDao().getBandById(bandid);
 	}
 
 	public List<Playlist> getBandPlaylists(Band band) {
 		return getDao().listPlaylists(band);
 	}
 
 	public void setBandProperties(Band band, String bandName) {
 		// Trim whitespace from the new band name.
 		if(bandName!=null) {
 			bandName = bandName.trim();
 			// Check if the band name has changed.
 			if(!bandName.equals(band.getName())) {
 				// If the user changed the band name, check if there already
 				// is a band with that name. If so, merge the two bands.
 				Band mergeBand = getDao().searchBand(bandName);
 				if(mergeBand!=null) {
 					// Merge the two bands. The band named in the "band"
 					// variable does no longer exist in the database after
 					// mergeBands() finishes. Change it into the band that
 					// it is merged into.
 					getDao().mergeBands(mergeBand, band);
 					band = mergeBand;
 				} else {
 					// Just change the band name
 					band.setName(bandName);					
 				}
 			}
 		}
 		getDao().save(band);
 	}
 
 	public List<Object[]> listBands(IUser user) {
 		return getDao().listBands(user);
 	}
 
 	public Keyword getKeywordById(Long id) {
 		return getDao().getKeywordById(id);
 	}
 
 	public List<Keywordbag> getKeywordBagsWithKeywords(List<Long> selectedKeywordIds) {
 		List<Keyword> keywords = new LinkedList<Keyword>();
 		if (selectedKeywordIds!=null) {
 			for (Long keywordid : selectedKeywordIds) {
 				keywords.add(getDao().getKeywordById(keywordid));
 			}
 			return getDao().listKeywordsBags(keywords);
 		} else {
 			return null;
 		}
 	}
 
 	public List<Object[]> listKeywords(IUser user, List<Keywordbag> bags) {
 		return getDao().listKeywords(user, bags);
 	}
 
 	public Playlist songsByKeywordbags(List<Keywordbag> bags, User user, int maxResults) {
 		return getDao().songsByKeywordbags(bags, user, maxResults);
 	}
 
 	public void setPlaylistCoverArt(Playlist playlist, CoverArtSearchResult selected) throws IOException {
 		if (selected==null || playlist==null) {
 			return;
 		}
 		URI uri = selected.getURI();
 		if(uri==null) {
 			return;
 		}
 		if(!uri.isAbsolute()) {
 			uri = URI.create("file:"+uri.toString());
 		}
 		URL url = uri.toURL();
 		URLConnection urlc = url.openConnection();
 		urlc.setRequestProperty("user-agent","Mozilla/5.0"); //Google wants a user-agent.
 		InputStream imageStream = urlc.getInputStream();
 		CoverArtManager.purge(playlist.getId());
 		CoverArtManager.add(playlist.getId(), imageStream);
 		imageStream.close();
 	}
 
 	public File attemptToDownloadCoverArt(long playlistid, int size) {
 		if (!CoverArtManager.contains(playlistid, size)) { //download!
 			if (!CoverArtManager.contains(playlistid, 0)) {
 				Logger.getLogger(McService.class).debug("Original coverart not found; downloading...");
 				downloadCover(playlistid);
 			}
 			Logger.getLogger(McService.class).debug("Resized coverart not found; creating...");
 			try {
 				CoverArtManager.scale(playlistid, size);
 			} catch (FileNotFoundException e) {
 				Logger.getLogger(McService.class).error("Error resizing coverart: "+e);
 			}
 		}
 		return CoverArtManager.get(playlistid, size);
 	}
 	
     /**
      * @param playlistid
      */
     private void downloadCover(long playlistid) {
 		Playlist playlist = getPlaylistById(playlistid);
 		Collection<CoverArtSearchResult> searchresult = getCoverArtList(playlist);
     	CoverArtProcessor p = new CoverArtProcessor();
     	
     	boolean succes = false;
     	Iterator<CoverArtSearchResult> it = searchresult.iterator();
     	while (!succes && it.hasNext()) {
     		CoverArtSearchResult test = it.next();
     		InputStream in = null;
    			try {
    	   			in = p.getCover(test,playlist.getId());
    	   			CoverArtManager.add(playlistid,in);
     			succes = true;
     		} catch (IOException e) {
     			Logger.getLogger(McService.class).debug("Exception downloading coverart, trying next searchresult");
     		} finally {
     			try {
     				if (in!=null) in.close();
     			} catch (IOException e) {
         			Logger.getLogger(McService.class).debug("Error closing inputstream.");
     			}
     		}
     	}
     }
 
 	public Set<Comment> getReviews(Playlist playlist) {
 		CommentService service = new CommentService();
 		return service.getComments(playlist);
 	}
 
 	public Set<Comment> getReviews(Band band) {
 		CommentService service = new CommentService();
 		return service.getComments(band);
 	}
 	
 	public List<Playlist> findImportedPlaylist(MusicArchiveBean archive) {
 		List<Playlist> candidates = new ArrayList<Playlist>();
 		if(archive==null) {
 			return candidates;
 		}
 		Set<String> playlistNames = new HashSet<String>();
 		for(MusicArchiveEntryBean entry: archive.getEntrySet()) {
 			if(entry.getPlaylistName()!=null && entry.getPlaylistName().trim().length()>0) {
 				playlistNames.add(entry.getPlaylistName());
 			}
 		}
 		// TODO: This can be implemented more efficiently if searchPlaylist accepts an array of names to search.
 		for(String playlistName : playlistNames ) {
 			List<Playlist> playlistsSameName = getDao().searchPlaylist(playlistName);
 			if(playlistsSameName.size()>0) {
 					candidates.addAll(playlistsSameName);
 			}
 		}
 		return candidates;
 	}
 	
 	public Set<Playlist> guessPlaylistsInArchive(MusicArchiveBean archive) {
 		Set<Playlist> candidates = new HashSet<Playlist>();
 		if(archive==null) {
 			return candidates;
 		}
 		// Step 1: If a persistent playlist with the same name and artist exists, use that.
 		String bandNameCandidate = guessBandNameOfArchive(archive);
 		List<Playlist> persistentCandidates = findImportedPlaylist(archive);
 		for(Playlist persistentCandidate: persistentCandidates) {
 			for(Contract_PS songContracts: persistentCandidate.getSongs()) {
 				if(songContracts.getSong().getBand().getName().equalsIgnoreCase(bandNameCandidate)) {
 					candidates.add(persistentCandidate);
 					break;
 				}
 			}
 		}
 		// The above will fail in the case of an album with various artists each performing
 		// one song. The playlist name will match, but no song of the same artist can be found.
 		// If no candidates are found, but there is a playlist with the same name, use that.
 		if(candidates.isEmpty()) {
 			candidates.addAll(persistentCandidates);
 		}
 		return candidates;
 	}
 
 	public String guessBandNameOfArchive(MusicArchiveBean archive) {
 		Set<String> bandNames = new HashSet<String>();
 		String bandName = null;
 		if(archive==null) {
 			return "Unknown";
 		}
 		for(MusicArchiveEntryBean entry: archive.getEntrySet()) {
 			if(entry.getBandName()!=null && entry.getBandName().trim().length()>0) {
 				bandNames.add(entry.getBandName());
 			}
 		}
 		if(bandNames.size()==0) {
 			bandName = "Unknown";
 		} else if(bandNames.size()==1) {
 			bandName = bandNames.iterator().next();
 		} else {
 			bandName = "Various";
 		}		
 		return bandName;
 	}
 
 	public List<Playlist> searchPlaylistByName(String playlistName) {
 		return getDao().searchPlaylist(playlistName);
 	}
 
 }