package org.varienaja.comments;
   
   import java.util.Date;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.Set;
   import java.util.TreeSet;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import java.util.regex.PatternSyntaxException;
  
  import org.apache.log4j.Logger;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Contract_PS;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.dao.Dao;
  import org.musicontroller.model.Linkable;
  import org.varienaja.util.wikipedia.WikipediaException;
  import org.varienaja.util.wikipedia.WikipediaSearcher;
  
  /**
   * Service that is used for getting/processing Comments for Bands, 
   * Playlists, etc..
   * @author Varienaja
   * @version $Id: CommentService.java,v 1.1 2010/03/16 18:55:42 varienaja Exp $
   */
  public class CommentService {
  	private static final Logger log = Logger.getLogger(CommentService.class);
  	private static Dao _dao;
  	private static final String plPrefix = "review";
  	private static final String bndPrefix = "band";
  	
  	public void setDao(Dao dao) {
  		_dao = dao;
  	}
  	
  	public Dao getDao() {
  		return _dao;
  	}
  	
  	/**
  	 * Gets the Comments for a certain Playlist. If there could be no Comments found,
  	 * on local storage a try is made to download them from online sources. Hereafter,
  	 * the new Comments will be stored on local storage for faster future use.
  	 * @param playlist The Playlist to get Comments for.
  	 * @return The Comments in an ordered Set (ordered by date of revies, latest first)
  	 */
  	public Set<Comment> getComments(Playlist playlist) {
  		Set<Comment> reviews = CommentDAO.getCommentsFromCache(plPrefix, playlist.getId());
  		if (reviews==null) {
  			reviews = downloadComments(playlist);
  			CommentDAO.saveCommentsToCache(plPrefix, playlist.getId(),reviews);
  		}
  		return reviews;
  	}
  	
  	/**
  	 * Gets the Comments for a certain Band. If there could be no Comments found,
  	 * on local storage a try is made to download them from online sources. Hereafter,
  	 * the new Comments will be stored on local storage for faster future use.
  	 * @param band The Band to get Comments for.
  	 * @return The info as a Set of one Review.
  	 */
  	public Set<Comment> getComments(Band band) {
  		Set<Comment> reviews = CommentDAO.getCommentsFromCache(bndPrefix, band.getId());
  		if (reviews==null) {
  			reviews = downloadComments(band);
  			CommentDAO.saveCommentsToCache(bndPrefix, band.getId(),reviews);
  		}
  		return reviews;
  	}
  	
  	/**
  	 * Refreshes the Comments for a Playlist. It re-downloads Comments from
  	 * online sources, and merges them with the existing ones.
  	 * @param playlist The Playlist to refresh the Comments for.
  	 * @return Whether the Comments were changed.
  	 */
  	public boolean refreshComments(Playlist playlist) {
  		log.debug("Refreshing comments for playlist: "+playlist.getName());
  		Set<Comment> comments = CommentDAO.getCommentsFromCache(plPrefix, playlist.getId());
  		if (comments==null) {
  			comments = new TreeSet<Comment>();
  		}
  		int oldcount = comments.size();
  		if (comments.addAll(downloadComments(playlist))) { //Only save if the collection changed!
  			log.debug("Comments refreshed, we had "+oldcount+" reviews, now we have "+comments.size());
  			for (Comment review : comments) {
  				enhanceComment(review, playlist);
  			}
  			CommentDAO.saveCommentsToCache(plPrefix, playlist.getId(),comments);
  			return true;
  		} else {
  			log.debug("No new comments found online.");
  			return false;
  		}
 	}
 	
 	/**
 	 * Downloads Comments for a Playlist from online sources.
 	 * @param playlist The Playlist to download the Comments for.
 	 * @return The Comments in an ordered Set (ordered by date of revies, latest first)
 	 */
 	private Set<Comment> downloadComments(Playlist playlist) {
 		Set<Comment> comments = new TreeSet<Comment>();
 			
 		AmazonCommentService amazonService = new AmazonCommentService();
 		comments.addAll(amazonService.getComments(playlist));
 		//TODO Retrieve comments from other sources...
 		return comments;
 	}
 
 	/**
 	 * Downloads Comments for a Band from Wikipedia.
 	 * @param band The Band to download Comments for.
 	 * @return The Comments as a Set, containing one Review object.
 	 */
 	private Set<Comment> downloadComments(Band band) {
 		Set<Comment> reviews = new TreeSet<Comment>();
 	
 		String source = WikipediaSearcher.getExternalBandURL(band.getName());
 		Comment comment = new Comment(source, "", new Date());
 		String content = "";
 		try {
 			content = WikipediaSearcher.getBandInfo(band.getName());
 		} catch (WikipediaException e) {
 			log.error("Could not get comment for band: "+band.getName()+" from Wikipedia: "+e);
 		}
 		CommentElement elt = new CommentElement();
 		elt.setText(content);
 		elt.setType('T');
 		comment.addElement(elt);
 		
 		reviews.add(comment);
 		return reviews;
 	}
 
 	/**
 	 * Uses the information of the Playlist to enhance its Reviews. Plain
 	 * text is hereby transformed into hyperlinked text.
 	 * @param review A Review
 	 * @param playlist The playist we're enhancing reviews for.
 	 */
     protected void enhanceComment(Comment review, Playlist playlist) {
     	log.debug("Enhancing comment: "+review.getTitle());
     	//First, we de-enhance the playlist to get it back to plain text.
     	StringBuilder sb = new StringBuilder();
     	for (CommentElement elt : review.getElements()) {
     		sb.append(elt.getText());
     		sb.append(" ");
     	}
     	
     	//Now, we iterate over the levels of importance. During this phase,
     	//more and more plaintext will be converted into hyperlinked text.
     	//Rule 1: The order of hyperlinking is:
     	//        a. Band
     	//        b. Songs in this playlist
     	//        c. Other playlists of the same band
     	//        d. Songs of the same band in other playlists
     	//        e. Artists in this band
     	//        f. Genres, used in this playlist.
     	//        g. Other Genres
     	//        h. Other bands
     	//Rule 2: once hyperlinked, text can not be enhanced again.
     	Set<Linkable>[] mappings = new Set[8];
     	mappings[0] = getBands(playlist);
     	mappings[1] = getSongs(playlist);
     	mappings[2] = getPlaylists(playlist);
     	mappings[3] = getAllSongs(playlist);
     	mappings[4] = getArtists(playlist);
     	mappings[5] = getKeywords(playlist);
     	mappings[6] = getAllKeywords();
     	mappings[7] = getAllBands();
     	
     	for (Set<Linkable> mapping : mappings) {
     		Iterator<Linkable> it = mapping.iterator();
     		while (it.hasNext()) {
     			Linkable link = it.next();
     			try {
 		    		Pattern p = Pattern.compile("\\b\\Q" + link.getName() + "\\E\\b"); 
 	    			
 	    			boolean somethingHyperlinked = true;
 	    			while (somethingHyperlinked) {
 		    			//Put all reviewelements into an array, so we can mess with them
 		    			//without having the chance of ConcurrentModificationException.
 		    			CommentElement[] all = new CommentElement[0];
 		    			all = review.getElements().toArray(all);
 		    			somethingHyperlinked = false;
 		    	    	for (CommentElement elt : all) {
 		    	    		if (elt.isText()) { //Rule 2: only enhance not already enhanced stuff
 			    	    		String txt = elt.getText();
 			    	    		//TODO try to program something nifty in
 			    	    		//order to catch slightly misspelled texts.
 			    	    		
 			    	    		Matcher matcher = p.matcher(txt.toLowerCase());
 			    	    		if (matcher.find()) {
 			    	    			int index = matcher.start();
 			    	    			List<CommentElement> newElts = new LinkedList<CommentElement>();
 			    	    			
 			    	    			CommentElement before = new CommentElement();
 			    	    			before.setType('T');
 			    	    			before.setText(txt.substring(0,index));
 			    	    			
 			    	    			CommentElement changed = new CommentElement();
 			    	    			changed.setType(link.getType().charAt(0));
 			    	    			changed.setText(link.getName());
 			    	    			changed.setId(link.getId());
 			    	    			
 			    	    			CommentElement after = new CommentElement();
 			    	    			after.setType('T');
 			    	    			after.setText(txt.substring(index+link.getName().length()));
 			    	    			log.debug("Enhanced review with: "+changed.toString());
 			    	    			
 			    	    			newElts.add(before);
 			    	    			newElts.add(changed);
 			    	    			newElts.add(after);
 			    	    			
 			    	    			review.splitElement(elt, newElts);
 			    	    			somethingHyperlinked = true;
 			    	    		}
 		    	    		}
 		    	    	}
 	    			}
     			} catch (PatternSyntaxException e) {
     				log.error(e.getMessage());
     			} catch (Exception e) {
     				log.error(e.getMessage());
     			} finally {
     				it.remove();
     			}
     		}
     	}
     	log.debug("Enhancing comment done.");
 	}
 
 	/**
 	 * Returns a Set of all Bands known to MusiController.
 	 * @return A Set of Band objects.
 	 */
 	private Set<Linkable> getAllBands() {
 		return new HashSet<Linkable>(); //TODO Implement this.
 	}
 
 	/**
 	 * Returns a Set of all Keywords known to MusiController.
 	 * @return A Set of Keyword objects.
 	 */
 	private Set<Linkable> getAllKeywords() {
 		return new HashSet<Linkable>(); //TODO Implement this.
 	}
 
 	/**
 	 * Returns a Set of all Keyword which are present in the Playlist.
 	 * @param playlist The playlist
 	 * @return A Set of Keyword objects.
 	 */
 	private Set<Linkable> getKeywords(Playlist playlist) {
 		Set<Linkable> result = new HashSet<Linkable>();
 		for (Contract_PS cps : playlist.getSongs()) {
 			Keywordbag kwb = cps.getSong().getKeywordbag();
 			if (kwb!=null) {
 				result.addAll(kwb.getKeywords());
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * Returns a Set of all Artists which are present in the Playlist.
 	 * @param playlist The playlist
 	 * @return A Set of Artist objects.
 	 */
 	private Set<Linkable> getArtists(Playlist playlist) {
 		return new HashSet<Linkable>(); //TODO Implement this.
 	}
 
 	/**
 	 * Returns a Set of all Songs of all Bands which are present in the Playlist.
 	 * @param playlist The Playlist
 	 * @return A Set of Song objects, but not Songs from the Playlist of the parameter.
 	 */
 	private Set<Linkable> getAllSongs(Playlist playlist) {
 		Set<Linkable> result = new HashSet<Linkable>();
 		for (Linkable band : getBands(playlist)) {
 			Playlist allSongs = getDao().songsByBand(band.getId());
 			for (Contract_PS cps : allSongs.getSongs()) {
 				result.add(cps.getSong());
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * Returns a Set of all Playlists of all Bands which are present in the Playlist.
 	 * @param playlist The Playlist
 	 * @return A Set of Playlist objects.
 	 */
 	private Set<Linkable> getPlaylists(Playlist playlist) {
 		Set<Linkable> result = new HashSet<Linkable>();
 		for (Linkable band : getBands(playlist)) {
 			result.addAll(getDao().listPlaylists((Band) band));
 		}
 		return result;
 	}
 
 	/**
 	 * Returns a Set of all Songs which are present in the Playlist.
 	 * @param playlist The Playlist
 	 * @return A Set of Song objects.
 	 */
 	private Set<Linkable> getSongs(Playlist playlist) {
 		Set<Linkable> result = new HashSet<Linkable>();
 		for (Contract_PS cps : playlist.getSongs()) {
 			result.add(cps.getSong());
 		}
 		return result;
 	}
 
 	/**
 	 * Returns a Set of all Bands which are present in the Playlist.
 	 * @param playlist The Playlist
 	 * @return A Set of Band objects.
 	 */
 	private Set<Linkable> getBands(Playlist playlist) {
 		Set<Linkable> result = new HashSet<Linkable>();
 		for (Contract_PS cps : playlist.getSongs()) {
 			result.add(cps.getSong().getBand());
 		}
 		return result;
 	}
 
 }