package org.musicontroller.dao;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.Map.Entry;
  
  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.Instrument;
  import org.musicontroller.core.Keyword;
  import org.musicontroller.core.KeywordCycleException;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.gui.edit.AiRelationBean;
  import org.musicontroller.gui.edit.TrackList;
  import org.varienaja.util.StringUtil;
  
  /**
   * This class manages persistent keyword bag objects.
   * @author deksels
   * @version $Id: BagAndKeywordUtils.java,v 1.1 2010/03/16 18:55:42 varienaja Exp $
   */
  public class BagAndKeywordUtils {
  
  	/**
  	 * The Dao object, used for persisting changes to the
  	 * keyword bag objects.
  	 */
  	private static Dao _dao;
  	
  	/**
  	 * Tries to find a keyword bag containing all the keywords in this bag
  	 * plus the keyword in the parameter. Returns the bag when found or constructs
  	 * a new bag with the required keywords when it does not exist.
  	 * 
  	 * This will allways return a different bag than the bag on which the method was invoked!
  	 * 
  	 * @param bag The keyword bag to add the keyword to.
  	 * @param keyword The keyword to add.
  	 * @return the keywordbag containing all current keywords + the new keyword.
  	 */
  	public static Keywordbag addKeywordToBag(Keywordbag bag, Keyword keyword) {
  		if(bag==null || keyword==null) {
  			return null;
  		}
  		if (bag.getKeywords().contains(keyword)) {
  			return bag; //Keywords cannot be added twice
  		}
  		
  		Iterator<Keywordbag> i = getBags().iterator();
  		while (i.hasNext()) {
  			Keywordbag candidate = i.next();
  			if (candidate.getKeywords().size()==bag.getKeywords().size()+1) {
  				if (candidate.getKeywords().contains(keyword)) {
  					if (candidate.getKeywords().containsAll(bag.getKeywords())) {
  						return candidate;
  					}
  				}
  			}
  		}
  		//If we're here, there was no keywordbag found, so we'll create a new one.
  		Keywordbag newOne = new Keywordbag();
  		newOne.getKeywords().addAll(bag.getKeywords());
  		newOne.getKeywords().add(keyword);
  		_dao.save(newOne);
  		return newOne;
  	}
  	
  	/**
  	 * Tries to find a keyword bag with all keywords of this bag minus the
  	 * parameter keyword. Returns the bag when found. If not found, constructs
  	 * a new bag with the required keywords and return it.
  	 * 
  	 * @param bag The bag to remove the keyword from.
  	 * @param keyword The keyword to exclude.
  	 * @return A keyword bag with all keywords of this bag minus the keyword parameter.
  	 */
  	public static Keywordbag removeKeyWordFromBag(Keywordbag bag, Keyword keyword) {
  		if(bag==null || keyword==null) {
  			return null;
  		}
  		if (!bag.getKeywords().contains(keyword.getId())) {
  			return bag; //Keywords not in the List
  		}
  
  		List<Keyword> tmp = bag.getKeywords();
  		tmp.remove(keyword);
  		
 		Iterator<Keywordbag> i = getBags().iterator();
 		while (i.hasNext()) {
 			Keywordbag candidate = i.next();
 			if (candidate.getKeywords().size()==tmp.size()) {
 				if (!candidate.getKeywords().contains(keyword.getId())) {
 					if (candidate.getKeywords().containsAll(tmp)) {
 						return candidate;
 					}
 				}
 			}
 		}
 		
 		//If we're here, there was no keywordbag found, so we'll create a new one.
 		Keywordbag newOne = new Keywordbag();
 		newOne.getKeywords().addAll(tmp);
 		_dao.save(newOne);
 		return newOne;
 	}
 	
 	/**
 	 * Add a keyword to the song. The method will save the keyword and
 	 * the keyword bag, but not the song (permitting more edits). The method
 	 * will create a keyword bag for the song if none exists. If the song or
 	 * kw parameters is null, nothing happens.
 	 * 
 	 * @param song The song.
 	 * @param kw The keyword to add.
 	 */
 	public static void addKeywordToSong(Song song, Keyword kw) {
 		if(song==null || kw==null) {
 			return;
 		}
 		Keywordbag bag = song.getKeywordbag();
 		if(bag==null) {
 			bag = new Keywordbag();
 		}
 		Keywordbag newBag = BagAndKeywordUtils.addKeywordToBag(bag,kw);
 		song.setKeywordbag(newBag);
 		_dao.save(kw);
 		_dao.save(newBag);
 	}
 
 	/**
 	 * Locates the keyword in the database or constructs a new keyword
 	 * if there isn't one already. The returned keyword object is 
 	 * always persistent. Returns NULL if the keyword name is NULL or 
 	 * if the trimmed name is "".
 	 * 
 	 * @param keywordname The sought keyword name.
 	 * @return A keyword object with the specified keyword name.
 	 */
 	public static Keyword getKeyword(String keywordname) {
 		if(keywordname==null) {
 			return null;
 		}
 		Keyword kw = _dao.searchKeyword(keywordname);
 		if (kw==null) {
 			kw = new Keyword();
 			kw.setName(keywordname);
 			try {
 				kw.setParent(null);
 			} catch (KeywordCycleException e) {
 				// ignore: setParent(null) can not cause a KeywordCycleException.
 			}
 			_dao.save(kw);
 		}
 		return kw;
 	}
 	
 	/**
 	 * Returns a keyword bag containing exactly the keywords specified
 	 * as comma separated keywords in the argument. Empty keywords are ignored.
 	 * @param songKeywords A comma separated list of Keywords.
 	 * @return A KeywordBag containing exactly the keywords listed in
 	 *         the argument.
 	 */
 	public static Keywordbag getKeywordBag(String songKeywords) {
 		// Convert into a list of Keyword objects.
 		List<Keyword> keywordList = getKeywordList(songKeywords);
 		return getKeywordBag(keywordList);
 	}
 
 	/**
 	 * Returns a persistent keyword bag containing exactly the keywords in
 	 * the parameter.
 	 * @param keywords The list of keywords.
 	 * @return A keyword bag containing exactly the keywords in the list.
 	 */
 	public static Keywordbag getKeywordBag(Collection<Keyword> keywords) {		
 		if(keywords==null) {
 			keywords = new ArrayList<Keyword>();
 		}
 		Keywordbag result = _dao.getKeywordsBag(keywords);
 		
 		if(result==null) {
 			result = new Keywordbag();
 			result.getKeywords().addAll(keywords);
 			_dao.save(result);
 		}
 		return result;
 	}
 	
 	/**
 	 * Returns a list of keywords corresponding to the comma separated list
 	 * of keywords in the parameter.
 	 * @param keywords The comma separted list of keywords.
 	 * @return A list of keywords corresponding to the keyword names in the list.
 	 */
 	public static List<Keyword> getKeywordList(String keywords) {
 		Collection<String> setOfKeywords = StringUtil.getIndividualWords(keywords);
 		List<Keyword> keywordList = new ArrayList<Keyword>();
 		for (String kws : setOfKeywords) {
 			if(kws.trim().length()>0) {
 				keywordList.add(getKeyword(kws));
 			}
 		}
 		return keywordList;
 	}
 
 	/**
 	 * Returns an artist_instrument bag containing exactly the artist-instrument
 	 * relations specified in the argument. 
 	 * @param relations The set of artist instrument relations that must be present
 	 *                  in the result.
 	 * @return A KeywordBag containing exactly the artist-instrument relations in
 	 *         the argument.
 	 */
 	@SuppressWarnings("unchecked")
 	public static AIBag getAIBag(Set<AIRelation> relations) {
 		AIBag result = null;
 		// This query selects ai_bags containing a specific AIRelation.
 		String hql = "from AIBag bag " +
 				"left join bag.relations rel" +
 				" where rel.artist_id=:artistid and rel.instrument_id=:instrid";
 		Set<Long> remaining_candidates = new HashSet<Long>();
 		for(AIRelation rel: relations) {
 			Set<Long> bag_currentRelation = new HashSet<Long>();
 			long artistid = rel.getArtist_id();
 			long instrid = rel.getInstrument_id();
 			Map<String,Object> params = new HashMap<String,Object>();
 			params.put("artistid", artistid);
 			params.put("instrid", instrid);
 			List<AIBag> bags = _dao.search(hql, params, 0);
 			for(AIBag candidate: bags) {
 				// discard all candidates with a different number of relations.
 				if(candidate.getRelations().size()==relations.size()) {
 					long bag_candidate_id = candidate.getId();
 					bag_currentRelation.add(bag_candidate_id);
 				}
 			}
 			if(remaining_candidates.isEmpty()) {
 				remaining_candidates.addAll(bag_currentRelation);
 			} else {
 				Set<Long> removed = new HashSet<Long>();
 				for(long bag2_id: remaining_candidates) {
 					if(!bag_currentRelation.contains(bag2_id)) {
 						removed.add(bag2_id);
 					}
 				}
 				remaining_candidates.removeAll(removed);
 			}
 			// Stop if all remaining candidates are disqualified.
 			if(remaining_candidates.isEmpty()) {
 				break;
 			}
 		}
 		
 		if(remaining_candidates.isEmpty()) {
 			AIBag targetBag = new AIBag();
 			targetBag.getRelations().addAll(relations);
 			_dao.save(targetBag);
 			result = targetBag;
 		} else {
 			long result_bag_id = remaining_candidates.iterator().next();
 			result = _dao.getAIBagById(result_bag_id);
 		}
 		return result;
 	}
 
 	/**
 	 * Returns a String representation of all keywords in the bag,
 	 * listing all keywords separated by commas.
 	 * @param bag The keyword bag to list.
 	 * @return A comma separated list of commas in the keyword bag.
 	 */
 	public static String listKeywords(Keywordbag bag) {
 		StringBuilder result = new StringBuilder();
 		boolean putComma = false;
 		if(bag!=null) {
 			for(Keyword kw: bag.getKeywords()) {
 				String kwname = kw.getName();
 				// Ignore zero-length keywords.
 				if (kwname==null || kwname.length()<1) {
 					continue;
 				}
 				if(putComma) {
 					result.append(",");
 				} else {
 					putComma = true;
 				}
 				String kwName = kw.getName().toLowerCase();
 				result.append(StringUtil.capitalize(kwName));
 			}		
 		}
 		return result.toString();
 	}
 		
 	/**
 	 * Getter for the list of keyword bag objects.
 	 * @return The list of keyword bags.
 	 */
 	public static List<Keywordbag> getBags() {
 		return _dao.listKeywordbags();
 	}
 
 	/**
 	 * Getter for the list of Artist-Instrument bag objects.
 	 * @return The list of AIBags.
 	 */
 	public static List<AIBag> getAIBags() {
 		return _dao.listAIBags();
 	}
 	
 	/**
 	 * 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;
 	}
 
 	/**
 	 * Constructs a list of AiRelationBean objects from a playlist.
 	 * This method first constructs a hash of hashes containing information on the artists
 	 * playing instruments on tracks. A graphical rendition of this data-structure:
 	 * 
 	 * Hash<Artist>
 	 *   |__A
 	 *   |  |__Hash<Instrument>
 	 *   |       |__x
 	 *   |       |  |__List<trackno>
 	 *   |       |       |__1,2
 	 *   |       |__y
 	 *   |          |__List<trackno>
 	 *   |               |__1,2
 	 *   |__B
 	 *      |__Hash<Instrument>
 	 *           |__z
 	 *              |__List<trackno>
 	 *                   |__1
 	 *                   
 	 * Artist A plays Instrument x on tracks 1,2
 	 * Artist A plays Instrument y on track 1,2
 	 * Artist B plays Instrument z on track 2
 	 * 
 	 * Then, this data structure is translated into a list of AiRelationBean objects:
 	 * 
 	 * [ <"A","x,y",(1,2)> , <"B","z",(1)> ]
 	 *                   
 	 * This list is the final result.
 	 * 
 	 * @param playlist The playlist to build the aiRelationBeanList for.
 	 * @return A list of AiRelationBean objects with all artist-instrument relations in the source. 
 	 */
 	public static List<AiRelationBean> buildAiRelationBeanList(Playlist playlist) {
 		List<AiRelationBean> result = new ArrayList<AiRelationBean>();
 		if(playlist==null) {
 			return result;
 		}
 		Map<Long, Map<Instrument, TrackList>> relations = new HashMap<Long,Map<Instrument,TrackList>>();
 		for(Contract_PS songcontract: playlist.getSongs()) {
 			Song song = songcontract.getSong();
 			int songindex = songcontract.getRowno();
 			if(song.getAibag()!=null) {
 				
 				for(AIRelation candidaterel : song.getAibag().getRelations()) {
 					long artistid = candidaterel.getArtist_id();
 					long instsrid = candidaterel.getInstrument_id();
 					Instrument instrument = _dao.getInstrumentById(instsrid);
 					
 					// Record the instrument in the entry regarding this artist.
 					Map<Instrument,TrackList> entryset = relations.get(artistid);					
 					if(entryset==null) {
 						entryset = new HashMap<Instrument,TrackList>();
 						relations.put(artistid,entryset);
 					}
 					TrackList list = entryset.get(instrument);
 					if(list==null) {
 						list = new TrackList();
 						entryset.put(instrument, list);
 					}
 					list.add(songindex);
 				}
 			}
 		}
 		// Next, "reverse" the map, grouping the instruments that an artist
 		// plays on the same set of songs.
 		for(Entry<Long,Map<Instrument,TrackList>> entry : relations.entrySet()) {
 			Map<Instrument,TrackList> instruments = entry.getValue();
 			Map<TrackList,List<Instrument>> reversedHashEntry = new HashMap<TrackList,List<Instrument>>();
 			for(Entry<Instrument,TrackList> innerEntry : instruments.entrySet()) {
 				TrackList tracks = innerEntry.getValue();
 				List<Instrument> reversedEntry = reversedHashEntry.get(tracks);
 				if(reversedEntry==null) {
 					reversedEntry = new ArrayList<Instrument>();
 					reversedHashEntry.put(tracks, reversedEntry);
 				}
 				reversedEntry.add(innerEntry.getKey());
 			}
 			// finally, construct the list of AiRelationBeans for this artist.
 			Artist artist = BagAndKeywordUtils._dao.getArtistById(entry.getKey());
 			for(Entry<TrackList,List<Instrument>> innerEntry : reversedHashEntry.entrySet()) {
 				AiRelationBean entrybean = new AiRelationBean();
 				entrybean.setFirstName(artist.getFirstname());
 				entrybean.setLastName(artist.getLastname());
 				entrybean.setTracklist(innerEntry.getKey());
 				List<Instrument> instrumentsOfThisTrackList = innerEntry.getValue();
 				StringBuilder sb = new StringBuilder();
 				boolean first = true;
 				for(Instrument instrument : instrumentsOfThisTrackList) {
 					if(first) {
 						first = false;
 					} else {
 						sb.append(",");
 					}
 					sb.append(instrument.getName());
 				}
 				entrybean.setInstruments(sb.toString());
 				result.add(entrybean);			
 			}
 		}
 		
 		Collections.sort(result);
 		return result;
 	}
 
 	/**
 	 * Converts the Set of AiRelationBean objects into a Set of AiRelation
 	 * objects. This is the reverse operation of the buildAiRelationBeanList()
 	 * method. 
 	 * @param source The set of AiRelationBean objects to convert.
 	 * @return A set of AiRelation objects corresponding to the source parameter.
 	 */
 	public static Set<AIRelation> buildAiRelationList(List<AiRelationBean> source) {
 		Set<AIRelation> relations = new HashSet<AIRelation>();
 		for(AiRelationBean bean : source) {
 			String artistfirstname = bean.getFirstName()==null ? null : bean.getFirstName().trim();
 			String artistlastname = bean.getLastName()==null ? null : bean.getLastName().trim();
 			String instruments = bean.getInstruments()==null ? null : bean.getInstruments().trim();
 			if(artistlastname==null) {
 				// Treat as if this line in the form has been cleared by the user.
 				continue;
 			}
 			Artist theArtist = _dao.searchArtist(artistfirstname, artistlastname);
 			if (theArtist==null && (instruments!=null)) {
 				// The artist is not present yet. Create.
 				theArtist = new Artist();
 				theArtist.setFirstname(artistfirstname);
 				theArtist.setLastname(artistlastname);
 				_dao.save(theArtist);
 			}
 			// Build the list of instruments for the artist.
 			List<Instrument> instrumentList = BagAndKeywordUtils.splitInstrumentList(instruments);
 			// Convert the instrumentlist into a list of artist-instrument relations and add
 			// them to the list of relations that should be in the artist-instrument bag.
 			for(Instrument instr : instrumentList) {
 				AIRelation airel = new AIRelation();
 				airel.setArtist_id(theArtist.getId());
 				airel.setInstrument_id(instr.getId());
 				relations.add(airel);
 			}
 		}
 		return relations;
 	}
 	
 	/**
 	 * Splits the string into comma separated instrument names and 
 	 * returns a list with instruments with the names in the list.
 	 * @param instruments The comma separated list of instruments.
 	 * @return A list of persistent instruments.
 	 */
 	public static List<Instrument> splitInstrumentList(String instruments) {
 		List<Instrument> result  = new ArrayList<Instrument>();
 		Collection<String> instrSet = StringUtil.getIndividualWords(instruments);
 		for(String instrname: instrSet) {
 			Instrument instr = _dao.searchInstrument(instrname);
 			if(instr==null) {
 				instr = new Instrument();
 				instr.setName(instrname);
 				_dao.save(instr);
 			}
 			result.add(instr);
 		}		
 		return result;
 	}
 
 	/**
 	 * Construct a set of artist-instrument relations corresponding to an artist with the supplied first name
 	 * and last name and the specified instrument names. Constructs persistent instruments and artists as
 	 * necessary.
 	 * @param artistfirstname The first name of the artist.
 	 * @param artistlastname The last name of the artist.
 	 * @param band A band the artist is a part of (or null).
 	 * @param instruments The comma separated list of instruments.
 	 * @return A set of artist-instrument relations corresponding to the input parameters.
 	 */
 	public static Set<AIRelation> createRelations(String artistfirstname, String artistlastname, Band band, String instruments) {
 		// Capitalize the artists' first and last name.
 		artistfirstname = StringUtil.capitalize(artistfirstname);
 		artistlastname = StringUtil.capitalize(artistlastname);
 		// Get the artist. Create if new.
 		Artist artistThisName = _dao.searchArtist(artistfirstname,artistlastname);
 		if (artistThisName==null) {
 			// Add the artist as a new artist playing in this band.
 			artistThisName = new Artist();
 			artistThisName.setFirstname(artistfirstname);
 			artistThisName.setLastname(artistlastname);
 			artistThisName.addBand(band);
 			_dao.save(artistThisName);
 		}
 		// Build a list of AIRelations that should be stored in the AIBag of this
 		// song.
 		Set<AIRelation> relations = new HashSet<AIRelation>();
 		List<Instrument> instrumentList = BagAndKeywordUtils.splitInstrumentList(instruments);
 		for (Instrument i : instrumentList) {
 			AIRelation relToAdd = new AIRelation();
 			relToAdd.setInstrument_id(i.getId());
 			relToAdd.setArtist_id(artistThisName.getId());
 			relations.add(relToAdd);
 		}
 		return relations;
 	}
 
 }