/***********************************************************************************************************************
 * Copyright (c) 2008 empolis GmbH and brox IT Solutions GmbH. All rights reserved. This program and the accompanying
 * materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: August Georg Schmidt (brox IT Solutions GmbH) - initial API and implementation
 **********************************************************************************************************************/

package org.eclipse.smila.search;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Enumeration;
import java.util.Formatter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.smila.search.exceptions.AFException;
import org.eclipse.smila.search.index.IndexConnection;
import org.eclipse.smila.search.index.IndexException;
import org.eclipse.smila.search.index.IndexManager;
import org.eclipse.smila.search.plugin.Plugin;
import org.eclipse.smila.search.plugin.PluginFactory;
import org.eclipse.smila.search.search.tools.advsearch.AdvSearchException;
import org.eclipse.smila.search.search.tools.advsearch.IAdvSearch;
import org.eclipse.smila.search.search.tools.advsearch.IQueryExpression;
import org.eclipse.smila.search.search.tools.search.DAnyFinderSearch;
import org.eclipse.smila.search.search.tools.search.DAnyFinderSearchCodec;
import org.eclipse.smila.search.search.tools.search.DQuery;
import org.eclipse.smila.search.search.tools.search.DSearchException;
import org.eclipse.smila.search.search.tools.searchresult.DAnyFinderSearchResult;
import org.eclipse.smila.search.search.tools.searchresult.DAnyFinderSearchResultCodec;
import org.eclipse.smila.search.search.tools.searchresult.DHit;
import org.eclipse.smila.search.search.tools.searchresult.DHitDistribution;
import org.eclipse.smila.search.search.tools.searchresult.DItem;
import org.eclipse.smila.search.search.tools.searchresult.DResult;
import org.eclipse.smila.search.search.tools.searchresult.DSearchResultException;
import org.eclipse.smila.search.tools.errormessage.DErrorMessage;
import org.eclipse.smila.tools.XMLUtils;
import org.eclipse.smila.tools.XMLUtilsConfig;
import org.eclipse.smila.tools.XMLUtilsException;
import org.eclipse.smila.tools.cache.CacheException;
import org.eclipse.smila.tools.cache.CacheManager;
import org.eclipse.smila.tools.cache.CacheManagerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Search Class.
 * 
 * @author August Georg Schmidt (BROX)
 * @version 1.0
 */
public abstract class AFSearch {

  static {
    EIFActivator.registerSchemas();
  }

  /**
   * Hidden constructor. Class must be used via static methods.
   */
  private AFSearch() {
  }

  /**
   * takes the given bytearray which must rsult to a valid AnyFinderSearch- or AnyFinderAdvancedSearch-XML and performs
   * a search for it.
   * 
   * @param anyFinderAnySearchStream
   *          Search query as byte[].
   * @return Search result.
   * @throws AFException
   *           Exception during search.
   */
  public static DAnyFinderSearchResult search(byte[] anyFinderAnySearchStream) throws AFException {
    final Log log = LogFactory.getLog(AFSearch.class);
    DAnyFinderSearchResult dSR = null;
    try {
      // get anyfinder search
      final Document doc = XMLUtils.parse(anyFinderAnySearchStream, new XMLUtilsConfig());
      final Element root = doc.getDocumentElement();
      if ("AnyFinderSearch".equals(root.getLocalName())) {
        dSR = AFSearch.search(DAnyFinderSearchCodec.decode(root));
      } else if ("AnyFinderAdvancedSearch".equals(root.getLocalName())) {
        final Plugin plugin = PluginFactory.getPlugin();
        dSR = AFSearch.search(plugin.getAdvSearchAccess().decode(root));
      } else {
        dSR = new DAnyFinderSearchResult();

        final DErrorMessage dErrorMessage = new DErrorMessage();
        dErrorMessage.setCode("AF-ERR");
        dErrorMessage.setMessage("AnyFinder Error");
        dErrorMessage.setDetail("Given ByteArray is neither a AnyFinderSearch nor an AnyFinderAdvancedSearch");
        dErrorMessage.setSource(AFSearch.class.getName());
        dSR.setErrorMessage(dErrorMessage);
        log.error(dErrorMessage.getDetail());
      }
    } catch (final XMLUtilsException e) {
      log.error(e.getMessage());
      throw new AFException("Unable to parse given xml stream", e);
    } catch (final AdvSearchException e) {
      throw new AFException("Unable to decode AdvancedSearch", e);
    } catch (final DSearchException e) {
      throw new AFException("Unable to decode search: " + e.getMessage());
    } catch (final ClassCastException e) {
      throw new AFException("Error during class conversion", e);
    }

    // exceute search
    return dSR;
  }

