package org.musicontroller.core.searching;
   
   import java.io.IOException;
   import java.util.Calendar;
   import java.util.Date;
   import java.util.GregorianCalendar;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import org.apache.log4j.Logger;
  import org.apache.lucene.analysis.standard.StandardAnalyzer;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.queryParser.MultiFieldQueryParser;
  import org.apache.lucene.queryParser.ParseException;
  import org.apache.lucene.search.Hits;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.Query;
  import org.apache.lucene.search.Searcher;
  import org.musicontroller.core.AIRelation;
  import org.musicontroller.core.Artist;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Contract_BA;
  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.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.dao.Dao;
  import org.musicontroller.service.FileUtils;
  import org.varienaja.comments.Comment;
  import org.varienaja.comments.CommentService;
  import org.varienaja.util.DateTools;
  
  
  /**
   * The Indexer periodically scans the database, and updates the Lucene-index.
   * The 'changed'-field of all Documents, contains the 'changed'-property of the
   * object. This is used to see if the object has been changed since the last indexation.
   * Only changed objects are updated in the index to keep disk-io as low as possible. This
   * also means that we have to be sure that the changed-property of all indexed objects
   * really is what is says!
   * 
   * @author Varienaja
   * @version $Id: Indexer.java,v 1.1 2010/03/16 18:55:42 varienaja Exp $
   */
  public class Indexer {
  	private static final Logger log = Logger.getLogger(Indexer.class);
  	
  	private static final String DATEPATTERN = "yyyyMMddHHmmssSSS";
  	
  	private long songCount;
  	private long bandCount;
  	private long playlistCount;
  	private long artistCount;
  	private long instrumentCount;
  	private long keywordCount;
  	private Dao dao;
  	private CommentService _reviewService;
  	private Date _lastUpdate;
  	
  	private IndexWriter getIndexWriter() {
  		IndexWriter writer = null;
  		try {
  			writer = new IndexWriter(FileUtils.getIndexdir(), new StandardAnalyzer(), false); //Try to open an existing index
  		} catch (IOException e) {
  			log.debug("Error creating searchindex "+e+" Trying force-create.");
  			if (writer==null) {
  				try {
  					writer = new IndexWriter(FileUtils.getIndexdir(), new StandardAnalyzer(), true); //If it fails: create a new one
  				} catch (IOException e2) {
  					log.error("Error creating searchindex: "+e);
  					
  				}
  			}
  		}
  		return writer;
  	}
  	
  	private IndexReader getIndexReader() {
  		IndexReader reader = null;
  		try {
  			reader = IndexReader.open(FileUtils.getIndexdir());
  		} catch (IOException e) {
  			log.error("Error reading searchindex: "+e);
  		}
  		return reader;
  	}
  	
  	public Indexer(Dao dao) {
  		songCount=0L;
  		bandCount=0L;
  		playlistCount=0L;
 		artistCount=0L;
 		instrumentCount=0L;
 		keywordCount=0L;
 		this.dao = dao;
 		_reviewService = new CommentService();
 		_lastUpdate = null;
 	}
 	
 	/**
 	 * Reindexes all items. Reindexing is done lazily, items that did not change
 	 * since the last index-update are not processed.
 	 */
 	public synchronized void reindexAll() {
 		Date now = new Date();
 		log.debug("Indexing started at: "+now);
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("lastUpdate",getLastUpdate());
 		
 		reindexSongs(params);
 		reindexArtists(params);
 		reindexBands(params);
 		reindexInstruments(params);
 		reindexKeywords(params);
 		reindexPlaylists(params);
 		
 		storeLastUpdate(now);
 		log.debug("Optimizing searchindex...");
 		optimizeIndex();
 		log.debug("Searchindex optimized.");
 		log.debug("Indexing finished");
 	}
 
 	/**
 	 * Reindexes all Songs. Only Songs that changed after the parameter are regarded.
 	 * @param params Map of Strings to Objects. Must contain an entry for "lastUpdate"--&gt;some Date
 	 */
 	@SuppressWarnings("unchecked")
 	private void reindexSongs(Map<String, Object> params) {
 		Iterator<Long> it;
 		List<Long> songIDs = dao.search("select s.id from Song s where s.changed>:lastUpdate", params, 0);
 		it = songIDs.iterator();
 		while (it.hasNext()) {
 			long songid = it.next();
 			Song song = dao.getSongById(songid);
 			log.debug("Reindexing song: " + song);
 			reindexSong(song);
 			it.remove();
 		}
 		log.debug("Songs indexed: "+songCount);
 	}
 
 	/**
 	 * Reindexes all Playlists. Only Playlists that changed after the parameter are regarded.
 	 * @param params Map of Strings to Objects. Must contain an entry for "lastUpdate"--&gt;some Date
 	 */
 	@SuppressWarnings("unchecked")
 	private void reindexPlaylists(Map<String, Object> params) {
 		Iterator<Long> it;
 		List<Long> playlistIDs = dao.search("select p.id from Playlist p where p.changed>:lastUpdate", params, 0);
 		it = playlistIDs.iterator();
 		while (it.hasNext()) {
 			long playlistid = it.next();
 			Playlist playlist = dao.getPlaylistById(playlistid, null);
 			reindexPlaylist(playlist);
 			it.remove();
 		}
 		log.debug("Playlists indexed: "+playlistCount);
 	}
 
 	/**
 	 * Reindexes all Keywords. Only Keywords that changed after the parameter are regarded.
 	 * @param params Map of Strings to Objects. Must contain an entry for "lastUpdate"--&gt;some Date
 	 */
 	@SuppressWarnings("unchecked")
 	private void reindexKeywords(Map<String, Object> params) {
 		Iterator<Long> it;
 		List<Long> keywordIDs = dao.search("select k.id from Keyword k where k.changed>:lastUpdate", params, 0);
 		it = keywordIDs.iterator();
 		while (it.hasNext()) {
 			long keywordid = it.next();
 			Keyword keyword = dao.getKeywordById(keywordid);
 			reindexKeyword(keyword);
 			it.remove();
 		}
 		log.debug("Keywords indexed: "+keywordCount);
 	}
 
 	/**
 	 * Reindexes all Instruments. Only Instruments that changed after the parameter are regarded.
 	 * @param params Map of Strings to Objects. Must contain an entry for "lastUpdate"--&gt;some Date
 	 */
 	@SuppressWarnings("unchecked")
 	private void reindexInstruments(Map<String, Object> params) {
 		Iterator<Long> it;
 		List<Long> instrumentIDs = dao.search("select i.id from Instrument i where i.changed>:lastUpdate", params, 0);
 		it = instrumentIDs.iterator();
 		while (it.hasNext()) {
 			long instrumentid = it.next();
 			Instrument instrument = dao.getInstrumentById(instrumentid);
 			reindexInstrument(instrument);
 			it.remove();
 		}
 		log.debug("Instruments indexed: "+instrumentCount);
 	}
 
 	/**
 	 * Reindexes all Bands. Only Bands that changed after the parameter are regarded.
 	 * @param params Map of Strings to Objects. Must contain an entry for "lastUpdate"--&gt;some Date
 	 */
 	@SuppressWarnings("unchecked")
 	private void reindexBands(Map<String, Object> params) {
 		Iterator<Long> it;
 		List<Long> bandIDs = dao.search("select b.id from Band b where b.changed>:lastUpdate", params, 0);
 		it = bandIDs.iterator();
 		while (it.hasNext()) {
 			long bandid = it.next();
 			Band band = dao.getBandById(bandid);
 			reindexBand(band);
 			it.remove();
 		}
 		log.debug("Bands indexed: "+bandCount);
 	}
 
 	/**
 	 * Reindexes all Artists. Only Artists that changed after the parameter are regarded.
 	 * @param params Map of Strings to Objects. Must contain an entry for "lastUpdate"--&gt;some Date
 	 */
 	@SuppressWarnings("unchecked")
 	private void reindexArtists(Map<String, Object> params) {
 		Iterator<Long> it;
 		List<Long> artistIDs = dao.search("select a.id from Artist a where a.changed>:lastUpdate", params, 0);
 		it = artistIDs.iterator();
 		while (it.hasNext()) {
 			long artistid = it.next();
 			Artist artist = dao.getArtistById(artistid);
 			reindexArtist(artist);
 			it.remove();
 		}
 		log.debug("Artists indexed: "+artistCount);
 	}
 
 	// FIXME BIG MEMORY-LEAK IN THIS METHOD
 	public Document reindexSong(Song song) {
 		String id = Long.toString(song.getId());
 		Document doc = null;
 		if (song.getChanged().after(getLastUpdate())) {
 			doc = new Document();
 	
 			StringBuilder sb = new StringBuilder();
 			
 			Band band = song.getBand();
 			sb.append(band.getName());
 			sb.append(" ");
 			
 			for (Keyword keyword : song.getKeywordbag().getKeywords()) {
 				sb.append(keyword.getName());
 				sb.append(" ");
 			}
 			
 			if (song.getAibag()!=null) {
 				for (AIRelation air : song.getAibag().getRelations()) {
 					Artist artist = dao.getArtistById(air.getArtist_id());
 					sb.append(artist.getFormattedName());
 					sb.append(" ");
 					
 					Instrument instrument = dao.getInstrumentById(air.getInstrument_id());
 					sb.append(instrument.getName());
 					sb.append(" ");
 				}
 			}
 			
 			Calendar c = new GregorianCalendar();
 			c.add(Calendar.YEAR,-1);
 			Date oneyearago = c.getTime();
 			
 	    	Map<String,Integer> map = new HashMap<String,Integer>();
 	    	for (Event ev : song.getEvents()) {
 	    		if (ev.getEventkind()==Event.played && ev.getUser()!=null && ev.getMoment().after(oneyearago)) {
 	    			
 	    			String username = ev.getUser().getLoginname();
 	    			Integer i = map.get(username);
 	    			if (i==null) {
 	    				i = 1;
 	        			map.put(username,i);
 	    			} else {
 	    				map.put(username,i+1);
 	    			}
 	       		}
 	    	}
 	    	
 	    	for (Entry<String,Integer> entry : map.entrySet()) {
 	        	doc.add(new Field("user_"+entry.getKey(),entry.getValue().toString(),Field.Store.YES,Field.Index.UN_TOKENIZED));
 	    	}
 	    	
 	    	for (Contract_PS pscontract : song.getPlaylists()) {
 	    		Playlist playlist = pscontract.getPlaylist();
 	    		sb.append(playlist.getName());
 	    		sb.append(" ");
 	    	}
 			doc.add(new Field("contents",sb.toString(),Field.Store.YES,Field.Index.TOKENIZED));
 	
 	   		updateDocument(doc,song.getName(),"song",id);
 		}
     	dao.evict(song);
 		songCount++;
     	return doc;
 	}
 	
 	public Document reindexBand(Band band) {
 		//TODO put an eventcount per user in the document!
 		
 		String id = Long.toString(band.getId());
 		Document doc = null;
 		
 		if (band.getChanged().after(getLastUpdate())) {
 			doc = new Document();
 	
 			StringBuilder sb = new StringBuilder();
 			for (Contract_BA bac : band.getArtists()) {
 				Artist artist = bac.getArtist();
 				sb.append(artist.getFormattedName());
 				sb.append(" ");
 			}
 			
 			Playlist playlist = dao.songsByBand(band.getId());
 	    	for (Contract_PS pscontract : playlist.getSongs()) {
 	    		Song song = pscontract.getSong();
 				sb.append(song.getName());
 				sb.append(" ");
 	    	}
 	    	doc.add(new Field("contents",sb.toString(),Field.Store.YES,Field.Index.TOKENIZED));
 			
 	   		updateDocument(doc,band.getName(),"band",id);
 		}
     	dao.evict(band);
     	bandCount++;
 		return doc;
 	}
 
 	public Document reindexArtist(Artist artist) {
 		String id = Long.toString(artist.getId());
 		Document doc = null;
 		if (artist.getChanged().after(getLastUpdate())) {
 			doc = new Document();
 	   		updateDocument(doc,artist.getFormattedName(),"artist",id);
 		}
     	dao.evict(artist);
     	artistCount++;
 		return doc;
 	}
 
 	public Document reindexInstrument(Instrument instrument) {
 		String id = Long.toString(instrument.getId());
 		Document doc = null;
 		if (instrument.getChanged().after(getLastUpdate())) {
 			doc = new Document();
 			updateDocument(doc,instrument.getName(),"instrument",id);
 		}
     	dao.evict(instrument);
     	instrumentCount++;
 		return doc;
 	}
 
 	public Document reindexKeyword(Keyword keyword) {
 		String id = Long.toString(keyword.getId());
 		Document doc = null;
 		
 		if (keyword.getChanged().after(getLastUpdate())) {
 			doc = new Document();
 			updateDocument(doc,keyword.getName(),"keyword",id);
 		}
     	dao.evict(keyword);
     	keywordCount++;
 		return doc;
 	}
 
 	public Document reindexPlaylist(Playlist playlist) {
 		//TODO put an eventcount per user in the document!
 		String id = Long.toString(playlist.getId());
 		Document doc = null;
 
 		if (playlist.getChanged().after(getLastUpdate())) {
 			doc = new Document();
 			StringBuilder sb = new StringBuilder();
 		    for (Contract_PS pscontract : playlist.getSongs()) {
 		    	Song song = pscontract.getSong();
 		    	sb.append(song.getName());
 		    	sb.append(" ");
 		    }
 		    for (Comment review : _reviewService.getComments(playlist)) {
 		    	sb.append(review.toString());
 		    }
 		    doc.add(new Field("contents",sb.toString(),Field.Store.YES,Field.Index.TOKENIZED));
 			
 		   	updateDocument(doc,playlist.getName(),"playlist",id);
 		}
     	dao.evict(playlist);
     	playlistCount++;
 		return doc;
 	}
 	
 	/**
 	 * Updates a document in the searchindex. If there already is a document in the
 	 * searchindex identified by the objecttype and objectid, the document is overwritten.
 	 * Otherwise, an new document is added to the searchindex.
 	 * @param doc The document to add or update.
 	 * @param name The name to be used as name-property in the document
 	 * @param objecttype The description of the type the document is about
 	 * @param objectid The id of the object the document is about
 	 * @return Whether the operation succeeded.
 	 */
 	private boolean updateDocument(Document doc, String name, String objecttype, String objectid) {
 		doc.add(new Field("name",name,Field.Store.YES,Field.Index.UN_TOKENIZED));
 		doc.add(new Field("objecttype",objecttype,Field.Store.YES,Field.Index.UN_TOKENIZED));
 		doc.add(new Field("objectid",objectid,Field.Store.YES,Field.Index.UN_TOKENIZED));
 		doc.add(new Field("uniqueid",objecttype+objectid,Field.Store.YES,Field.Index.UN_TOKENIZED));
 		//use a unique id for documents. The combined objecttype+objectid which was used before
 		//causes clashes. Sometimes, a Playlist with id 75 is returned instead of Song with that
 		//id when checking if there already exists a document with that id.
 		
 		//As it is very well possible that there's (for instance) a Band with >100 songs,
 		//we boost the name-field a little, to make sure that you'll find the Band in most
 		//cases when you provide the bandname in the query.
 		Field namefield = new Field("contents",name,Field.Store.YES,Field.Index.TOKENIZED);
 		namefield.setBoost(100);
 		doc.add(namefield);
 		
 		try {
 			IndexReader reader = getIndexReader();
 			if (reader!=null) {
 				Searcher searcher = new IndexSearcher(reader);
 				
 			    Query query = MultiFieldQueryParser.parse(new String[]{objecttype+objectid},new String[]{"uniqueid"},new StandardAnalyzer());
 				Hits hits = searcher.search(query);
 				if (hits.length()>0) {
 					Document existing = hits.doc(0);
 					if ((objecttype+objectid).equals(existing.getField("uniqueid").stringValue())) {
 						reader.deleteDocument(hits.id(0));
 					}
 				}
 				reader.close();
 			}
 			
     		storeDocument(doc);
     		return true;
 		} catch (ParseException pe) {
 			log.error("Error trying to find existing document: "+pe);
     	} catch (IOException e) {
     		log.debug("Error adding document to searchindex: "+e);
     	}
 		return false;
 	}
 	
 	/**
 	 * Searches the index for the existence of a Document of a certain type
 	 * having a certain id. 
 	 * TODO Use this in the update procedure as well
 	 * @param objecttype The object-type
 	 * @param objectid The id of the object
 	 * @return The Document, or null if nothing was found.
 	 */
 	private Document findDocument(String objecttype, String objectid) {
 		Document result = null;
 		try {
 			IndexReader reader = getIndexReader();
 			if (reader!=null) {
 				Searcher searcher = new IndexSearcher(reader);
 				
 			    Query query = MultiFieldQueryParser.parse(new String[]{objecttype+objectid},new String[]{"uniqueid"},new StandardAnalyzer());
 				Hits hits = searcher.search(query);
 				if (hits.length()>0) {
 					result = hits.doc(0);
 					if (!(objecttype+objectid).equals(result.getField("uniqueid").stringValue())) {
 						result = null;
 					}
 				}
 				reader.close();
 			}
 		} catch (ParseException pe) {
 			log.error("Error trying to find existing document: "+pe);
     	} catch (IOException e) {
 			log.error("Error trying to find existing document: "+e);
     	}
     	return result;
 	}
 	
 	/**
 	 * Returns the moment at which the index was last updated.
 	 * @return The String representation of this moment, or null if the index
 	 * has never been updated.
 	 */
 	private Date getLastUpdate() {
 		if (_lastUpdate == null) {
 			_lastUpdate = new Date(0); // Long, long ago.
 			
 			Document doc = findDocument("lastupdate","0");
 			if  (doc!=null) {
 				Field field = doc.getField("changed");
 				if (field != null) {
 					_lastUpdate = DateTools.parseDate(field.stringValue(),DATEPATTERN);
 				}
 				log.debug("Last update of the searchindex: " + _lastUpdate);
 			}
 		}			
 		return _lastUpdate;
 	}
 		
 	private void storeLastUpdate(Date now) {
 		Document doc = new Document();
 		String fmtDate = DateTools.formatDate(now,DATEPATTERN);
 		doc.add(new Field("changed",fmtDate,Field.Store.YES,Field.Index.UN_TOKENIZED));
 		updateDocument(doc,"","lastupdate","0");
 	}
 	
 	private void storeDocument(Document doc) {
 		try {
 			IndexWriter writer = getIndexWriter();
 			writer.addDocument(doc);
 			writer.close();
 		} catch (IOException e) {
 			log.error("Error storing document: "+e);
 		}
 	}
 	
 	private void optimizeIndex() {
 		try {
 			IndexWriter writer = getIndexWriter();
 			writer.optimize();
 			writer.close();
 		} catch (IOException e) {
 			log.error("Error optimizing index: "+e);
 		}
 	}
 	
 }