package org.marketchangers.prayer.lucene;
   
   import java.io.IOException;
   import java.text.SimpleDateFormat;
   import java.util.Date;
   
   import junit.framework.TestCase;
   
   import org.apache.lucene.analysis.Analyzer;
  import org.apache.lucene.analysis.standard.StandardAnalyzer;
  import org.apache.lucene.document.DateField;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.queryParser.MultiFieldQueryParser;
  import org.apache.lucene.queryParser.ParseException;
  import org.apache.lucene.search.BooleanQuery;
  import org.apache.lucene.search.DateFilter;
  import org.apache.lucene.search.FilteredQuery;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.Query;
  import org.apache.lucene.search.RangeQuery;
  import org.apache.lucene.search.Searcher;
  import org.apache.lucene.search.TermQuery;
  import org.apache.lucene.store.Directory;
  import org.apache.lucene.store.RAMDirectory;
  
  /***
   * @author <a href="mailto:mtodd@wc-group.com">Matthew Todd</a>
   */
  public class LearningTest extends TestCase {
  	public void testNewRamDirectoriesHaveNoFiles() {
  		assertEquals(0, new RAMDirectory().list().length);
  	}
  
  	public void testWrittenDirectoriesHaveSomeFiles() throws IOException {
  		Directory directory = new RAMDirectory();
  		new IndexWriter(directory, new StandardAnalyzer(), true).close();
  		assertTrue(0 < directory.list().length);
  	}
  
  	public void testCannotKeepAnIndexSearcherAcrossWritings()
  		throws IOException {
  		Directory directory = new RAMDirectory();
  
  		IndexWriter writer;
  		writer = new IndexWriter(directory, new StandardAnalyzer(), true);
  		writer.close();
  
  		Searcher searcher = new IndexSearcher(directory);
  		assertEquals(0, searcher.maxDoc());
  
  		Document document = new Document();
  		document.add(Field.Keyword("the man", "Jianshuo"));
  		writer = new IndexWriter(directory, new StandardAnalyzer(), false);
  		writer.addDocument(document);
  		writer.close();
  
  		assertEquals(0, searcher.maxDoc());
  		assertEquals(1, new IndexSearcher(directory).maxDoc());
  	}
  
  	public void testTheDirectoryIsNotModifiedUntilClose() throws IOException {
  		Directory directory = new RAMDirectory();
  		IndexWriter writer;
  
  		Document document = new Document();
  		document.add(Field.Keyword("the man", "Jianshuo"));
  		writer = new IndexWriter(directory, new StandardAnalyzer(), true);
  		writer.addDocument(document);
  
  		assertEquals(0, new IndexSearcher(directory).maxDoc());
  		writer.close();
  		assertEquals(1, new IndexSearcher(directory).maxDoc());
  	}
  
  	public void testMultiFieldQueryParserWithEmptyStringExplodes() {
  		try {
  			MultiFieldQueryParser.parse("", "field", new StandardAnalyzer());
  			fail("We thought this would throw an Exception.");
  		} catch (ParseException pe) {
  			// expected
  		}
  	}
  
  	public void testMultiFieldQueryParserWithStarWorks() throws Exception {
  		MultiFieldQueryParser.parse("a*", "field", new StandardAnalyzer());
  	}
  
  	public void testDateRangeSearchesWithFilteredQueries() throws Exception {
  		Directory directory = new RAMDirectory();
  		Analyzer analyzer = new StandardAnalyzer();
  
  		Document entry = new Document();
  		entry.add(Field.Keyword("date", date("08-19-2004")));
  		entry.add(Field.Keyword("anything", "anything"));
  
  		IndexWriter writer = new IndexWriter(directory, analyzer, true);
 		writer.addDocument(entry);
 		writer.close();
 
 		IndexSearcher searcher = new IndexSearcher(directory);
 		Query query = dateAfterQuery("08-20-2004");
 
 		assertEquals(0, searcher.search(query).length());
 		query = dateAfterQuery("08-19-2004");
 		assertEquals(1, searcher.search(query).length());
 		query = dateAfterQuery("08-18-2004");
 		assertEquals(1, searcher.search(query).length());
 	}
 
 	private Query anythingQuery() {
 		return new TermQuery(new Term("anything", "anything"));
 	}
 
 	private Date date(String date) throws Exception {
 		return new SimpleDateFormat("MM-dd-yyyy").parse(date);
 	}
 
 	private DateFilter dateAfter(String date) throws Exception {
 		return DateFilter.After("date", date(date));
 	}
 
 	private FilteredQuery dateAfterQuery(String date) throws Exception {
 		return new FilteredQuery(anythingQuery(), dateAfter(date));
 	}
 
 	private Query alternativeDateAfterQuery(String date) throws Exception {
 		return new RangeQuery(
 			new Term("date", DateField.dateToString(date(date))),
 			null,
 			true);
 	}
 
 	public void testBooleanFilteredQueriesDontWorkSoWell() throws Exception {
 		Directory directory = new RAMDirectory();
 		Analyzer analyzer = new StandardAnalyzer();
 
 		Document entry = new Document();
 		entry.add(Field.Keyword("date", date("08-19-2004")));
 		entry.add(Field.Keyword("anything", "anything"));
 
 		IndexWriter writer = new IndexWriter(directory, analyzer, true);
 		writer.addDocument(entry);
 		writer.close();
 
 		IndexSearcher searcher = new IndexSearcher(directory);
 
 		// First try: boolean(dateAfterQuery + anythingQuery)
 		BooleanQuery query = new BooleanQuery();
 		query.add(dateAfterQuery("08-20-2004"), true, false);
 		assertEquals(0, searcher.search(query).length());
 		query.add(anythingQuery(), true, false);
 		// Hoped for 0; we thought dateAfterQuery was absolutely required.
 		assertEquals(1, searcher.search(query).length());
 
 		// Second try: filter(boolean(anythingQuery), dateAfter)
 		query = new BooleanQuery();
 		query.add(anythingQuery(), true, false);
 		assertEquals(1, searcher.search(query).length());
 		// Yes!
 		assertEquals(
 			0,
 			searcher.search(query, dateAfter("08-20-2004")).length());
 
 		// Aside: BooleanQuery without dates.
 		query = new BooleanQuery();
 		query.add(
 			new TermQuery(new Term("anything", "something else")),
 			true,
 			false);
 		assertEquals(0, searcher.search(query).length());
 		query.add(anythingQuery(), true, false);
 		assertEquals(0, searcher.search(query).length());
         
         // Third try: boolean(alternativeDateAfterQuery + anythingQuery)
         query = new BooleanQuery();
         query.add(alternativeDateAfterQuery("08-20-2004"), true, false);
         assertEquals(0, searcher.search(query).length());
         query.add(anythingQuery(), true, false);
         assertEquals(0, searcher.search(query).length());        
 	}
 }