package junotu;

import java.lang.RuntimeException;
import java.io.File;

import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.util.Version;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;

import org.apache.lucene.document.Document;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;

import org.apache.lucene.search.Query;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.NumericRangeQuery;
import org.apache.lucene.queryParser.QueryParser;

import org.apache.lucene.search.BooleanClause;

public class Database {

    public static class Card {
	public long identifier;
	public String title;
	public String content;
    }
    
    public static final String DATABASE_DIRECTORY = "./Database";
    public static final Version LUCENE_VERSION = Version.LUCENE_30;

    public static final String TAG_IDENTIFIER = "_junotu_identifier";
    public static final String TAG_TITLE      = "_junotu_title";
    public static final String TAG_CONTENT    = "_junotu_content";
    public static final String TAG_LAST_EDIT  = "_junotu_timestamp_last_edit";
    
    private IndexWriter luceneWriter;
    private IndexSearcher luceneSearcher;

    private long highestIdentifier;
    
    public Database() throws Exception
    {
	Directory indexDirectory = FSDirectory.open( new File( DATABASE_DIRECTORY ) );
	luceneWriter = new IndexWriter(
				       indexDirectory,
				       new StandardAnalyzer(LUCENE_VERSION),
				       null,
				       IndexWriter.MaxFieldLength.UNLIMITED
				       );
	luceneSearcher = new IndexSearcher( luceneWriter.getReader() );

	/* Find highest unique identifier. */
	TopDocs topDocuments = luceneSearcher.search(
					       new MatchAllDocsQuery(),
					       null,
					       1,
					       new Sort( new SortField( TAG_IDENTIFIER, SortField.LONG, true ) )
					       );

	if( topDocuments.scoreDocs.length == 0 ) {
	    highestIdentifier = 0;
	} else {
	    /** TODO: Find a way to get NumericField from document. */
	    highestIdentifier = Long.valueOf( luceneSearcher.doc( topDocuments.scoreDocs[0].doc ).get( TAG_IDENTIFIER ) );
	}
	
    }

    public void databaseCommit() throws Exception
    {
	luceneWriter.commit();
    }

    private void searcherRefresh() throws Exception
    {
	luceneSearcher = new IndexSearcher( luceneWriter.getReader() );
    }
    
    private Document documentByIdentifier( long identifier ) throws Exception
    {
	
	TopDocs topDocuments = luceneSearcher.search( NumericRangeQuery.newLongRange( TAG_IDENTIFIER, identifier, identifier, true, true ), 1 );

	if( topDocuments.scoreDocs.length == 0 ) {
	    return null;
	}
	
	return luceneSearcher.doc( topDocuments.scoreDocs[0].doc );
	
    }
    
    private Document cardToDocument( Card card ) throws Exception
    {
	
	Document document = new Document();

	NumericField fieldIdentifier = new NumericField( TAG_IDENTIFIER, Field.Store.YES, true );
	Field        fieldTitle      = new Field( TAG_TITLE, card.title, Field.Store.YES, Field.Index.ANALYZED );
	Field        fieldContent    = new Field( TAG_CONTENT, card.content, Field.Store.YES, Field.Index.ANALYZED );
	NumericField fieldLastEdit   = new NumericField( TAG_LAST_EDIT, Field.Store.YES, true );
	
	fieldIdentifier.setLongValue( card.identifier );
	fieldLastEdit.setLongValue( System.currentTimeMillis() );
	    
	document.add( fieldIdentifier );
	document.add( fieldTitle );
	document.add( fieldContent );
	document.add( fieldLastEdit );

	return document;
	
    }

    private Card cardFromDocument( Document document ) throws Exception
    {
	
	Card card = new Card();

	/** TODO: Find how to get NumericField from document. */
	card.identifier = Long.valueOf( document.get( TAG_IDENTIFIER ) );
	card.title      = document.get( TAG_TITLE );
	card.content    = document.get( TAG_CONTENT );

	return card;
	
    }
    
    public long cardAdd( Card card ) throws Exception
    {

	highestIdentifier++;
	card.identifier = highestIdentifier;
	
	luceneWriter.addDocument( cardToDocument( card ) );
	System.out.print("Added card with identifier "+Long.toString(highestIdentifier)+": '"+card.title+"'\n");
	searcherRefresh();
	//luceneWriter.commit();

	return highestIdentifier;
	
    }

    public void cardUpdate( Card card ) throws Exception
    {

	Query query = NumericRangeQuery.newLongRange( TAG_IDENTIFIER, card.identifier, card.identifier, true, true );
	TopDocs topDocuments = luceneSearcher.search( query, 1 );

	if( topDocuments.scoreDocs.length == 0 ) {
	    throw new RuntimeException( "Failed to update card with identifier "+Long.toString( card.identifier )+", not found." );
	}
	
        int documentNumber = topDocuments.scoreDocs[0].doc;

	luceneWriter.deleteDocuments( query );
	luceneWriter.addDocument( cardToDocument( card ) );
	searcherRefresh();
	//luceneWriter.commit();
	
    }

    public Card cardGetByIdentifier( long identifier ) throws Exception
    {
	
	Document document = documentByIdentifier( identifier );

	if( document == null ) {
	    return null;
	}
	
	return cardFromDocument( document );
	
    }

    /** Return up to 'amount' of recently modified cards. */
    public Card[] searchTopRecent( int amount ) throws Exception
    {
	
	TopDocs topDocuments = luceneSearcher.search(
						     new MatchAllDocsQuery(),
						     null,
						     amount,
						     new Sort( new SortField( TAG_LAST_EDIT, SortField.LONG, true ) )
						     );

	Card[] cards = new Card[topDocuments.scoreDocs.length];
	
	for( int i = 0; i < topDocuments.scoreDocs.length; i++ ) {
	    Document document = luceneSearcher.doc( topDocuments.scoreDocs[i].doc );
	    cards[i] = cardFromDocument( document );
	}

	return cards;
	
    }
    
    public Card[] searchSimple( String query ) throws Exception
    {

	String[] split = query.split( " " );
	
        Query queryTitle = new QueryParser(
					   LUCENE_VERSION,
					   TAG_TITLE,
					   new StandardAnalyzer(LUCENE_VERSION)).parse(query);
	Query queryContent = new QueryParser(
					     LUCENE_VERSION,
					     TAG_CONTENT,
					     new StandardAnalyzer(LUCENE_VERSION)).parse(query);

	BooleanQuery queryFinal = new BooleanQuery();

	queryFinal.add( queryTitle, BooleanClause.Occur.SHOULD );
	queryFinal.add( queryContent, BooleanClause.Occur.SHOULD );

	TopDocs hits = luceneSearcher.search( queryFinal, 32 );
	Card[] cards = new Card[hits.scoreDocs.length];
	
	for( int i = 0; i < hits.scoreDocs.length; i++ ) {
	    Document document = luceneSearcher.doc( hits.scoreDocs[i].doc );
	    cards[i] = cardFromDocument( document );
	}

	return cards;
	
    }
    
}