package junotu;

import java.lang.RuntimeException;
import java.io.IOException;
import java.io.File;
import java.util.Set;

import org.apache.lucene.queryParser.ParseException;

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.Fieldable;
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.TermQuery;
import org.apache.lucene.search.WildcardQuery;
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.index.Term;

import org.apache.lucene.search.BooleanClause;

import junotu.Card;

public class Database {
    
    public static final String DATABASE_DIRECTORY = "./database";
    public static final Version LUCENE_VERSION = Version.LUCENE_30;
    
    private IndexWriter luceneWriter;
    private IndexSearcher luceneSearcher;

    private long highestIdentifier;

    private Query[] hideQueries;
    
    public Database()
    {
	try {
	    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( Card.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( Card.TAG_IDENTIFIER ) );
	    }
	} catch( IOException e ) { /* Also catches CorruptIndexException from Lucene */
	    throw new RuntimeException(e);
	}

	hideQueries = new Query[Card.HIDE_TAGS.length+Card.HIDE_TAG_VALUES.length/2];
	int pos = 0;
	
	for( int i = 0; i < Card.HIDE_TAGS.length; i++ ) {
	    hideQueries[pos] = new WildcardQuery( new Term(Card.HIDE_TAGS[i], "*") );
	    pos += 1;
	}
	