  /**
   * Execute search for a <code>DAnyFinderSearch</code> object.
   * 
   * @param dSimpleSearch
   *          Search to execute.
   * @return Search result.
   */
  public static DAnyFinderSearchResult search(DAnyFinderSearch dSimpleSearch) {
    final Log log = LogFactory.getLog(AFSearch.class);

    final DAnyFinderSearchResult dAnyFinderSearchResult = new DAnyFinderSearchResult();
    final Enumeration queries = dSimpleSearch.getQueries();
    if (queries != null) {
      while (queries.hasMoreElements()) {
        DQuery dQuery = null;
        long start = 0;
        try {
          dQuery = (DQuery) queries.nextElement();
          String indexName = dQuery.getIndexName();

          if (indexName != null) {
            indexName = indexName.trim();
          } else {
            throw new IndexException("index name is not specified in query");
          }

          if ("".equals(indexName)) {
            throw new IndexException("index name is empty in query");
          }

          final CacheManager<String, DResult> cache = CacheManagerFactory.getInstance();

          start = System.currentTimeMillis();
          if (indexName.indexOf(';') == -1) {

            final String sQuery = dQuery.toString();
            final String queryHash = getMD5Hash(sQuery);
            final String queryName = byteArrayToString(sQuery.getBytes());
            final String qualifiedNameInCache = "/" + dQuery.getIndexName() + "/" + queryHash;
            DResult dResult = null;
            if (cache.exists(qualifiedNameInCache, queryName)) {
              dResult = cache.get(qualifiedNameInCache, queryName);
              if (dResult != null) {
                dAnyFinderSearchResult.addResult(dResult);
              }
            } else {
              // get Pool, do query, and release it
              boolean killPoolConnection = false;
              IndexConnection indexConnection = null;
              try {
                indexConnection = IndexManager.getInstance(indexName);
                if (log.isInfoEnabled()) {
                  log.info("Time to get instance: " + (System.currentTimeMillis() - start) + "[ms]");
                }
                // TODO:
                dResult = null; //indexConnection.doQuery(dQuery);
                if (dResult != null) {
                  dAnyFinderSearchResult.addResult(dResult);
                }
                if ((dResult != null) && (dResult.getErrorMessage() == null)) {
                  cache.put(qualifiedNameInCache, queryName, dResult);
                }
              } catch (final IndexException e) {
                killPoolConnection = true;
                throw e;
              } finally {
                if (indexConnection != null) {
                  IndexManager.releaseInstance(indexConnection, killPoolConnection);
                  if (log.isDebugEnabled()) {
                    log.debug("Time to Release: " + (System.currentTimeMillis() - start) + "[ms]");
                  }
                }
              }
            }
          } else {
            searchOnMultipleIndizes(indexName, dQuery, dAnyFinderSearchResult, start);
          }
          if (log.isInfoEnabled()) {
            log.info("Time to Query result: " + (System.currentTimeMillis() - start) + "[ms]");
          }
        } catch (final IndexException e) {
          createErrorMessage(dAnyFinderSearchResult, dQuery.getIndexName(), e);
        } catch (final Exception e) {
          createErrorMessage(dAnyFinderSearchResult, dQuery.getIndexName(), e);
        } // try
      } // while
    } // if

    return dAnyFinderSearchResult;
  }

