package org.musicontroller;
   
   import java.util.LinkedList;
   import java.util.List;
   import java.util.concurrent.CopyOnWriteArrayList;
   
   import org.apache.log4j.Logger;
   import org.musicontroller.core.Band;
   import org.musicontroller.core.Event;
  import org.musicontroller.core.Keyword;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Song;
  import org.musicontroller.security.IUser;
  import org.musicontroller.songselection.CandidateSelector;
  import org.musicontroller.songselection.LastPlayedContainer;
  import org.musicontroller.songselection.SongSelector;
  
  public class DJImpl implements DJ, SongChangeListener {
  	private static Logger LOG = Logger.getLogger(DJImpl.class);
  	
  	private static MusiController _musicontroller;
  	private SongSelector _songselector;
  	private CandidateSelector _candidateselector;
  	private List<Long> _requests;
  	private List<Long> _prediction;
  	private IUser _user;
  	private boolean _mustskip;
  	private long _nextMandatoryRequest;
  	private boolean _playing;
  	private LastPlayedContainer _lastplayed;
  	/**
  	 * A non DB-related version of the Song currently being played. Never null.
  	 */
  	private Song _currentSong;
  	private int _millisecondsplayed;
  	
  	public DJImpl() {
  		_requests = new CopyOnWriteArrayList<Long>();
  		_user = null;
  		_mustskip = false;
  		_nextMandatoryRequest = -1L;
  		_playing = false;
  		_prediction = null;
  		_lastplayed = new LastPlayedContainer();
  		_currentSong = new Song();
  		_currentSong.setBand(new Band());
  	}
  	
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#setPlaying(boolean)
  	 */
  	public void setPlaying(boolean playing) {
  		_playing = playing;
  	}
  	
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#setMusiController(org.musicontroller.MusiController)
  	 */
  	public void setMusiController(MusiController musicontroller) {
  		_musicontroller = musicontroller;
  	}
  	
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#getMusiController()
  	 */
  	public MusiController getMusiController() {
  		return _musicontroller;
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#getSongSelector()
  	 */
  	public SongSelector getSongSelector() {
  		return _songselector;
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#setSongSelector(org.musicontroller.songselection.SongSelector)
  	 */
  	public void setSongSelector(SongSelector selector) {
  		this._songselector = selector;
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#getCandidateSelector()
  	 */
  	public CandidateSelector getCandidateSelector() {
  		return _candidateselector;
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * @see org.musicontroller.DJ#setCandidateSelector(org.musicontroller.songselection.CandidateSelector)
 	 */
 	public void setCandidateSelector(CandidateSelector selector) {
 		_candidateselector = selector;
 	}
 	
 	/**
 	 * Selects a list of Songs that were chosen from the pool. Rules are applied
 	 * in the following order: 
 	 * <ol>
 	 * <li>If there has been a mandatory request, that request is returned.</li>
 	 * <li>If we have already made predictions, we return the first prediction/</li>
 	 * <li>If the requests parameter is set, those requests are returned</li>
 	 * <li>A new random selection from the pool is returned.</ul>
 	 * </ol>
 	 * @param requests An optional list of requests.
 	 * @return A list of songs, with the above rules applied.
 	 * @see #peek(int)
 	 */
 	private List<Song> selectCandidates(final List<Long> requests) {
 		// If we have a mandatory request, it preceeds all other requests.
 		List<Long> reqs;
 		if (_nextMandatoryRequest!=-1L) {
 			reqs = new LinkedList<Long>();
 			reqs.add(_nextMandatoryRequest);
 		} else {
 			if (_prediction!=null && _prediction.size()>0) {
 				//If we made a prediction, it preceeds 'free' selection
 				reqs = new LinkedList<Long>();
 				reqs.add(_prediction.get(0));
 				_prediction.remove(0);
 			} else {
 				reqs = requests;
 			}
 		}
 		return _candidateselector.selectCandidates(reqs);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#choose()
 	 * This method is synchronized to prevent simultaneous access to the 
 	 * internal lists of requests and predictions.
 	 */
 	public synchronized Song choose() {
 		if(getUser()==null) {
 			LOG.error("DJ has no user attached. The DJ can not play songs.");
 			return null;			
 		}
 		if(getMusiController()==null) {
 			LOG.error("DJ for user "+getUser().getName()+" has no MusiController attached. The DJ can not play songs.");
 			return null;
 		}
 		Song song = null;
 		try {
 			song = _songselector.selectSong(selectCandidates(_requests),_lastplayed,_user);
 			_nextMandatoryRequest=-1L; //If there was a mandatory request, it has been chosen, so reset this value.
 			// The song selector might return NULL if there are no more unplayed songs.
 			if(song!=null) {
 				_lastplayed.addToLastPlayed(song.getId());
 				_candidateselector.removeFromCandidates(song);
 				removeFromRequestsandPredictions(song.getId());
 				setCurrentSong(song);
 			}
 		} catch (Exception e) {
 			LOG.error(e);
 		}
 		return song;
 	}
 
 	/**
 	 * Sets the internal _currentSong variable with a copy of a Song object.
 	 * The internal _currentSong is and remains DB-independent.
 	 * @param song The new Song that is currently being played.
 	 */
 	private void setCurrentSong(Song song) {
 		_currentSong.setId(song.getId());
 		_currentSong.setName(song.getName());
 		_currentSong.getBand().setId(song.getBand().getId());
 		_currentSong.getBand().setName(song.getBand().getName());
 		_currentSong.setLength(song.getLength());
 		
 		List<Keyword> currentKeywords = new LinkedList<Keyword>();
 		if (song.getKeywordbag()!=null) {
 			for(Keyword kw : song.getKeywordbag().getKeywords()) {
 				Keyword currentkw = new Keyword();
 				currentkw.setId(kw.getId());
 				currentkw.setName(kw.getName());
 				currentKeywords.add(kw);
 			}
 		}
 		Keywordbag currentKeywordbag = new Keywordbag();
 		currentKeywordbag.setKeywords(currentKeywords);
 		_currentSong.setKeywordbag(currentKeywordbag);
 	}
 	
 	/**
 	 * Marks a Song as played. This adds a played-Event to the Song for the
 	 * current user. As a side effect, the Band- and Keywordpopularity lists
 	 * are updated.
 	 * @param songid The id of the Song that has just been played.
 	 */
 	private void markAsPlayed(long songid) {
 		getMusiController().saveSongEvent(songid,Event.played,_user.getId());
 		_songselector.addBandPlay(_currentSong.getBand().getId());
 		for (Keyword kw : _currentSong.getKeywordbag().getKeywords()) {
 			_songselector.addKeywordPlay(kw.getId());
 		}
 	}
 	
 	/**
 	 * Marks a Song as skipped. This adds a skipped-Event to the Song for the
 	 * current user. As a side effect, the Band- and Keywordpopularity lists
 	 * are updated.
 	 * @param songid The id of the Song that has just been skipped.
 	 */
 	private void markAsSkipped(long songid) {
 		_lastplayed.markLastSongAsSkipped();
 		getMusiController().saveSongEvent(songid,Event.skipped,_user.getId());
 		_songselector.addBandSkip(_currentSong.getBand().getId());
 		for (Keyword kw : _currentSong.getKeywordbag().getKeywords()) {
 			_songselector.addKeywordSkip(kw.getId());
 		}
 	}
 	
 	/**
 	 * Marks a song as requested. This adds a requested-Event to the Song for the
 	 * current user.
 	 * @param songid The id of the Song that has just been requested.
 	 */
 	private void markAsRequested(long songid) {
 		getMusiController().saveSongEvent(songid,Event.requested,_user.getId());
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#requestSong(long)
 	 * This method is synchronized to prevent simultaneous access to the 
 	 * internal lists of requests and predictions.
 	 */
 	public synchronized void requestSong(long songid) {
 		if(_user==null) {
 			LOG.info("Song request denied: user not logged on.");
 			return;
 		}
 		_requests.add(songid);
 		markAsRequested(songid);
 		_prediction = null;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#unrequestSong(long)
 	 * This method is synchronized to prevent simultaneous access to the 
 	 * internal lists of requests and predictions.
 	 */
 	public synchronized void unrequestSong(long songid) {
 		removeFromRequestsandPredictions(songid);
 		markAsSkipped(songid);
 	}
 
 	/**
 	 * Removes a song-ID from the requests and predictions. To be used when
 	 * a Song has been selected by the SongSelector.
 	 * @param songid The id to remove.
 	 */
 	private void removeFromRequestsandPredictions(long songid) {
 		_requests.remove(songid);
 			
 		if (_prediction!=null) {
 			//If a song was unrequested that was not requested but predicted
 			//The behaviour is the same: the song disappears from the list
 			//of upcoming songs.
 			_prediction.remove(songid);
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#skipSong()
 	 */
 	public void skipSong() {
 		_mustskip = true;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#mustSkip()
 	 */
 	public boolean mustSkip() {
 		return _mustskip;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#confirmSkip()
 	 */
 	public void confirmSkip() {
 		_mustskip = false;
 		markAsSkipped(_currentSong.getId());
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#confirmPlay()
 	 */
 	public void confirmPlay() {
 		markAsPlayed(_currentSong.getId());
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#playSong(long)
 	 */
 	public void playSong(long songid) {
 		_nextMandatoryRequest = songid;
 		skipSong();
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#getRequests()
 	 */
 	public List<Long> getRequests() {
 		return _requests;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#setUser(org.musicontroller.security.IUser)
 	 */
 	public void setUser(IUser user) {
 		_user = user;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#getUser()
 	 */
 	public IUser getUser() {
 		return _user;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#getCurrentSongId()
 	 */
 	public Song getCurrentSong() {
 		return _playing ? _currentSong : null;
 	}
 	
 	/*
 	 * This method is synchronized, because it is expensive. We don't want to
 	 * execute it more than needed. The result is cached anyway, to the
 	 * subsequent call to this method returns more or less instantly.
 	 * 
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#peek(int)
 	 */
 	public synchronized List<Long> peek(int count) {
 		List<Long> prediction = _prediction==null ? new LinkedList<Long>() : _prediction;
 		
 		//We predict a minimum of count songs, but requests are always predicted.
 		count = Math.max(count, _requests.size());
 
 		int toPredict = count - prediction.size();
 		if (toPredict==0) return _prediction;
 		LOG.debug("Asked for "+toPredict+" new predictions.");
 
 		//Create a list of requests that are not predicted yet.
 		List<Long> requestsCopy = new LinkedList<Long>();
 		for (Long l : _requests) {
 			if (!prediction.contains(l)) requestsCopy.add(l);
 		}
 
 		LastPlayedContainer lastplayedCopy = null;
 		try {
 			lastplayedCopy = _lastplayed.clone();
 		} catch (CloneNotSupportedException e) {
 			LOG.error("Error cloning lastplayedcontainer, continueing with a new one : " + e);
 			lastplayedCopy = new LastPlayedContainer();
 		}
 		//Add the predictions we already made to the lastplayed-list.
 		for (Long l : prediction) {
 			lastplayedCopy.addToLastPlayed(l);
 		}
 	
 		_prediction=null; //Should be null while predicting to kill side-effects
 		
 		//First, predict the order of all requests
 		while (requestsCopy.size()>0) {
 			Song song = getSongSelector().selectSong(selectCandidates(requestsCopy),lastplayedCopy,_user);
 			if (song!=null) {
 				lastplayedCopy.addToLastPlayed(song.getId());
 				requestsCopy.remove(song.getId());
 				prediction.add(song.getId());
 			}
 			toPredict--;
 		}
 		
 		if (toPredict>0) { //Only enter when we need some more predictions.
 			//For the rest of the predictions, we use Min(toPredict*10,100) candidates.
 			//We can use the _candidateselector here, because we already predicted
 			//the requests-order.
 			int toSelect = Math.min(100, _candidateselector.getCandidateCount()*toPredict);
 			List<Song> candidates = _candidateselector.selectCandidates(toSelect);
 			while (toPredict>0) {
 				Song song = getSongSelector().selectSong(candidates,lastplayedCopy,_user);
 				if (song!=null) {
 					lastplayedCopy.addToLastPlayed(song.getId(), true);
 					requestsCopy.remove(song.getId());
 					prediction.add(song.getId());
 					candidates.remove(song);
 				}
 				toPredict--;
 			}
 		}
 		_prediction = prediction;
 		
 		return _prediction;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#setPlayingTime(int)
 	 */
 	public void setPlayingTime(int millis) {
 		_millisecondsplayed = millis;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.DJ#getPlayingTime()
 	 */
 	public int getPlayingTime() {
 		return _millisecondsplayed;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.SongChangeListener#onSongAdded(org.musicontroller.core.Song)
 	 */
 	public void onSongAdded(Song song) {
 		_candidateselector.addToCandidates(song);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.SongChangeListener#onSongChanged(org.musicontroller.core.Song)
 	 */
 	public void onSongChanged(Song song) {
 		if (_currentSong.getId()==song.getId()) {
 			setCurrentSong(song);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.musicontroller.SongChangeListener#onSongDeleted(org.musicontroller.core.Song)
 	 * This method is synchronized to prevent simultaneous access to the 
 	 * internal lists of requests and predictions.
 	 */
 	public synchronized void onSongDeleted(Song song) {
 		_candidateselector.removeFromCandidates(song);
 		removeFromRequestsandPredictions(song.getId());
 	}
 
 }