#include "nsLuceneHighlighter.h"
#include "nsLuceneQuery.h"
#include "nsILuceneAnalyzer.h"
#include "nsLuceneAnalyzer.h"

#include "CLucene/CLConfig.h"
#include "CLucene.h"

#include "CLucene/highlighter/QueryScorer.h"
#include "CLucene/highlighter/Highlighter.h"
#include "CLucene/highlighter/Formatter.h"
#include "CLucene/highlighter/SimpleHTMLFormatter.h"
#include "CLucene/highlighter/Fragmenter.h"
#include "CLucene/highlighter/SimpleFragmenter.h"

NS_IMPL_ISUPPORTS1(nsLuceneHighlighter, nsILuceneHighlighter)

nsLuceneHighlighter::nsLuceneHighlighter(nsILuceneQuery* aQuery,
                                         const nsAString& aFragmentSeparator,
                                         PRInt16 aMaxNumFragmentsRequired,
                                         const nsAString& preTag,
                                         const nsAString& postTag)
{
  nsLuceneStringConverter preTag32(preTag);
  nsLuceneStringConverter postTag32(postTag);

  mFormatter  =
    new lucene::search::highlight::SimpleHTMLFormatter((wchar_t*)  preTag32.get(),
                                                       (wchar_t*) postTag32.get());
  mFragmenter = new lucene::search::highlight::SimpleFragmenter();

  mQuery = aQuery;
  mFragmentSeparator = aFragmentSeparator;
  mMaxNumFragmentsRequired = aMaxNumFragmentsRequired;

  mFragmentSeparator32 = new nsLuceneStringConverter(aFragmentSeparator);

  mScorer =
    new lucene::search::highlight::QueryScorer(((nsLuceneQuery*) aQuery)
      ->getQuery());
  mHighlighter = new lucene::search::highlight::Highlighter(mFormatter,
                                                            mScorer);

  /*
   * XXX: This crashes when clucene is not compiled in debug mode and I have
   * no idea why.  Thankfully it actually is not needed because the
   * SimpleFragmenter is the default fragmenter
   */
  //mHighlighter->setTextFragmenter(mFragmenter);
}

nsLuceneHighlighter::~nsLuceneHighlighter()
{
  if(mScorer) {
    delete mScorer;
  }

  if(mHighlighter) {
    delete mHighlighter;
  }

  if(mFormatter) {
    delete mFormatter;
  }

  if(mFragmenter) {
    delete mFragmenter;
  }

  if(mFragmentSeparator32) {
    delete mFragmentSeparator32;
  }
}

NS_IMETHODIMP
nsLuceneHighlighter::Highlight(nsILuceneAnalyzer* analyzer,
                               const nsAString& field,
                               const nsAString& text,
                               nsAString& _retval)
{
  if(!mQuery) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  nsLuceneStringConverter text32(text);
  nsLuceneStringConverter field32(field);

  lucene::util::StringReader reader((wchar_t*) text32.get());
  lucene::analysis::TokenStream* tokenStream =
    ((nsLuceneAnalyzer*) analyzer)->getAnalyzer()
    ->tokenStream((wchar_t*) field32.get(), &reader);

  wchar_t* result =
    mHighlighter->getBestFragments(
      tokenStream,
      (wchar_t*) text32.get(),
      mMaxNumFragmentsRequired,
      (wchar_t*) mFragmentSeparator32->get());

  nsLuceneStringConverter::makeNsString((utf32_t*) result, _retval);

  delete [] result;
  delete tokenStream;

  return NS_OK;
}