  /**
   * Create a MD5 Hash from a String.
   * 
   * @param in
   *          String to create MD5 hash from.
   * @return MD5 Hash as String.
   */
  private static String getMD5Hash(String in) {
    final Log log = LogFactory.getLog(AFSearch.class);
    final StringBuffer result = new StringBuffer(32);
    try {
      final MessageDigest md5 = MessageDigest.getInstance("MD5");
      md5.update(in.getBytes());
      final Formatter f = new Formatter(result);
      for (final byte b : md5.digest()) {
        f.format("%02x", b);
      }
    } catch (final NoSuchAlgorithmException ex) {
      if (log.isErrorEnabled()) {
        log.error(ex);
      }
    }
    return result.toString();
  }

  /**
   * Create a String from a byte[].
   * 
   * @param bytes
   *          Byte[] for string conversion.
   * @return Byte[] as String.
   */
  private static String byteArrayToString(byte[] bytes) {
    final StringBuffer result = new StringBuffer(32);
    final Formatter f = new Formatter(result);
    for (final byte b : bytes) {
      f.format("%02x", b);
    }
    return result.toString();
  }

  /**
   * Search on multiple indices with extended search result merging and caching.
   * 
   * @param indexName
   *          Index names for search query. (';' is delemiter)
   * @param dQuery
   *          Search query to execute.
   * @param dAnyFinderSearchResult
   *          Search result.
   * @param startTime
   *          Start time for logging.
   * @throws IndexException
   *           Search problems.
   * @throws CacheException
   *           Exception during cache access.
   */
  private static void searchOnMultipleIndizes(String indexName, DQuery dQuery,
    final DAnyFinderSearchResult dAnyFinderSearchResult, long startTime) throws IndexException, CacheException {
    final Log log = LogFactory.getLog(AFSearch.class);
    String[] indexNames = indexName.split(";");
    indexNames = normalizeIndexNames(indexNames);

    final HashMap<String, DHitDistribution> hitDistributions = getHitDistributionsForQuery(indexNames, dQuery);

    int startHits = 0;
    if (dQuery.getStartHits() != null) {
      startHits = dQuery.getStartHits().intValue();
    }
    final QueryScope[] queryScopes =
      FederatedQueryHandling.calculateQueries(indexNames, startHits, dQuery.getMaxHits(), hitDistributions);

    final CacheManager<String, DResult> cache = CacheManagerFactory.getInstance();
    final DResult dMergedResult = new DResult();
    dMergedResult.setName(indexName);
    for (final QueryScope queryScope : queryScopes) {

      boolean killPoolConnection = false;
      IndexConnection indexConnection = null;
      try {
        final long start2 = System.currentTimeMillis();
        dQuery.setIndexName(queryScope.getIndexName());
        dQuery.setStartHits(queryScope.getStart());
        dQuery.setMaxHits(queryScope.getHits());

        final String sQuery = dQuery.toString();
        final String queryHash = getMD5Hash(sQuery);
        final String queryName = byteArrayToString(sQuery.getBytes());
        final String qualifiedNameInCache = "/" + dQuery.getIndexName() + "/" + queryHash;
        DResult dResult = null;
        if (cache.exists(qualifiedNameInCache, queryName)) {
          dResult = cache.get(qualifiedNameInCache, queryName);
        } else {
          indexConnection = IndexManager.getInstance(queryScope.getIndexName());
          if (log.isInfoEnabled()) {
            log.info("Time to get instance [" + queryScope.getIndexName() + "]: "
              + (System.currentTimeMillis() - start2) + "[ms]");
          }
          // TODO:
          dResult = null; //indexConnection.doQuery(dQuery);

          if ((dResult != null) && (dResult.getErrorMessage() == null)) {
            cache.put(qualifiedNameInCache, queryName, dResult);
          }
        }

        if (dResult != null) {

          if (dResult.getErrorMessage() != null) {
            dMergedResult.clearItems();
            dMergedResult.setErrorMessage(dResult.getErrorMessage());
            dMergedResult.setHitDistribution(null);
            break;
          }

          addItemsToExistingResult(startHits, dMergedResult, dResult, queryScope);
        }
      } catch (final IndexException e) {
        killPoolConnection = true;
        throw e;
      } finally {
        if (indexConnection != null) {
          IndexManager.releaseInstance(indexConnection, killPoolConnection);
          if (log.isDebugEnabled()) {
            log.debug("Time to Release [" + queryScope.getIndexName() + "]: "
              + (System.currentTimeMillis() - startTime) + "[ms]");
          }
        }
      }

    }

    final HashMap<Integer, DHit> hits = new HashMap<Integer, DHit>();
    for (final DHitDistribution hitDistribution : hitDistributions.values()) {
      updateHitDistribution(hitDistribution, hits);
    }

    final DHitDistribution hd = new DHitDistribution();
    for (final Iterator iter = hits.values().iterator(); iter.hasNext();) {
      final DHit hit = (DHit) iter.next();
      hd.addHit(hit);
    }
    if (hd.getHitsCount() != 0) {
      dMergedResult.setHitDistribution(hd);
    }
    dMergedResult.setHits(dMergedResult.getItemsCount());
    dAnyFinderSearchResult.addResult(dMergedResult);
  }

