/***
    * 
    */
   package hu.elte.tribus.services;
   
   import hu.elte.tribus.model.QA;
   import hu.elte.tribus.model.Topic;
   
   import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.io.StringReader;
  import java.util.Iterator;
  
  import org.apache.log4j.Logger;
  import org.apache.lucene.analysis.Analyzer;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.document.Field.Index;
  import org.apache.lucene.document.Field.Store;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.search.Hit;
  import org.apache.lucene.search.Hits;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.TermQuery;
  import org.apache.lucene.store.Directory;
  import org.hibernate.EmptyInterceptor;
  import org.hibernate.type.Type;
  
  /***
   * Cos life of the smurfs is not just fun.
   * 
   * @author kocka
   * 
   */
  @SuppressWarnings("serial")
  public class IndexingInterceptor extends EmptyInterceptor {
  
  	Directory directory = null;
  
  	Analyzer analyzer = null;
  	
  	private final static Logger logger = Logger.getLogger(IndexingInterceptor.class);
  	
  	void deleteDocument(String type, Serializable key) {
  		IndexSearcher indexSearcher = null;
  		IndexReader indexReader = null;
  		try {
  			indexSearcher = new IndexSearcher(directory);
  			indexReader = IndexReader.open(directory);
  			Hits hits = indexSearcher.search(new TermQuery(new Term("id", key.toString())));
  			Iterator it = hits.iterator();
  			if(hits.length() == 0) {
  				logger.warn("There was no document like that in index, consider full reindexing!");
  			}
  			while(it.hasNext()) {
  				//innen mar csak hit kerdese
  				Hit hit = (Hit) it.next();
  				logger.info("deleting from index:"+hit.getId());
  				indexReader.deleteDocument(hit.getId());
  			}
  		} catch (IOException e) {
  			logger.fatal("Indexing error at deleting document!", e);
  		} finally {
  			try {
  				if(indexSearcher != null) {
  					indexSearcher.close();
  				}
  				if(indexReader != null) {
  					indexReader.close();
  				}
  			} catch (IOException e) {
  				logger.warn("Hopszare", e);
  			}
  		}
  	}
  
  	void saveDocument(Document document) {
  		if(document == null) {
  			return;
  		}
  		IndexWriter indexWriter = null;
  		try {
  			indexWriter = new IndexWriter(directory, analyzer, false);
  			indexWriter.addDocument(document);
  			indexWriter.optimize();
  		} catch (IOException e) {
  			logger.fatal("Could not save document to index.", e);
  		} finally {
  			try {
  				if(indexWriter != null)
  					indexWriter.close();
  			} catch (IOException e) {
  				logger.warn("Could not close indexwriter.");
  			}
  		}
 
 	}
 	
 	public static byte[] serialize(Serializable data) {
 		try {
 			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
 			ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
 			objectOutputStream.writeObject(data);
 			return byteArrayOutputStream.toByteArray();
 		} catch (IOException e) {
 			logger.error("Errorn serializing",e);
 			return null;
 		}
 
 	}
 	
 	Document createDocument(Serializable key, Object[] data, String[] properties) {
 		// soo limited, but we will search QA only...
 		String question = null;
 		String answer = null;
 		Topic topic = null;
 		for (int i = 0; i < data.length; i++) {
 			if ("question".equals(properties[i]))
 				question = (String) data[i];
 			if ("answer".equals(properties[i]))
 				answer = (String) data[i];
 			if ("topic".equals(properties[i]))
 				topic = (Topic) data[i];
 		}
 		if(topic == null){
 			return null;
 		}
 
 		Document document = new Document();
 		document.add(new Field("type", new StringReader("qa")));
 		document.add(new Field("id", serialize(key), Store.YES));
 		document.add(new Field("topic",topic.getId().toString(), Store.YES, Index.UN_TOKENIZED));
 		document.add(new Field("question", new StringReader(question == null ? "" : question)));
 		document.add(new Field("answer", new StringReader(answer == null ? "" : answer)));
 		return document;
 	}
 
 	public void onDelete(Object entity, Serializable key, Object[] data,
 			String[] properties, Type[] types) {
 		if (entity instanceof QA) {
 			saveDocument(createDocument(key, data, properties));
 		}
 	}
 
 	public boolean onFlushDirty(Object entity, Serializable key, Object[] data,
 			Object[] previousState, String[] properties, Type[] types) {
 		if(entity instanceof QA) {
 			deleteDocument("qa", key);
 			saveDocument(createDocument(key, data, properties));
 		}
 		return false;
 	}
 
 	public boolean onSave(Object entity, Serializable key, Object[] data, String[] properties, Type[] types) {
 		if(entity instanceof QA) {
 			saveDocument(createDocument(key, data, properties));
 		}
 		return false;
 	}
 
 	public Analyzer getAnalyzer() {
 		return analyzer;
 	}
 
 	public void setAnalyzer(Analyzer analyzer) {
 		this.analyzer = analyzer;
 	}
 
 	public Directory getDirectory() {
 		return directory;
 	}
 
 	public void setDirectory(Directory directory) {
 		this.directory = directory;
 	}
 
 }