package org.musicontroller.dao;
   
   import java.io.File;
   import java.util.ArrayList;
   import java.util.Calendar;
   import java.util.Collection;
   import java.util.Date;
   import java.util.GregorianCalendar;
   import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeMap;
  import java.util.Vector;
  import java.util.Map.Entry;
  import java.util.concurrent.CopyOnWriteArraySet;
  
  import org.apache.log4j.Logger;
  import org.hibernate.HibernateException;
  import org.hibernate.Query;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.musicontroller.SongChangeListener;
  import org.musicontroller.core.AIBag;
  import org.musicontroller.core.Artist;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Contract_PS;
  import org.musicontroller.core.Event;
  import org.musicontroller.core.Instrument;
  import org.musicontroller.core.Keyword;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Link;
  import org.musicontroller.core.LinkableAbs;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.repair.ConsistencyChecker;
  import org.musicontroller.security.Authority;
  import org.musicontroller.security.Encrypter;
  import org.musicontroller.security.IUser;
  import org.musicontroller.security.Role;
  import org.musicontroller.security.User;
  import org.springframework.orm.hibernate3.HibernateTemplate;
  import org.springframework.orm.hibernate3.SessionFactoryUtils;
  import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  import org.varienaja.util.DateTools;
  import org.varienaja.util.DenseSet;
  import org.varienaja.util.FileOperations;
  
  public class HibernateDao extends HibernateDaoSupport implements Dao {
  	private static final Logger LOG = Logger.getLogger(HibernateDao.class);
  	
  	private Set<SongChangeListener> _songChangeListeners;
  	
  	public HibernateDao() {
  		_songChangeListeners = new CopyOnWriteArraySet<SongChangeListener>();
  	}
  
  	@SuppressWarnings("unchecked")
  	public List<Long> getSongIds() {
  		return getHibernateTemplate().find(
  				"select s.id from Song s order by s.id");
  	}
  
  	public Song getSongById(long id) {
  		return (Song) getHibernateTemplate().get(Song.class,id);
  	}
  	
  	@SuppressWarnings("unchecked")
  	public List<Song> getSongsById(Collection<Long> ids) {
  		String sql = "from Song s where s.id in (:ids)";
  		List<Song> songlist = getHibernateTemplate().findByNamedParam(sql, 
  				new String[]{"ids"}, 
  				new Object[] {ids});
  
  		return songlist;
  	}
  	
  	public Band getBandById(long id) {
  		return (Band) getHibernateTemplate().get(Band.class,id);
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.dao.Dao#getBandByName(java.lang.String)
  	 */
  	@SuppressWarnings("unchecked")
  	public Band getBandByName(String name) {
  		String sql = "from Band b where lower(b.name)=:name order by b.inserted";
  		List<Band> bandlist = getHibernateTemplate().findByNamedParam(sql,
  					new String[] {"name"},
  					new Object[] {name.toLowerCase()});
  		return bandlist.size()==0 ? null : bandlist.get(0);
  	}
  
  	public Keyword getKeywordById(long id) {
  		return (Keyword) getHibernateTemplate().get(Keyword.class,id);
  	}
 	
 	public Keywordbag getKeywordBagById(long id) {
 		return (Keywordbag) getHibernateTemplate().get(Keywordbag.class,id);
 	}
 	
 	public Artist getArtistById(long id) {
 		return (Artist) getHibernateTemplate().get(Artist.class,id);
 	}
 
 	public AIBag getAIBagById(long id) {
 		return (AIBag) getHibernateTemplate().get(AIBag.class,id);
 	}
 	
 	@SuppressWarnings("unchecked")
 	public Artist searchArtist(String artistfirstname, String artistlastname) {
 		if(artistlastname==null) {
 			return null;
 		}
 		StringBuilder sb = new StringBuilder();
 		sb.append("from Artist a where lower(a.lastname)=:lastname");
 		List<Artist> artistlist = null;
 		if(artistfirstname==null) {
 			sb.append(" and a.firstname is null");
 			artistlist = getHibernateTemplate().findByNamedParam( sb.toString(),
 					new String[] { "lastname" },
 					new Object[] { artistlastname.toLowerCase()});
 		} else {
 			sb.append(" and lower(a.firstname)=:firstname");
 			artistlist = getHibernateTemplate().findByNamedParam( sb.toString(),
 					new String[] { "lastname","firstname" },
 					new Object[] { artistlastname.toLowerCase(),artistfirstname.toLowerCase()});
 		}
 		Artist result = null;
 		if (artistlist.size() > 0) {
 			result = artistlist.get(0);
 		}
 		return result;		
 	}
 	
 	@SuppressWarnings("unchecked")
 	public AIBag getArtistAppearances(long artistid) {
 		String hql = "from AIBag bag " +
 				"left join bag.relations rel" +
 				" where rel.artist_id=:artistid"; 
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("artistid", artistid);
 		List<AIBag> bags = search(hql, params, 0);
 		return bags.isEmpty()? null : bags.get(0);
 	}
 	
 	public Instrument getInstrumentById(long id) {
 		return (Instrument) getHibernateTemplate().get(Instrument.class,id);
 	}
 
 	@SuppressWarnings("unchecked")
 	public Song getSong(Band band, String songname) {
 		Song result = null;
 		List<Song> bandlist = getHibernateTemplate().findByNamedParam("from Song s where s.name=:name and s.band=:band",
 				new String[]{"name","band"},new Object[]{LinkableAbs.normalizeName(songname),band});
 		if(bandlist.size()>0) {
 			result = bandlist.get(0);
 		}
 		return result;
 	}
 	
 	@SuppressWarnings("unchecked")
 	public Playlist songsByBand(long bandid) {
 		Playlist result = new Playlist();
 		
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("bandid",bandid);
 		List<Song> l = search("from Song s where s.band.id=:bandid order by s.name",params,0);
 		
 		result.setName("");
 		int counter = 1;
 		for (Song s : l) {
 			result.addSong(s,counter++);
 		}
 	
 		return result;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#search(java.lang.String, java.util.Map, int)
 	 */
 	@SuppressWarnings("unchecked")
 	public List search(String hql, Map<String,Object> params, int maxResults) {
 		return search(hql, params, maxResults, 0);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#search(java.lang.String, java.util.Map, int, int)
 	 */
 	@SuppressWarnings("unchecked")
 	public List search(String hql, Map<String,Object> params, int maxResults, int offset) {
 		List result = new ArrayList();
 		try {
 			Query q = searchInternal(hql, params, maxResults, offset);
 			if(q!=null) {
 				result = q.list();
 			}
 		} catch (Exception e) {
 			LOG.error("Query failed: "+e.toString());
 			e.printStackTrace();
 		}
 		return result;
 	}
 
 	/**
 	 * Searches in the Database, and returns the objects that were selected.
 	 * @param hql The HQL-query.
 	 * @param params Query parameters as name,value pairs
 	 * @param maxResults The maximum amount of objects to return
 	 * @param offset The first <i>offset</i> objects will not be returned
 	 * @return The objects that fit to the search-query.
 	 * @throws Exception When the query failed.
 	 */
 	private Query searchInternal(String hql, Map<String,Object> params,
 			int maxResults, int offset) throws Exception {
 		Session session = SessionFactoryUtils.getSession(getSessionFactory(),
 				true);
 		
 		try {
 			LOG.debug("Query: "+hql);
 			Query query = session.createQuery(hql);
 			if (maxResults > 0)
 				query.setMaxResults(maxResults);
 			if (offset > 0)
 				query.setFirstResult(offset);
 
 			if (params != null) {
 				LOG.debug("Setting query parameters");
 				for (Entry<String,Object> entry : params.entrySet()) {
 					String s = entry.getKey();
 					LOG.debug("Parameter: "+s);
 					Object value = entry.getValue();
 					LOG.debug("Value: "+value);
 					if (value instanceof Collection) {
 						query.setParameterList(s,(Collection<?>) value);
 					} else {
 						query.setParameter(s,value);
 					}
 				}
 				LOG.debug("All parameters set");
 			}
 
 			return query;
 		} catch (HibernateException e) {
 			LOG.error("Query failed: "+e.toString());
 			throw new Exception("Query failed. " + e.toString());
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	public Band searchBand(String bandname) {
 		Band result = null;
 		List<Band> results = getHibernateTemplate().findByNamedParam(
 				"from Band b where b.name=:name", "name", LinkableAbs.normalizeName(bandname));
 		if (results.size() > 0) {
 			result = results.get(0);
 		}
 		return result;
 	}
 
 	@SuppressWarnings("unchecked")
 	public Keyword searchKeyword(String keyworddesc) {
 		if(keyworddesc==null) {
 			return null;
 		}
 		Keyword result = null;
 		List<Keyword> results = getHibernateTemplate().findByNamedParam(
 				"from Keyword k where lower(k.name)=:name", "name", LinkableAbs.normalizeName(keyworddesc).toLowerCase());
 		if (results.size() > 0) {
 			result = results.get(0);
 		}
 		return result;
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<Playlist> searchPlaylist(String playlistname) {
 		List<Playlist> results = getHibernateTemplate().findByNamedParam(
 				"from Playlist p where p.name=:name", "name", LinkableAbs.normalizeName(playlistname));
 		return results;
 	}
 	
 	public void save(Band band) {
 		getHibernateTemplate().save(band);
 	}
 
 	public void save(Keyword keyword) {
 		getHibernateTemplate().save(keyword);
 	}
 
 	public void save(Keywordbag keywordbag) {
 		getHibernateTemplate().save(keywordbag);
 	}
 	
 	public void save(Playlist playlist) {
 		getHibernateTemplate().save(playlist);
 	}
 
 	public void save(Link link) {
 		getHibernateTemplate().save(link);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#save(org.musicontroller.core.Song)
 	 */
 	public void save(Song song) {
 		boolean newSong = song.getId()==-1L; //New Songs have an 'uninitialized' id.
 		getHibernateTemplate().save(song);
 		if (newSong) {
 			fireSongAdded(song);
 		} else {
 			fireSongChanged(song);
 		}
 	}
 
 	public void save(Artist artist) {
 		getHibernateTemplate().save(artist);
 	}
 	
 	public void save(Instrument instr) {
 		getHibernateTemplate().save(instr);
 	}
 
 	public void save(AIBag aibag) {
 		getHibernateTemplate().save(aibag);
 	}
 
 	@SuppressWarnings("unchecked")
 	public IUser findUserByName(String username) {
 		IUser result = null;
 		List<IUser> results = getHibernateTemplate().findByNamedParam(
 				"from User u where u.nickname=:name", "name", username);
 		if (results.size() > 0) {
 			result = results.get(0);
 		}
 		return result;
 	}
 	
 	private void appendSongIDsToPlaylist(Playlist playlist, List<Long> songids) {
 		if(songids==null) {
 			return;
 		}
 		int counter=playlist.getSongs().size()+1;
 		for (Long songid : songids) {
 			playlist.addSong(getSongById(songid),counter++);
 		}
 	}
 
 	/**
 	 * Returns a Playlist with a maximum of amount songs.
 	 * @param Specifies a title for the playlist
 	 * @param amount The maximum amount of songs
 	 * @param user The User, to select the Toplist for. When
 	 * this parameter is null anonymous statistics are returned
 	 * @param eventkind The eventkind to base the top-list on
 	 * @param daybegin Specifies the Date from which Events are considered
 	 * Set this value to null to consider all Events.
 	 * @param dayend Specifies the last date to be consideren.
 	 * Set this value to null to consider all events after daybegin
 	 * @param bags Specifies a List of Keywordbags. If this is a non-null
 	 * parameter, all songs in the resulting Playlist will have a Keywordbag that
 	 * is any of the Keywordbags specified.
 	 * @return A Playlist containing the specified criteria, sorted by popularity
 	 */
 	@SuppressWarnings("unchecked")
 	private Playlist getTopSongsInternal(String title, int amount, final IUser user, final int eventkind, final Date daybegin, Date dayend, List<Keywordbag> bags) {
 		Playlist result = new Playlist();
 		Map<String,Object> params = new HashMap<String,Object>();
 		StringBuilder sb = new StringBuilder();
 
 		sb.append("select ev.song.id from Event ev where ev.eventkind=:kind ");
 		params.put("kind",eventkind);
 		
 		if (user!=null) {
 			sb.append("and ev.user=:user ");
 			params.put("user",user);
 		}
 		
 		if (daybegin!=null) {
 			sb.append("and ev.moment>=:daybegin ");
 			params.put("daybegin",daybegin);
 			result.setFilterBegin(daybegin);
 			if (dayend!=null) {
 				sb.append("and ev.moment<:dayend ");
 				params.put("dayend",dayend);
 				result.setFilterEnd(dayend);
 			}
 		}
 		
 		if (bags!=null && bags.size()>0) {
 			sb.append("and ev.song.keywordbag.id in (");
 			Iterator<Keywordbag> it = bags.iterator();
 			while (it.hasNext()) {
 				sb.append(it.next().getId());
 				if (it.hasNext()) {
 					sb.append(",");
 				}
 			}
 			sb.append(") ");
 		}
 		
 		sb.append("group by ev.song.id order by count(ev.id) desc, max(ev.moment) desc)"); 
 		
 		List<Long> l = search(sb.toString(),params,amount);
 		this.appendSongIDsToPlaylist(result,l);
 		result.setName(title);
 		return result;
 	}
 	
 	/**
 	 * Queries the database for the list of songs inserted between two dates.
 	 * @param title The title to use for the Playlist
 	 * @param daybegin The timestamp from which to start counting (inclusive).
 	 * @param dayend The timestamp to stop counting at (exclusive).
 	 * @return A Playlist, containing the requested songs.
 	 */
 	@SuppressWarnings("unchecked")
 	private Playlist getNewSongs(String title, Date daybegin, Date dayend) {
 		String hql = "from Song s where s.inserted>=:daybegin and s.inserted<:dayend " +
 			"order by s.inserted desc";
 
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("daybegin",daybegin);
 		params.put("dayend",dayend);
 
 		List<Song> l = search(hql,params,0);
 		
 		Playlist result = new Playlist();
 		result.setName(title);
 		int counter = 1;
 		for (Song s : l) {
 			result.addSong(s,counter++);
 		}
 		return result;
 	}
 	
 	/**
 	 * Works together with the ConsistencyChecker to scan for songs with
 	 * broken filesystem links. This Playlist is intended to use to make
 	 * repairs in the database.
 	 * @param title The title to use for the Playlist
 	 * @return A Playlist of songs with broken filesystem links.
 	 */
 	private Playlist getBrokenSongs(String title) {
 		final int maxSize = 250;
 		DenseSet errors = ConsistencyChecker.getBrokenSongIDs();
 		int size = errors.size();
 		
 		Playlist result = new Playlist();
 		if (size>maxSize) {
 			title = title + " (first "+maxSize+" shown)";
 		}
 		result.setName(title);
 		
 		int counter = 0;
 		while (counter<maxSize && counter<size) {
 			long songid = errors.get(counter);
 			Song s = getSongById(songid);
 			result.addSong(s,counter++);
 		}
 		
 		return result;
 	}
 	
 	private Playlist getTopSongs(String title, int amount, IUser user, int eventkind, Date daybegin, Date dayend) {
 		Playlist result = getTopSongsInternal(title,amount,user,eventkind,daybegin,dayend,null);
 		
 		if (daybegin!=null && dayend!=null) {
 			Date olddaybegin = DateTools.previousMonthEnd(daybegin);
 			Date olddayend = DateTools.previousMonthEnd(dayend);
 			//We create a toplist of the period before the specified one to make it possible
 			//to show the difference of position of songs in these two periods
 			result.setPrevious( getTopSongsInternal(title,amount,user,eventkind,olddaybegin,olddayend,null) );
 		}
 		
 		return result;
 	}
 	
 	@SuppressWarnings("unchecked")
 	private Playlist getSongsPlayedAt(String title, IUser user, Date daybegin, Date dayend) {
 		Playlist result = new Playlist();
 		
 		StringBuilder sb = new StringBuilder();
 		Map<String,Object> params = new HashMap<String,Object>();
 		
 		sb.append("select e.song from Event e where e.moment>=:daybegin and e.moment<:dayend and e.eventkind=:kind ");
 		params.put("daybegin",daybegin);
 		params.put("dayend",dayend);
 		params.put("kind",Event.played);
 		
 		if (user!=null) {
 			sb.append("and e.user=:user ");
 			params.put("user",user);
 		}
 		sb.append("order by e.moment desc");
 		
 		List<Song> l = search(sb.toString(),params,0);
 		
 		result.setName(title);
 		int counter = 1;
 		for (Song s : l) {
 			result.addSong(s,counter++);
 		}
 		
 		return result;
 	}
 
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#getBandByName(java.lang.String)
 	 */
 	@SuppressWarnings("unchecked")
 	public Playlist getPlaylistByName(String name) {
 		String sql = "from Playlist p where lower(p.name)=:name order by p.inserted";
 		List<Playlist> playlistlist = getHibernateTemplate().findByNamedParam(sql,
 					new String[] {"name"},
 					new Object[] {LinkableAbs.normalizeName(name).toLowerCase()});
 		return playlistlist.size()==0 ? null : playlistlist.get(0);
 	}
 
 	public Playlist getPlaylistById(long id, IUser user) {
 		PlaylistKey key = new PlaylistKey(id);
 		if (key.isSpecial()) {
 			return getSpecialPlaylist(key.getKind(),user,key.getFilter());
 		} else {
 			return (Playlist) getHibernateTemplate().get(Playlist.class,id);
 		}
 	}
 
 	private Playlist getSpecialPlaylist(int kind, IUser user, Date filter) {
 		if (user==null && kind>-1000) kind-=1000; //Get anonymous stats when user==null
 		
 		Calendar begin = new GregorianCalendar();
 		begin.set(Calendar.HOUR_OF_DAY,0);
 		begin.set(Calendar.MINUTE,0);
 		begin.set(Calendar.SECOND,0);
 		
 		Calendar end = new GregorianCalendar();
 		end.set(Calendar.HOUR_OF_DAY,23);
 		end.set(Calendar.MINUTE,59);
 		end.set(Calendar.SECOND,59);
 		
 		Date prevmonth = DateTools.previousMonthEnd(filter);
 		Date endofmonth = DateTools.endOfMonth(filter);
 		String dateDesc = DateTools.formatDate(filter,"MMMMM yyyy");
 		
 		//TODO Use the enum-type for Dynamic Playlists 
 		switch (kind) {
 		case -1 : return getTopSongs(user+"'s top 100",100,user,Event.played,null,null);
 		case -2 : return getSongsPlayedAt("Songs played today by "+user,user,begin.getTime(),end.getTime()); 
 		case -3 : return getTopSongs(user+"'s top 100 most requested songs",100,user,Event.requested,null,null);
 		case -4 : return getTopSongs(user+"'s top 25 of "+dateDesc,25,user,Event.played,prevmonth,endofmonth);
 		case -5 : return getTopSongs(user+"'s top 25 requested of "+dateDesc,25,user,Event.requested,prevmonth,endofmonth);
 		case -6 : return getTopSongs(user+"'s horrible 100",100,user,Event.skipped,null,null);
 		case -7 : return getForgottenSongs(user);
 		case -8 : {
 			begin.setTime(filter);
 			begin.set(Calendar.HOUR_OF_DAY,0);
 			begin.set(Calendar.MINUTE,0);
 			begin.set(Calendar.SECOND,0);
 			begin.set(Calendar.MONTH,0);
 			begin.set(Calendar.DAY_OF_MONTH, 1);
 			
 			end.setTime(filter);
 			end.set(Calendar.HOUR_OF_DAY,23);
 			end.set(Calendar.MINUTE,59);
 			end.set(Calendar.SECOND,59);
 			end.set(Calendar.MONTH,11);
 			end.set(Calendar.DAY_OF_MONTH,31);
 			return getTopSongs(user+"'s top 100 in "+DateTools.formatDate(begin.getTime(), "yyyy"),100,user,Event.played,begin.getTime(),end.getTime());
 		}
 		
 		//------------------ Anonymous stats
 		case -1001 : return getTopSongs("Top 100",100,null,Event.played,null,null);
 		case -1002 : return getSongsPlayedAt("Songs played today",null,begin.getTime(),end.getTime()); 
 		case -1003 : return getTopSongs("Top 100 most requested songs",100,null,Event.requested,null,null);
 		case -1004 : return getTopSongs("Top 25 of "+dateDesc,25,null,Event.played,prevmonth,endofmonth);
 		case -1005 : return getTopSongs("Top 25 requested of "+dateDesc,25,null,Event.requested,prevmonth,endofmonth);
 		case -1006 : return getTopSongs("Horrible 100",100,null,Event.skipped,null,null);
 		case -1007 : return getForgottenSongs(null);
 		
 		case -2001 : return getNewSongs("Songs inserted in "+dateDesc,prevmonth,endofmonth);
 		case -2002 : return getBrokenSongs("Songs that don't have a correct filesystem-link");
 		default : return null;
 		}
 	}
 
 	/**
 	 * Lists a maximum amount of 25 Songs, with the following properties:
 	 * <ul>
 	 * <li>The Songs have not been played, skipped, downloaded or requested at 
 	 * all during the last two years.</li>
 	 * <li>The Songs have been played at least 10 times.</li>
 	 * </ul>
 	 * The list is ordered to the plays/year ratio. 
 	 * 
 	 * @param user The User for who to create this list for (may be null).
 	 * @return A Playlist, containing at most 25 Songs.
 	 */
 	@SuppressWarnings("unchecked")
 	protected Playlist getForgottenSongs(IUser user) {
 		Playlist result = new Playlist();
 		result.setName(user + "'s forgotten songs");
 		
 		StringBuilder hql = new StringBuilder();
 		hql.append("select s.id from Song s, Event e "); 
 		hql.append("where s=e.song ");
 		hql.append("and s.id in ( ");
 		hql.append("select plays.song.id from Event plays where plays.user=:user and plays.eventkind=:eventkind group by plays.song.id having max(plays.moment)<:twoyearsago and count(plays.id)>=10");
 		hql.append(")");
 		if (user!=null) hql.append("and e.user=:user "); 
 		hql.append("group by s.id, s.inserted "); 
 		hql.append("having max(e.moment)<:twoyearsago ");
 		hql.append("order by (:twoyearsago-s.inserted)/count(e.id)"); 
 		//FIXME Does not work in HSQL
 		//Timestamp - Timestamp is Interval in Postgres, which you can divide by something
 		//Timestamp - Timestamp remains Timestamp in HSQL, which you cannot divide.
 
 		Map params = new HashMap<String, Object>();
 		params.put("user", user);
 		params.put("eventkind", Event.played);
 		Date now = new Date();
 		Date twoyearsago = new Date(now.getTime()- (2L*365*24*60*60*1000) );
 		params.put("twoyearsago", twoyearsago);
 		List<Long> songIDs = search(hql.toString(), params, 25); 
 			
 		int counter = 0;
 		while (counter<songIDs.size()) {
 			long songid = songIDs.get(counter);
 			Song s = getSongById(songid);
 			result.addSong(s,++counter);
 		}
 		
 		return result;
 	}
 
 	public IUser getUserById(long userId) {
 		return (IUser) getHibernateTemplate().get(User.class, userId);
 	}
 
 	@SuppressWarnings("unchecked")
 	public IUser findUserByNamePassword(String username, String password) {
 		if(username==null) {
 			return null;
 		}
         IUser gebruiker = null;
         String encryptedPassword = Encrypter.encrypt(password);
         List<IUser> gebrList = getHibernateTemplate().findByNamedParam(
                 "from User p where p.loginname=:inlognaam and p.password=:password",
                 new String[] { "inlognaam", "password"},
                 new Object[] { username, encryptedPassword});
         if (gebrList != null && !gebrList.isEmpty()) {
         	gebruiker = (IUser) gebrList.get(0);
         }
         return gebruiker;
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<IUser> listUsers() {
 		return (List<IUser>) getHibernateTemplate().find("from User u order by u.loginname");
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<IUser> findUserByLoginname(String loginname) {
 		if(loginname==null) {
 			return new Vector<IUser>();
 		}
 		return getHibernateTemplate().findByNamedParam(
 					"from User p where p.loginname=:inlognaam",
 					new String[]{"inlognaam"},
 					new String[]{loginname});
 	}
 
 	@SuppressWarnings("unchecked")
 	public IUser getUserByLoginname(String inlognaam) {
 		List<IUser> l = getHibernateTemplate().findByNamedParam("from User p where p.loginname=:inlognaam",
 			new String[]{"inlognaam"},
 			new Object[]{inlognaam});
 		return (l.size()>0) ? l.get(0) : null;
 	}
 	
 	public void save(IUser user) {
 		getHibernateTemplate().saveOrUpdate(user);
 	}
 	
 	public void delete(IUser user) {
 		getHibernateTemplate().delete(user);
 	}
 	
 	public Role getRoleById(int roleId) {
 		return (Role) getHibernateTemplate().get(Role.class, roleId);
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Role> listRoles() {
 		return (List<Role>) getHibernateTemplate().find("from Role r order by r.name");
 	}
 	
 	public void save(Role role) {
 		getHibernateTemplate().saveOrUpdate(role);
 	}
 	
 	public Authority getAuthorityById(int authorityId) {
 		return (Authority) getHibernateTemplate().get(Authority.class, authorityId);
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Authority> listAuthorities() {
 		return (List<Authority>) getHibernateTemplate().find("from Authority a order by a.name");
 	}
 	
 	public void save(Authority authority) {
 		getHibernateTemplate().saveOrUpdate(authority);
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<Playlist> listPlaylists(Band band) {
 		return getHibernateTemplate().findByNamedParam(
 				"from Playlist p where p in (" +
 				"select distinct (ps.playlist) from Contract_PS ps, Song s "+
 				"where ps.song=s and s.band=:band) order by p.releasedate, p.name",
 				new String[]{"band"},
 				new Object[]{band});
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<Playlist> listPlaylists(Song song) {
 		return getHibernateTemplate().findByNamedParam(
 				"from Playlist p where p in (" +
 				"select distinct (ps.playlist) from Contract_PS ps "+
 				"where ps.song=:song) order by p.releasedate, p.name",
 				new String[]{"song"},
 				new Object[]{song});
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Playlist> listPlaylists() {
 		return getHibernateTemplate().find("from Playlist p");
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Playlist> listPodcasts() {
 		return getHibernateTemplate().find("from Playlist p where p.link is not null");
 	}
 	
 	public void evictSong(long songId) {
 		Song song = getSongById(songId);
 		getHibernateTemplate().evict(song);
 	}
 
 	public void evict(Object o) {
 		getHibernateTemplate().evict(o);
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Object[]> listBands(IUser user) {
 		Map<String,Object> params = new HashMap<String,Object>();
 		StringBuffer sb = new StringBuffer();
 		sb.append("select b.id, b.name, sum(case when ev.eventkind="+Event.played+" then 1 else 0 end), ");
 		sb.append("sum(case when ev.eventkind="+Event.skipped+" then 1 else 0 end)");
 		sb.append(" from Song s join s.band b left outer join s.events ev");
 		sb.append(" with ev.moment>:startdate ");
 
 		if(user!=null) {
 			sb.append("and ev.user.id=:userid");
 			params.put("userid",user.getId());
 		}
 		sb.append(" group by b.id, b.name, b.sortname");
 		sb.append(" order by b.sortname");
 		
 		Calendar lastYear = new GregorianCalendar();
 		lastYear.add(Calendar.YEAR,-1);
 
 		params.put("startdate",lastYear.getTime());
 
 		return search(sb.toString(),params,0);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#listKeywords()
 	 */
 	@SuppressWarnings("unchecked")
 	public List<Keyword> listKeywords() {
 		return getHibernateTemplate().find("from Keyword k");
 	}
 
 	
 	@SuppressWarnings("unchecked")
 	public List<Object[]> listKeywords(IUser user, List<Keywordbag> bags) {
 		/*
 		 * select k.id, k.name, count(ev.id) as co from keyword k, keywordbag kwb, song s left join event ev on ev.song_id=s.id and ev.moment>'2006.01.01' and (ev.eventkind=2 or ev.eventkind=3) and ev.user_id=2
 where s.kbrel_id=kwb.id and k.id=kwb.keyword_id
 group by k.id, k.name
 order by co desc
 		 */
 		/* Ha, dat kan nog veel ingewikkelder!
 	     * select keyword2_.id as col_0_0_, keyword2_.name as col_1_0_, count(events5_.id) as col_2_0_ 
 	     * from s_kb_relation keywordbag0_ 
 	     * left outer join keywordbag keywords1_ on keywordbag0_.id=keywords1_.bag_id 
 	     * left outer join keyword keyword2_ on keywords1_.keyword_id=keyword2_.id, song song3_ 
 		 * inner join s_kb_relation keywordbag4_ on song3_.kbrel_id=keywordbag4_.id 
 		 * left outer join event events5_ on song3_.id=events5_.song_id and (events5_.moment>'2006.01.01'  and events5_.eventkind=2 and events5_.user_id=100) 
 		 * where keywordbag4_.id=keywordbag0_.id 
 		 * group by keyword2_.id , keyword2_.name 
 		 * order by keyword2_.name		 */
 		StringBuilder sb = new StringBuilder();
 		
 		sb.append("select k.id, k.name, sum(case when ev.eventkind="+Event.played+" then 1 else 0 end), ");
 		sb.append("sum(case when ev.eventkind="+Event.skipped+" then 1 else 0 end)");
 		sb.append(" from Keywordbag kwb left join kwb.keywords k,");
 		sb.append("  Song s join s.keywordbag skwb left join s.events as ev ");
 		sb.append(" with ev.moment>:startdate and ev.user.id=:userid ");
 		sb.append(" where skwb=kwb and k.id is not null");
 
 		if (bags!=null) {
 			// If the bags is non-null and there are no keywords in the bag,
 			// then the result should be empty as well.
 			if (bags.size()==0) {
 				return null;
 			}
 			sb.append(" and kwb.id in(");
 			Iterator<Keywordbag> it = bags.iterator();
 			while (it.hasNext()) {
 				sb.append(it.next().getId());
 				if (it.hasNext()) {
 					sb.append(",");
 				}
 			}
 			sb.append(")");
 		}
 		sb.append(" group by k.id, k.name ");
 		sb.append(" order by k.name");
 
 		Calendar lastYear = new GregorianCalendar();
 		lastYear.add(Calendar.YEAR,-1);
 
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("userid",user.getId());
 		params.put("startdate",lastYear.getTime());
 
 		return search(sb.toString(),params,0);
 	}
 	
 	@SuppressWarnings("unchecked")
 	private List<Keywordbag> listKeywordbagsInternal(Collection<Keyword> keywords, boolean exactmatch) {
 		if (keywords==null) return null;
 		if (keywords.size()==0) return null;
 
 		Map<String,Object> params = new HashMap<String,Object>();
 
 		StringBuilder sb = new StringBuilder();
 		sb.append("select kwb.id from Keywordbag kwb");
 		if(exactmatch) {
 			sb.append(" where kwb.keywords.size=:size ");
 		} else {
 			sb.append(" where kwb.keywords.size>=:size ");
 		}
 		
 		Iterator<Keyword> it = keywords.iterator();
 		int keywordcount = 0;
 		while (it.hasNext()) {
 			keywordcount++;
 			Keyword kw = it.next();
 			String paramname = "k"+String.valueOf(keywordcount);
 			sb.append(" and :");
 			sb.append(paramname);
 			sb.append(" in elements(kwb.keywords)");
 			params.put(paramname, kw);
 		}
 		params.put("size",keywordcount);
 		
 		List<Long> kwbIds = search(sb.toString(),params,0);
 		
 		if (kwbIds==null) {
 			return null;
 		} else {
 			List<Keywordbag> bags = new LinkedList<Keywordbag>();
 			for (Long kwbid : kwbIds) {
 				bags.add(getKeywordBagById(kwbid));
 			}
 			return bags;
 		}
 	}
 	
 	public List<Keywordbag> listKeywordsBags(List<Keyword> keywords) {
 		/* 	select bag_id, count(id) from keywordbag where keyword_id in (1986,1987)
 		 * 	group by bag_id having count(bag_id)>=2
 		 */
 		return listKeywordbagsInternal(keywords,false);
 	}
 	
 	public Keywordbag getKeywordsBag(Collection<Keyword> keywords) {
 		/* 	select bag_id, count(id) from keywordbag where keyword_id in (1986,1987)
 		 * 	group by bag_id having count(bag_id)==2
 		 */
 		List<Keywordbag> bags = listKeywordbagsInternal(keywords,true);
 		return bags==null ? null : bags.size()==0 ? null : bags.get(0);
 	}
 
 	public Playlist songsByKeywordbags(List<Keywordbag> bags, IUser user, int maxResults) {
 		String title = "All songs with keywordbags...";
 		Date daybegin = DateTools.currentDate();
 		Calendar lastYear = new GregorianCalendar();
 		lastYear.add(Calendar.YEAR,-1);
 		return getTopSongsInternal(title,maxResults,user,Event.played,lastYear.getTime(),daybegin,bags);
 	}
 	
 	@SuppressWarnings("unchecked")
 	private Playlist songsByKeywordsInternal(List<Keyword> keywords, IUser user) {
 		//TODO If user is set, sort by playcount
 		/* select s.*, kwb.* from song s, keywordbag kwb, keyword k where k.id=1
 		 * and kwb.keyword_id=k.id and s.kbrel_id=kwb.id
 		 */
 		//TODO Currently maxed at 250 items, should be configurable
 		Playlist result = new Playlist();
 		if (keywords.size()==0) {
 			result.setName("");
 		} else {
 			StringBuilder sb = new StringBuilder();
 			//Find the bag(s) that containt the keywords mentioned return the
 			//songs in those bag(s)
 			sb.append("select s from Keywordbag kwb left join kwb.keywords as k, Song s where k in (:keywords) ");
 			sb.append("and s.keywordbag=kwb.id order by s.name");
 			
 			Map<String, Object> params = new HashMap<String,Object>();
 			params.put("keywords", keywords);
 			List<Song> l = search(sb.toString(),params,250);
 			
 			result.setName("All songs with keyword '"+keywords+"'");
 			int counter = 1;
 			for (Song s : l) {
 				result.addSong(s,counter++);
 			}
 		}
 	
 		return result;
 	}
 	
 	public Playlist songsByKeyword(long keywordid) {
 		Keyword keyword = getKeywordById(keywordid);
 		List<Keyword> keywords = new LinkedList<Keyword>();
 		keywords.add(keyword);
 		return songsByKeywordsInternal(keywords,null);
 	}
 	
 	public Playlist songsByKeywords(List<Keyword> keywords, IUser user) {
 		return songsByKeywordsInternal(keywords,user);
 	}
 
 	public Playlist songsByKeywordIds(List<Long> keywordIds, IUser user) {
 		List<Keyword> keywords = new LinkedList<Keyword>();
 		if (keywordIds!=null) {
 			for (Long keywordid : keywordIds) {
 				Keyword keyword = getKeywordById(keywordid);
 				keywords.add(keyword);
 			}
 		}
 		return songsByKeywordsInternal(keywords,null);
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<Keywordbag> listKeywordbags() {
 		return (List<Keywordbag>) getHibernateTemplate().find("from Keywordbag kbg");
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#getNeighbours(long, org.musicontroller.security.IUser)
 	 */
 	@SuppressWarnings("unchecked")
 	public Playlist getNeighbours(long songid, IUser user) {
 		/* 	select n.song_id, count(n.moment) from event ev, event n
 		 *	where ev.song_id=223 and ev.user_id=2 and ev.eventkind in (1,2)
   		 *	and n.user_id=2 and n.eventkind in (1,2)
   		 *	and n.song_id<>ev.song_id and (n.moment between ev.moment - time '0:10' and ev.moment + time '0:10')
   		 *	group by n.song_id
   		 *	having count(n.moment)>=5
   		 *	order by count(n.moment) desc 
 		 */
 		
 		Playlist result = new Playlist();
 		Map<String,Object> params = new HashMap<String,Object>();
 		StringBuilder sb = new StringBuilder();
 
 		sb.append("select n.song.id from Event ev, Event n ");
 		sb.append("where ev.song.id=:songid and ev.eventkind in (:kinds1) ");
 		if (user!=null) {
 			sb.append("and ev.user=:user ");
 			params.put("user",user);
 		}
 		sb.append("and n.user=ev.user and n.eventkind in (:kinds2) ");
 		sb.append("and n.song<>ev.song and n.moment between ev.moment+'-0:10' and ev.moment+'0:10' ");
 		sb.append("group by n.song.id ");
 		sb.append("having count(n.moment)>=5 ");
 		sb.append("order by count(n.moment) desc");
 		
 		Collection<Integer> kinds = new LinkedList<Integer>();
 		kinds.add(Event.played);
 		params.put("kinds1",kinds);
 		params.put("kinds2",kinds);
 		params.put("songid",songid);
 		
 		List<Long> l = search(sb.toString(),params,0);
 		if(l!=null) {
 			appendSongIDsToPlaylist(result,l);
 		}
 		result.setName("Neighbouring songs of song: "+songid);			
 		return result;
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Long[]> getDoubleSongs() {
 		/* 	select s1.id, s2.id, s1.name, s2.name, s1.length, s2.length
 		 * from song s1, song s2
 		 * where s1.id<s2.id and s1.name ilike s2.name
 		 * and s1.band_id=s2.band_id
 		 * and s1.length-s2.length between -10000 and 10000
 		 * order by s1.name 
 		 */
 		
 		StringBuilder sb = new StringBuilder();
 		sb.append("select s1.id, s2.id from Song s1, Song s2 ");
 		sb.append("where s1.id<s2.id and lower(s1.name) like lower(s2.name) ");
 		sb.append("and s1.band=s2.band and abs(s1.length-s2.length)<10000 ");
 		sb.append("order by s1.name");
 		List<Object[]> l = search(sb.toString(),new HashMap<String,Object>(),0);
 
 		//Transform the list to a list of Long-pairs
 		//TODO Won't a cast just work?
 		List<Long[]> thePairs = new LinkedList<Long[]>();
 		for (Object[] ll : l) {
 			Long[] pair = new Long[2];
 			pair[0] = (Long) ll[0];
 			pair[1] = (Long) ll[1];
 			thePairs.add(pair);
 		}
 		
 		//TODO Some similarities are not detected:
 		//TODO Billy vs Billie
 		//TODO Cant vs Can't
 		//TODO U vs You
 		
 		//TODO Same function with similar bands??? Mc Hammer vs MC Hammer...
 		
 		
 		return thePairs;
 	}
 
 	public void mergeSongs(Song keep, Song remove) {
 		//Oldest inserted-date stays.
 		try {
 			keep.setInserted(new Date(Math.min(keep.getInserted().getTime(), remove.getInserted().getTime())));
 		} catch (Exception e) {
 			LOG.error("Not-fatal error setting date to oldest version when merging song: "+e);
 		}
 		
 		//Copy events from 'remove' to 'keep', event-cache is updated.
 		for (Event ev : remove.getEvents()) {
 			keep.addEvent(ev.getMoment(), ev.getUser(), ev.getEventkind());
 		}
 		save(keep); //Implicitly informs SongChangeListeners.
 		
 		//Move 'remove's' occurences in playlists to 'keep'
 		for (Playlist pl : listPlaylists(remove)) {
 			for (Contract_PS ps : pl.getSongs()) {
 				if (ps.getSong().equals(remove)) {
 					ps.setSong(keep);
 				}
 			}
 			save(pl);
 		}
 		
 		//If the link-object of 'remove' points to an other file than the link
 		//of 'keep', then delete the file that 'remove' points to
 		//TODO Keep biggest (highest quality) file?
 		File file = null;
 		if (remove.getLink()!=null) {
 			if (keep.getLink()!=null) {
 				if (!remove.getLink().getFile().equals(keep.getLink().getFile())) {
 					file = remove.getLink().getFile();
 				}
 			}
 		}
 		getHibernateTemplate().delete(remove);
 		getHibernateTemplate().flush(); 
 		//Flush here, if it fails, an exception is thrown, rollback is invoked, file will not be deleted 
 
 		fireSongDeleted(remove); //Inform SongChangeListeners
 		if (file!=null) {
 			if (!file.delete()) {
 				LOG.error("Could not delete duplicate file: " + file.getAbsolutePath());
 			}
 		}
 		
 		LOG.info("Song "+remove.getLink().getUrl()+" merged with song "+keep.getLink().getUrl()+".");
 	}
 	
 	@SuppressWarnings("unchecked")
 	public void mergeBands(Band keep, Band remove) {
 		// Build a list of songs to move
 		StringBuilder sb = new StringBuilder();
 		sb.append("from Song s where s.band=:remove");
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("remove", remove);
 		List<Song> songs = search(sb.toString(), params,0);
 		// Move the songs in the list from "remove" to "keep".
 		for(Song s: songs) {
 			s.setBand(keep);
 			save(s);
 		}
 		// Eliminate the song to remove.
 		getHibernateTemplate().delete(remove);
 		LOG.info("All songs from band "+remove.getName()+" moved to band "+keep.getName()+
 				", band "+remove.getName()+" deleted.");
 	}
 
 	@SuppressWarnings("unchecked")
 	public Instrument searchInstrument(String instrname) {
 		Instrument result = null;
 		List<Instrument> instrlist = getHibernateTemplate().findByNamedParam(
 				"from Instrument i where lower(i.name)=:name",
 				new String[] { "name" },
 				new Object[] { LinkableAbs.normalizeName(instrname).toLowerCase() });
 		if (instrlist.size() > 0) {
 			result = instrlist.get(0);
 		}
 		return result;		
 	}
 
 	public int count(String hql, Map<String,Object> params) throws Exception {
 		Query query = searchInternal(hql,params,0,0);
 		int result = ((Long)query.iterate().next()).intValue(); 
 		return result;
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<Object[]> listMonthlySongCounts() {
 		String hql =	"select month(s.inserted), year(s.inserted), count(s.id) "+
 						"from Song s "+
 						"group by month(s.inserted),year(s.inserted) "+
 						"order by year(s.inserted),month(s.inserted)";
 		
 		return search(hql,null,0);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#listMonthlyStatistics(org.musicontroller.security.IUser)
 	 */
 	@SuppressWarnings("unchecked")
 	public Map<String, Integer> listMonthlyStatistics(IUser user) {
 		String hql = "select year(e.moment), month(e.moment), e.eventkind, count(e.id) from Event e " +
 				"where e.user=:user and e.eventkind>0 and e.moment is not null " +
 				"group by year(e.moment), month(e.moment), e.eventkind";
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("user", user);
 		List<Object[]> iresult = search(hql, params, 0);
 		
 		// We now process the intermediate result, and spit out a result which
 		// conforms to the javadoc: Year, Month, Map<Eventkind, Integer>
 		Map<String, Integer> result = new TreeMap<String, Integer>(); //TreeMap guarantees sorted keys
 		for (Object[] obj : iresult) {
 			String key = obj[0].toString() + "," + obj[1].toString() + "," + obj[2].toString();
 			Integer value = 0;
 			if (obj[3] instanceof Integer) {
 				value = (Integer) obj[3];
 			} else if (obj[3] instanceof Long) {
 				value = ((Long) obj[3]).intValue();
 			}
 			result.put(key, value);	
 		}
 		return result;
 	}
 	
 	@SuppressWarnings("unchecked")
 	public List<Object[]> listNamableItems() {
 		List<Object[]> result = search("select s.name, s.id, 's' from Song s",null,0);
 		result.addAll(search("select i.name, i.id, 'i' from Instrument i",null,0));
 		result.addAll(search("select k.name, k.id, 'k' from Keyword k",null,0));
 		result.addAll(search("select a.lastname, a.id, 'a' from Artist a",null,0));
 		result.addAll(search("select b.name, b.id, 'b' from Band b",null,0));
 		result.addAll(search("select p.name, p.id, 'p' from Playlist p",null,0));
 		
 		return result;
 	}
 
 	
 	@SuppressWarnings("unchecked")
 	public AIBag getMostUsedAIBag(Band band) {
 		String hql = "select s.aibag.id from Song s where s.band=:band and s.aibag is not null group by s.aibag.id order by count(s.id) desc";
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("band",band);
 		
 		List<Long> bags = search(hql,params,1);
 		if (bags.size()>0) {
 			return getAIBagById(bags.get(0));
 		} else {
 			return null;
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	public List<AIBag> listAIBags() {
 		return (List<AIBag>) getHibernateTemplate().find("from AIBag ai");		
 	}
 
 	public void mergePlaylists(Playlist keep, Playlist delete) {
 		if(keep==null || delete==null) {
 			return;
 		}
 		for (Contract_PS songs : delete.getSongs()) {
 			Song song = songs.getSong();
 			keep.addSong(song, songs.getRowno());
 		}
 		save(keep);
 		delete.getSongs().clear();
 		save(delete);
 		getHibernateTemplate().delete(delete);
 	}
 
 	public void deleteArtist(Artist delete) {
 		if(delete==null) {
 			return;
 		}
 		getHibernateTemplate().delete(delete);
 	}
 
 	public void deleteAiBag(AIBag delete) {
 		if(delete==null) {
 			return;
 		}
 		getHibernateTemplate().delete(delete);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#openSession()
 	 */
 	public SessionFactory getSessionFactory2() {
 		return getSessionFactory();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.dao.Dao#registerSongChangeListener(org.musicontroller.SongChangeListener)
 	 */
 	public void registerSongChangeListener(SongChangeListener listener) {
 		_songChangeListeners.add(listener);
 	}
 	
 	/**
 	 * Informs listeners of a new Song.
 	 * @param song The new Song.
 	 */
 	private void fireSongAdded(Song song) {
 		LOG.debug("Informing " + _songChangeListeners.size()+" listeners about new Song with id: " + song.getId());
 		for (SongChangeListener listener : _songChangeListeners) {
 			listener.onSongAdded(song);
 		}
 	}
 
 	/**
 	 * Informs listeners of a deleted Song.
 	 * @param song The deleted Song.
 	 */
 	private void fireSongDeleted(Song song) {
 		LOG.debug("Informing " + _songChangeListeners.size()+" listeners about deleted Song with id: " + song.getId());
 		for (SongChangeListener listener : _songChangeListeners) {
 			listener.onSongDeleted(song);
 		}
 	}
 	
 	/**
 	 * Informs listeners of a changed Song.
 	 * @param song The changed Song.
 	 */
 	private void fireSongChanged(Song song) {
 		LOG.debug("Informing " + _songChangeListeners.size()+" listeners about changed Song with id: " + song.getId());
 		for (SongChangeListener listener : _songChangeListeners) {
 			listener.onSongChanged(song);
 		}
 	}
 	
 	public HibernateTemplate getSupport() {
 		return getHibernateTemplate();
 	}
 
 }