  /**
   * This function removes dublicate entries from a set of index names. Index names are treated case sensitive.
   * 
   * @param indexNames
   *          Index names to normalize.
   * @return Normalized index names.
   */
  public static String[] normalizeIndexNames(String[] indexNames) {
    final Set<String> indexNamesAsSet = new HashSet<String>();

    // TODO: check order of returned index names. ==> order could probably have a result for paging

    for (final String indexName : indexNames) {
      indexNamesAsSet.add(indexName.trim());
    }

    return indexNamesAsSet.toArray(new String[0]);
  }

  /**
   * @param indexNames
   *          Array of indices to query on.
   * @param query
   *          Base query for request.
   * @return DHitDistribution per index.
   * @throws IndexException
   *           Exception statitng that a search has failed.
   * @throws CacheException
   *           Exception during cache access.
   */
  private static HashMap<String, DHitDistribution> getHitDistributionsForQuery(String[] indexNames, DQuery query)
    throws IndexException, CacheException {
    final DQuery queryClone = (DQuery) query.clone();

    // start at first document; these is a good chance for a cached result
    queryClone.setStartHits(0);

    final HashMap<String, DHitDistribution> hitDistributions = new HashMap<String, DHitDistribution>();
    final CacheManager<String, DResult> cache = CacheManagerFactory.getInstance();

    for (final String indexName : indexNames) {
      queryClone.setIndexName(indexName);
      final String sQuery = queryClone.toString();
      final String queryHash = getMD5Hash(sQuery);
      final String queryName = byteArrayToString(sQuery.getBytes());
      boolean killPoolConnection = false;
      IndexConnection indexConnection = null;
      try {
        DResult dResult = null;
        final String qualifiedNameInCache = "/" + queryClone.getIndexName() + "/" + queryHash;
        if (cache.exists(qualifiedNameInCache, queryName)) {
          dResult = cache.get(qualifiedNameInCache, queryName);
          dResult = cache.get(qualifiedNameInCache, queryName);
          dResult = cache.get(qualifiedNameInCache, queryName);
          dResult = cache.get(qualifiedNameInCache, queryName);
          dResult = cache.get(qualifiedNameInCache, queryName);
        } else {
          indexConnection = IndexManager.getInstance(indexName);
          // TODO:
          dResult = null; //indexConnection.doQuery(queryClone);
          cache.put(qualifiedNameInCache, queryName, dResult);
        }

        if ((dResult != null) && (dResult.getErrorMessage() == null)) {
          hitDistributions.put(indexName, dResult.getHitDistribution());
        }
      } catch (final IndexException e) {
        killPoolConnection = true;
        throw e;
      } finally {
        if (indexConnection != null) {
          IndexManager.releaseInstance(indexConnection, killPoolConnection);
        }
      }
    }

    return hitDistributions;
  }

