package org.musicontroller.core;
   
   import java.text.SimpleDateFormat;
   import java.util.Date;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.Set;
   import java.util.TreeSet;
   
  public class Playlist extends LinkableAbs {
  	private Date releasedate,filterbegin,filterend;
  	private String comments;
  	private Link link;
  	private Set<Contract_PS> songs;
  	private Playlist previous;
  	
  	public Playlist() {
  		comments="";
  		link=null;
  		songs=new TreeSet<Contract_PS>(); //To preserve ordering (see mapping-file), this is a TreeSet
  		filterbegin=null;
  		filterend=null;
  		previous=null;
  	}
  	
  	/**
  	 * Adds a song to the playlist, with the indicated index number. If
  	 * the playlist already contains a song with the same index number then
  	 * the song will be added with index number 0.
  	 * @param song The song to add. Nothing is added if this is NULL.
  	 * @param index The requested index number.
  	 */
  	public void addSong(Song song,int index) {
  		if(song==null) {
  			return;
  		}
  		if (index>0) {
  			Iterator<Contract_PS> i = songs.iterator();
  			while (i.hasNext()) {
  				Contract_PS c = i.next();
  				if (c.getRowno()==index) {
  					index=0; // This index number is taken. Use 0 instead.
  					break;
  				}
  			}
  		}
  		
  		// Do not add the same song twice at index 0.
  		if(index==0) {
  			Iterator<Contract_PS> i = songs.iterator();
  			while (i.hasNext()) {
  				Contract_PS c = i.next();
  				if (c.getRowno()==0) {
  					Song index0Song = c.getSong();
  					if(index0Song.equals(song)) {
  						return;
  					}
  				}
  			}
  		}
  
  		Contract_PS contract = new Contract_PS();
  		contract.setPlaylist(this);
  		contract.setSong(song);
  		contract.setRowno(index);
  		songs.add(contract);
  	}
  	
  	public String getComments() {
  		return comments;
  	}
  	
  	public void setComments(String comments) {
  		this.comments = comments;
  	}
  	
  	public Link getLink() {
  		return link;
  	}
  	
  	public void setLink(Link link) {
  		this.link = link;
  	}
  	
  	public Date getReleasedate() {
  		return releasedate;
  	}
  	
  	public String getFormattedReleasedate() {
  		if (getReleasedate()==null) {
  			return "";
  		} else {
  			//TODO Doesn't really belong here...
  			SimpleDateFormat df = (SimpleDateFormat) SimpleDateFormat.getDateInstance();
  			df.applyPattern("dd-MM-yyyy");
  			return df.format(getReleasedate());
  		}
  	}
  	
 	public void setReleasedate(Date releasedate) {
 		this.releasedate = releasedate;
 	}
 
 	public Set<Contract_PS> getSongs() {
 		return songs;
 	}
 	
 
 	public void setSongs(Set<Contract_PS> songs) {
 		if (songs!=null) this.songs = songs;
 	}
 	
 	public Date getFilterBegin() {
 		return filterbegin;
 	}
 	
 	/**
 	 * You can set this value to indicate that this playlist's Songs' Events should be filtered
 	 * to a certain period. This makes it possible to show the amount of plays in one month
 	 * for instance.
 	 * @param filter
 	 */
 	public void setFilterBegin(Date filter) {
 		this.filterbegin = filter;
 	}
 	
 	public Date getFilterEnd() {
 		return filterend;
 	}
 	
 	public void setFilterEnd(Date filter) {
 		this.filterend = filter;
 	}
 	
 	/**
 	 * You can set this property to a non-null value, to indicate the previous state
 	 * of this playlist.
 	 * @param playlist Another Playlist
 	 */
 	public void setPrevious(Playlist playlist) {
 		this.previous = playlist;
 	}
 	
 	public Playlist getPrevious() {
 		return previous;
 	}
 	
 	/**
 	 * Returns the rownumber of the given Song in this Playlist.
 	 * @param song The Song
 	 * @return The Rownumber, or 0 if the Song is not in this Playlist.
 	 */
 	public int getRownumberOf(Song song) {
 		int result = 0;
 		if (song!=null) {
 			for (Contract_PS psc : songs) {
 				if (song.equals(psc.getSong())) return psc.getRowno();
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * Returns the song at song index i in the playlist, or null if there
 	 * is no song at song index i. If the requested song index is 0, this
 	 * returns one of the songs listed at index 0, if any.
 	 * 
 	 * @param i The requested song index.
 	 * @return The song at song index 0, or null if there is no song at that
 	 *         index.
 	 */
 	public Song getSongAtIndex(int i) {
 		for (Contract_PS psc : songs) {
 			if(psc.getRowno()==i) {
 				return psc.getSong();
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * Constructs a playlist containing the song passed in the parameter. 
 	 * @param song The song to be entered in the playlist.
 	 * @return A playlist containing the song at index number 0. The playlist has no name.
 	 */
 	public static Playlist createInstance(Song song) {
 		Playlist playlist = new Playlist();
 		playlist.addSong(song, 0);
 		return playlist;
 	}
 	
 	/**
 	 * Explicitly specify that two playlist are equal only if they have the same id.
 	 * This makes it possible to have two playslists with the same
 	 * name (and other properties).
 	 */
 	public boolean equals(Object o) {
 		if(o instanceof Playlist) {
 			Playlist p = (Playlist) o;
 			return getId() == p.getId();
 		} else {
 			return false;
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#hashCode()
 	 */
 	@Override
 	public int hashCode() {
 		return Long.valueOf(getId()).hashCode();
 	}
 
 	public String getType() {
 		return "P";
 	}
 
 	/**
 	 * Returns the name of the Band performing on this Playlist. If there is more
 	 * than one Band performing on this Playlist, the result will be "Various".
 	 * @return The name of the Band.
 	 */
 	public String getBandname() {
 		String result = "Various";
 		Set<String> names = new HashSet<String>();
 		for (Contract_PS cps : getSongs()) {
 			names.add(cps.getSong().getBand().getName());
 			if (names.size()>1) {
 				return result;
 			}
 		}
 		return names.size()>0 ? names.iterator().next() : result;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		StringBuilder sb = new StringBuilder();
 		sb.append("[");
 		sb.append(getId());
 		sb.append("] ");
 		sb.append(getName());
 		for (Contract_PS contract : songs) {
 			sb.append("\n");
 			String rowno = Integer.toString(contract.getRowno());
 			for (int i=0;i<5-rowno.length();i++) {
 				sb.append(" ");
 			}
 			sb.append(rowno);
 			sb.append(" ");
 			sb.append(contract.getSong());
 		}
 		
 		return sb.toString();
 	}
 
 	/**
 	 * Adds a Song to the Playlist at a certain index, if the Playlist does
 	 * not already contain that Song. If the Playlist already contains the Song,
 	 * nothing happens.
 	 * Songs having a rownumber equal to or greater than the specified index, 
 	 * will shift one position.
 	 * @param song The Song.
 	 * @param index The index-position for the new Song.
 	 */
 	public void addSongIfNew(Song song, int index) {
 		int maxRowno = 0;
 		for (Contract_PS contract : getSongs()) {
 			if (contract.getRowno()>maxRowno) {
 				maxRowno = contract.getRowno();
 			}
 			if (contract.getSong().equals(song)) {
 				return;
 			}
 		}
 		
 		//Shift all Playlist-Song-Contracts which have an index >= index to make
 		//room for the new Song.
 		for (Contract_PS psc : songs) {
 			int idx = psc.getRowno();
 			if (idx>=index) {
 				psc.setRowno(idx+1);
 			}
 		}
 		addSong(song, index);
 	}
 
 }