package org.marketchangers.prayer.lucene;
   
   import java.io.IOException;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   
  import org.apache.lucene.document.Document;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.search.Hits;
  import org.apache.lucene.search.Query;
  import org.marketchangers.prayer.PrayerRequest;
  import org.marketchangers.prayer.PrayerRequestQuery;
  import org.marketchangers.prayer.PrayerRequestSearcher;
  
  /***
   * @author <a href="mailto:jniu@wc-group.com">Jianshuo Niu</a>
   * @author <a href="mailto:mtodd@wc-group.com">Matthew Todd</a>
   */
  public class LucenePrayerRequestSearcher implements PrayerRequestSearcher {
  	private IndexProvider provider;
  
  	public LucenePrayerRequestSearcher(IndexProvider provider) {
  		this.provider = provider;
  	}
  
  	public synchronized void index(PrayerRequest request) {
  		Document document = provider.translateToDocument(request);
  
  		try {
  			IndexWriter writer = provider.getWriter();
  			writer.addDocument(document);
  			writer.close();
  		} catch (IOException e) {
  			// TODO How should we handle this?
  			e.printStackTrace();
  		}
  	}
  
  	public synchronized void index(Collection prayerRequests) {
  		Iterator requests = prayerRequests.iterator();
  
  		try {
  			IndexWriter writer = provider.getWriter();
  
  			while (requests.hasNext()) {
  				PrayerRequest request = (PrayerRequest) requests.next();
  				writer.addDocument(provider.translateToDocument(request));
  			}
  
  			writer.close();
  		} catch (IOException e) {
  			// TODO How should we handle this?
  			e.printStackTrace();
  		}
  	}
  
  	public List search(PrayerRequestQuery q) {
  		if (q.getRequestorUserIds().isEmpty()) {
  			return Collections.EMPTY_LIST;
  		}
  
  		Hits hits;
  
  		try {
  			hits = provider.getSearcher().search(provider.translateToQuery(q));
  		} catch (IOException ioe) {
  			return Collections.EMPTY_LIST;
  		}
  
  		List prayerRequestIds = new LinkedList();
  
  		for (int i = 0; i < hits.length(); i++) {
  			try {
  				prayerRequestIds.add(id(hits, i));
  			} catch (IOException ioe) {
  				// what can we do?
  			}
  		}
  
  		return prayerRequestIds;
  	}
  
  	public void updateStatus(PrayerRequest request) {
  		Query query = provider.translateToQuery(request);
  		List prayerRequestIds = new LinkedList();
  
  		//hits should contain only one documents id, otherwise,
  		// it is a bug in the search.
  		try {
  			Hits hits = provider.getSearcher().search(query);
  			for (int i = 0; i < hits.length(); i++) {
  				delete(hits.id(i));
  			}
  		} catch (IOException ioe) {
  			// can't think of much to do here
 		}
 		index(request);
 	}
 
 	private Integer id(Hits hits, int i) throws IOException {
 		return Integer.valueOf(hits.doc(i).get("id"));
 	}
 
 	public synchronized void delete(int docId) throws IOException {
 
 		IndexReader reader = provider.getReader();
 		if (reader != null) {
 			reader.delete(docId);
 		}
 		reader.close();
 	}
 }