  /**
   * Add items to an existing search result. The basis structure for the hit distribution is also updated.
   * 
   * @param startHits
   *          Start of hits in result set.
   * @param targetResult
   *          Target search result.
   * @param sourceResult
   *          Source search result.
   * @param queryScope
   *          Query scope item selection.
   */
  private static void addItemsToExistingResult(final int startHits, final DResult targetResult,
    final DResult sourceResult, final QueryScope queryScope) {
    // add items
    int recordsSelected = 0;
    final int resultPositionStartSelection = (queryScope.getStartSelection() % queryScope.getHits()) - 1;
    for (int j = 0; j < sourceResult.getItemsCount(); j++) {
      if ((j >= resultPositionStartSelection) && (recordsSelected < queryScope.getRecordsToSelect())) {
        recordsSelected++;
        final DItem item = (DItem) sourceResult.getItem(j).clone();
        item.setPos(targetResult.getItemsCount() + startHits);
        targetResult.addItem(item);
      }
    }
  }

  /**
   * Update hit distribution.
   * 
   * @param srcHD
   *          Source hit distribution.
   * @param hits
   *          Structure containing the merged hit distribution.
   */
  private static void updateHitDistribution(final DHitDistribution srcHD, final HashMap<Integer, DHit> hits) {
    for (int j = 0; j < srcHD.getHitsCount(); j++) {
      final DHit srcHit = srcHD.getHit(j);

      if (hits.containsKey(new Integer(srcHit.getScore()))) {
        final DHit hit = hits.get(new Integer(srcHit.getScore()));
        hit.setHits(srcHit.getHits() + hit.getHits());
      } else {
        hits.put(new Integer(srcHit.getScore()), new DHit(srcHit.getScore(), srcHit.getHits()));
      }
    }
  }

  /**
   * Takes <code>IAdvSearch</code> object and performs a search with it. The result could be multiple queries.
   * 
   * @param dAdvancedSearch
   *          Search to be executed.
   * @return Search result.
   */
  public static DAnyFinderSearchResult search(IAdvSearch dAdvancedSearch) {

    final DAnyFinderSearchResult dAnyFinderSearchResult = new DAnyFinderSearchResult();

    // technically several QE are supported per AFAS but only one is currently allowed
    final Iterator queries = dAdvancedSearch.getQueryExpressions();
    while (queries.hasNext()) {
      final IQueryExpression dQE = (IQueryExpression) queries.next();
      final DResult dResult = search(dQE, dQE.getIndexName());
      if (dResult != null) {
        dAnyFinderSearchResult.addResult(dResult);
      }
    } // while

    return dAnyFinderSearchResult;
  }

  /**
   * Takes either a <code>.search.DQuery</code> or a <code>.advsearch.DQueryExpression</code> object and performs
   * with that a search.
   * 
   * @param dAnyQuery
   *          DQuery or IQueryExpression object containing an query to execute.
   * @param indexName
   *          Name of index onto which the query is executed.
   * @return Search result.
   */
  private static DResult search(Object dAnyQuery, String indexName) {
    final Log log = LogFactory.getLog(AFSearch.class);
    DResult dResult = null;
    IndexConnection indexConnection = null;
    long start = 0;
    boolean killPoolConnection = false;

    // get Pool, do query, and release it
    try {
      start = System.currentTimeMillis();

      indexConnection = IndexManager.getInstance(indexName);
      if (log.isInfoEnabled()) {
        log.info("Time to get instance: " + (System.currentTimeMillis() - start) + "[ms]");
      }

      // perform query
      if (dAnyQuery instanceof DQuery) {
        // TODO:
        dResult = null; //indexConnection.doQuery((DQuery) dAnyQuery);
      } else if (dAnyQuery instanceof IQueryExpression) {
        // TODO:
        dResult = null; //indexConnection.doQuery((IQueryExpression) dAnyQuery);
      } else {
        dResult = new DResult();
        dResult.setName(indexName);
        dResult.setHits(0);
        final DErrorMessage dErrorMessage = new DErrorMessage();
        dErrorMessage.setCode("AF-ERR");
        dErrorMessage.setMessage("AnyFinder Error");
        dErrorMessage.setDetail("Object dAnyQuery is neither of Class DQuery nor DQueryExpression");
        dErrorMessage.setSource(AFSearch.class.getName());
        dResult.setErrorMessage(dErrorMessage);
        log.error(dErrorMessage.getDetail());
        killPoolConnection = true;
      }

      if (log.isInfoEnabled()) {
        log.info("Time to Query result: " + (System.currentTimeMillis() - start) + "[ms]");
      }
    } catch (final IndexException e) {
      dResult = createErrorMessage2(indexName, e);
      killPoolConnection = true;
    } catch (final Exception e) {
      dResult = createErrorMessage2(indexName, e);
      killPoolConnection = true;
    } finally {
      if (indexConnection != null) {
        IndexManager.releaseInstance(indexConnection, killPoolConnection);
        if (log.isDebugEnabled()) {
          log.debug("Time to Release: " + (System.currentTimeMillis() - start) + "[ms]");
        }
      }
    } // try
    return dResult;
  }