	for( int i = 0; i < Card.HIDE_TAG_VALUES.length/2; i++ ) {
	    hideQueries[pos] = new TermQuery( new Term(Card.HIDE_TAG_VALUES[i*2], Card.HIDE_TAG_VALUES[i*2+1]) );
	    pos += 1;
	}
	
    }

    public void databaseCommit()
    {
	System.out.print( "Saving database to disk..\n" );
	try {
	    luceneWriter.commit();
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
    }

    private void searcherRefresh()
    {
	try {
	    luceneSearcher = new IndexSearcher( luceneWriter.getReader() );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
    }
    
    private Document documentByIdentifier( long identifier )
    {

	try {
	    TopDocs topDocuments = luceneSearcher.search( NumericRangeQuery.newLongRange( Card.TAG_IDENTIFIER, identifier, identifier, true, true ), 1 );
	    
	    if( topDocuments.scoreDocs.length == 0 ) {
		return null;
	    }
	    
	    return luceneSearcher.doc( topDocuments.scoreDocs[0].doc );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
	
    }
    
    private Document cardToDocument( Card card )
    {
	
	Document document = new Document();

	String search = "";
	for( String tag : card.tags.keySet() ) {
	    Set<Object> values = card.tags.get( tag );
	    for( Object value : values ) {
		if( value == null ) {
		    search += tag+" ";
		} else {
		    search += tag+" "+value.toString()+" ";
		}
		if( value == null ) {
		    if( !tag.equals("") ) {
			document.add( new Field( tag, "", Field.Store.YES, Field.Index.NOT_ANALYZED ) );
		    }
	        } else if( value instanceof String ) {
		    document.add( new Field( tag, (String)value, Field.Store.YES, Field.Index.ANALYZED ) );
		} else if( value instanceof Number ) {
		    NumericField field = new NumericField( tag, Field.Store.YES, true );
		    if( value instanceof Long ) {
			field.setLongValue( ((Long)value).longValue() );
		    } else {
			throw new RuntimeException( "Unknown tag number type." );
		    }
		    document.add( field );
		}
	    }
	}
	document.add( new Field( Card.TAG_SEARCH, search, Field.Store.NO, Field.Index.ANALYZED ) );

	return document;
	
    }

    private Card cardFromDocument( Document document )
    {

	Card card = new Card();

	for( Fieldable field : document.getFields() ) {
	    /** TODO: Find how to get NumericField from document. */
	    String value = field.stringValue();
	    card.tagValueAdd( field.name(), value.equals("") ? null : value );
	}

	card.tagValueSetOnly( Card.TAG_IDENTIFIER, Long.valueOf( document.get( Card.TAG_IDENTIFIER ) ) );

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

	highestIdentifier++;
	card.tagValueSetOnly( Card.TAG_IDENTIFIER, new Long( highestIdentifier ) );
	card.tagValueSetOnly( Card.TAG_LAST_EDIT, new Long( System.currentTimeMillis() ) );

	try {
	    luceneWriter.addDocument( cardToDocument( card ) );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
	
	System.out.print( "Added card with identifier "+Long.toString(highestIdentifier)+": '"+card.titleGet()+"'\n" );
	searcherRefresh();
	//luceneWriter.commit();

	return highestIdentifier;
	
    }

    public void cardUpdate( Card card )
    {

	TopDocs topDocuments;
	Query query = NumericRangeQuery.newLongRange( card.TAG_IDENTIFIER, card.identifierGet(), card.identifierGet(), true, true );
	try {
	    topDocuments = luceneSearcher.search( query, 1 );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}

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

	card.tagValueSetOnly( Card.TAG_LAST_EDIT, new Long( System.currentTimeMillis() ) );
	
        int documentNumber = topDocuments.scoreDocs[0].doc;

	try {
	    luceneWriter.deleteDocuments( query );
	    luceneWriter.addDocument( cardToDocument( card ) );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
	System.out.print( "Updated card with identifier "+Long.toString(card.identifierGet())+": '"+card.titleGet()+"'\n" );
	searcherRefresh();
	//luceneWriter.commit();
	
    }

    public void cardDelete( Card card )
    {
	cardDelete( card, false );
    }

    public void cardDelete( Card card, boolean cautious )
    {
	if( cautious ) {
	    String tag;
	    if( (tag = card.<String>tagGetAs(Card.TAG_BOARD_COLUMN_CARD)) != null && tag.equals(Card.VALUE_BOARD_COLUMN_CARD_ONLY) ) {
		//pass
	    } else {
		return; /* Don't delete. */
	    }
	}
	String tag;
	Card[] cards;
	if( card.tagHas(Card.TAG_BOARD) ) {
	    tag = card.<String>tagGetAsOr(Card.TAG_BOARD_COLUMNS, "");
	    cards = TagUtility.parseCardList(tag);
	    for( int i = 0; i < cards.length; i++ ) {
		if( cards[i] == null ) {
		    continue;
		}
		cardDelete( cards[i], false );
	    }
	}
	if( card.tagHas(Card.TAG_BOARD_COLUMN) ) {
	    tag = card.<String>tagGetAsOr(Card.TAG_BOARD_COLUMN_CARDS, "");
	    cards = TagUtility.parseCardList(tag);
	    for( int i = 0; i < cards.length; i++ ) {
		if( cards[i] == null ) {
		    continue;
		}
		cardDelete( cards[i], true );
	    }
	}

	cardDeleteRaw(card.identifierGet());
	
    }

    public void cardDeleteByIdentifier( long identifier )
    {
	cardDeleteByIdentifier( identifier, false );
    }
    
    public void cardDeleteByIdentifier( long identifier, boolean cautious )
    {
	Card card = cardGetByIdentifier(identifier);
	if( card != null ) {
	    cardDelete(card);
	} else {
	    throw new RuntimeException( "Failed to delete card by identifier "+Long.toString(identifier)+", not found." );
	}
    }

    public void cardDeleteRaw( long identifier )
    {
	TopDocs topDocuments;
	Query query = NumericRangeQuery.newLongRange( Card.TAG_IDENTIFIER, identifier, identifier, true, true );
	try {
	    topDocuments = luceneSearcher.search( query, 1 );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}

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

	try {
	    luceneWriter.deleteDocuments( query );
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
	System.out.print("Deleted card with identifier "+Long.toString(identifier)+"\n");
	searcherRefresh();
	
    }

    public Card cardGetByIdentifier( long identifier )
    {
	
	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 )
    {
	BooleanQuery finalQuery = new BooleanQuery();

	finalQuery.add( new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD );
	for( int i = 0; i < hideQueries.length; i++ ) {
	    finalQuery.add( hideQueries[i], BooleanClause.Occur.MUST_NOT );
	}
	
	try {
	    TopDocs topDocuments = luceneSearcher.search(
						 finalQuery,
						 null,
						 amount,
						 new Sort( new SortField( Card.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;
	    
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
    }
    
    public Card[] searchSimple( String query )
    {

	Query parsedQuery;
	BooleanQuery finalQuery;
	
	try {
	    QueryParser queryParser = new QueryParser(
		    LUCENE_VERSION,
		    Card.TAG_SEARCH,
		    new StandardAnalyzer(LUCENE_VERSION)
	    );

	    queryParser.setAllowLeadingWildcard( true );
	    
	    parsedQuery = queryParser.parse( query );
	    
	} catch( ParseException e ) {
	    System.out.print( "Search query parsing exception, returning zero results: "+e.getMessage()+"\n" );
	    return new Card[0];
	}
	
	finalQuery = new BooleanQuery();

	finalQuery.add( parsedQuery, BooleanClause.Occur.SHOULD );
	for( int i = 0; i < hideQueries.length; i++ ) {
	    finalQuery.add( hideQueries[i], BooleanClause.Occur.MUST_NOT );
	}
	
	try {
	    
	    TopDocs hits = luceneSearcher.search( finalQuery, 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;
	    
	} catch( IOException e ) {
	    throw new RuntimeException(e);
	}
	
    }

}