  /**
   * Prepare and log error message for result.
   * 
   * @param dAnyFinderSearchResult
   *          Search result where the error is appended.
   * @param indexName
   *          Index name.
   * @param exception
   *          Exception occured in code.
   */
  private static void createErrorMessage(final DAnyFinderSearchResult dAnyFinderSearchResult, String indexName,
    Exception exception) {
    final Log log = LogFactory.getLog(AFSearch.class);
    final DResult dResult = prepareErrorMessageFromException(indexName, exception);
    dAnyFinderSearchResult.addResult(dResult);
    log.error("", exception);
  }

  /**
   * Prepare DResult containing error description.
   * 
   * @param indexName
   *          Index name.
   * @param exception
   *          Exception occured in code.
   * @return DResult containing error description.
   */
  private static DResult prepareErrorMessageFromException(String indexName, Exception exception) {
    final DResult dResult = new DResult();
    dResult.setName(indexName);
    dResult.setHits(0);
    final DErrorMessage dErrorMessage = new DErrorMessage();
    dErrorMessage.setCode("AF-ERR");
    dErrorMessage.setMessage("AnyFinder Error");
    if (exception.getMessage() != null) {
      dErrorMessage.setDetail(exception.getMessage());
    } else {
      dErrorMessage.setDetail(exception.getClass().getName());
    }
    dErrorMessage.setSource(AFSearch.class.getName());
    dResult.setErrorMessage(dErrorMessage);
    return dResult;
  }

  /**
   * Create error message result structure.
   * 
   * @param indexName
   *          Index name where the error occured in request.
   * @param exception
   *          Exception in code.
   * @return DResult containing an error message.
   */
  private static DResult createErrorMessage2(String indexName, Exception exception) {
    final Log log = LogFactory.getLog(AFSearch.class);
    final DResult dResult = prepareErrorMessageFromException(indexName, exception);
    log.error("", exception);
    return dResult;
  }

  /**
   * Converts a <code>DAnyFinderSearchResult</code> to a byte[].
   * 
   * @param dAnyFinderSearchResult
   *          search result to transform.
   * @return Streamed search result.
   * @throws AFException
   *           Streaming error.
   */
  public static final byte[] toStream(DAnyFinderSearchResult dAnyFinderSearchResult) throws AFException {
    try {
      final Document doc = DAnyFinderSearchResultCodec.encode(dAnyFinderSearchResult);
      final byte[] bytes = XMLUtils.stream(doc.getDocumentElement(), true, true);
      return bytes;
    } catch (final DSearchResultException e) {
      throw new AFException("unable encode AnyFinderSearchResult", e);
    } catch (final XMLUtilsException e) {
      throw new AFException("unable to stream AnyFinderSearchResult", e);
    }
  }

}