D-Net

package eu.dnetlib.index.query;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.function.Function;

import java.util.stream.Collectors;

import com.google.common.collect.BiMap;

import com.google.common.collect.Iterables;

import com.google.common.collect.Lists;

import eu.dnetlib.clients.index.query.QueryResponseParser;

import eu.dnetlib.clients.index.utils.IndexFieldUtility;

import eu.dnetlib.rmi.provision.BrowsingRow;

import eu.dnetlib.rmi.provision.GroupResult;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.solr.client.solrj.response.FacetField;

import org.apache.solr.client.solrj.response.FacetField.Count;

import org.apache.solr.client.solrj.response.QueryResponse;

import org.apache.solr.common.SolrDocument;

import org.apache.solr.common.SolrDocumentList;

/**

 * The Class SolrResponseParser.

 */

public class SolrResponseParser extends QueryResponseParser {

	/**

	 * logger.

	 */

	private static final Log log = LogFactory.getLog(SolrResponseParser.class);

	/**

	 * The wrapper rank.

	 */

	protected final Function<SolrDocument, String> wrapperRank =

			doc -> addRanking(getSingleField(doc, IndexFieldUtility.RESULT), getSingleField(doc, IndexFieldUtility.SCORE_FIELD));

	/**

	 * The wrapper no rank.

	 */

	protected final Function<SolrDocument, String> wrapperNoRank = doc -> wrap(getSingleField(doc, IndexFieldUtility.RESULT));

	/**

	 * Lower level response.

	 */

	private QueryResponse queryRsp = null;

	/**

	 * The Constructor.

	 *

	 * @param highlightUtils    the highlight utils

	 * @param aliases           the aliases

	 * @param returnEmptyFields the return empty fields

	 * @param includeRanking    the include ranking

	 * @param response          the response

	 */

	public SolrResponseParser(final Function<String, String> highlightUtils, final BiMap<String, String> aliases, final boolean returnEmptyFields,

			final boolean includeRanking, final QueryResponse response) {

		super(highlightUtils, aliases, returnEmptyFields, includeRanking);

		this.queryRsp = response;

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public long getNumFound() {

		return this.queryRsp.getResults().getNumFound();

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public int getQueryTime() {

		return queryRsp.getQTime();

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public long getElapsedTime() {

		return queryRsp.getElapsedTime();

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public String getStatus() {

		return String.valueOf(queryRsp.getStatus());

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public int getCurrentSize() {

		return queryRsp.getResults().size();

	}

	/**

	 * Gets the query response.

	 *

	 * @return the query response

	 */

	public QueryResponse getQueryResponse() {

		return queryRsp;

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public List<String> getResults() {

		return asRankedList(queryRsp.getResults());

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public Long getNumberOfBrowsingResults() {

		List<FacetField> ffList = queryRsp.getFacetFields();

		Long maxCount = 0L;

		if (ffList != null) {

			for (FacetField ff : ffList) {

				if (ff != null) {

					Long countFacets = countFacets(ff.getValues());

					if (countFacets > maxCount) {

						maxCount = countFacets;

					}

				}

			}

		}

		return maxCount;

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public List<BrowsingRow> getBrowsingResults() {

		List<BrowsingRow> bresList = new ArrayList<>();

		List<GroupResult> facets = new ArrayList<>();

		final List<FacetField> ffList = queryRsp.getFacetFields();

		Long numberOfBrowsingResults = getNumberOfBrowsingResults();

		for (int i = 0; (ffList != null) && (i < numberOfBrowsingResults); i++) {

			for (FacetField ff : ffList) {

				String name = null;

				if (aliases != null) {

					name = aliases.inverse().get(ff.getName());

				}

				// fix #1456

				if (name == null) {

					name = ff.getName();

				}

				final Count facet = getFacet(ff, i);

				if ((facet != null) && (facet.getCount() > 0)) {

					final String value = facet.getName();

					final int count = (int) facet.getCount();

					if (returnEmptyFields || !value.isEmpty()) {

						facets.add(new GroupResult(name, value, count));

					}

				}

			}

			if (facets.size() > 0) {

				bresList.add(new BrowsingRow(Lists.newArrayList(facets)));

				facets.clear();

			}

		}

		if (log.isDebugEnabled()) {

			log.debug("BrowsingResult size: " + bresList.size());

		}

		return bresList;

	}

	// /////////////// helpers

	/**

	 * Gets the facet.

	 *

	 * @param ff  the ff

	 * @param pos the pos

	 * @return the facet

	 */

	private Count getFacet(final FacetField ff, final int pos) {

		if ((ff.getValues() == null) || (pos >= ff.getValues().size())) return null;

		return ff.getValues().get(pos);

	}

	/**

	 * Given SolrDocumentList, return a List of Strings, representing it.

	 *

	 * @param documentList the document list

	 * @return the list< string>

	 */

	private List<String> asRankedList(final SolrDocumentList documentList) {

		Function<SolrDocument, String> wrapper = includeRanking ? wrapperRank : wrapperNoRank;

		if (queryRsp.getHighlighting() != null) return documentList

				.stream()

				.map(doc -> {

					String score = getSingleField(doc, IndexFieldUtility.SCORE_FIELD);

					String hl = getHighlighting(getSingleField(doc, IndexFieldUtility.INDEX_RECORD_ID));

					String res = hl != null ? hl : getSingleField(doc, IndexFieldUtility.RESULT);

					return includeRanking ? addRanking(res, score) : wrap(res);

				}).map(highlightUtils)

				.collect(Collectors.toList());

		return documentList.stream().map(wrapper).collect(Collectors.toList());

	}

	/**

	 * Converts a String document to

	 * <p>

	 * <record rank="score"> [document] </record>.

	 *

	 * @param doc   the doc

	 * @param score the score

	 * @return the string

	 */

	private String addRanking(final String doc, final String score) {

		return new String("<record rank=\"" + score + "\">" + doc + "</record>");

	}

	/**

	 * Wraps the given document as <record> [document] </record>.

	 *

	 * @param doc the doc

	 * @return the string

	 */

	private String wrap(final String doc) {

		return new String("<record>" + doc + "</record>");

	}

	/**

	 * Gets the single field.

	 *

	 * @param doc       the doc

	 * @param fieldName the field name

	 * @return the single field

	 */

	@SuppressWarnings("unchecked")

	protected String getSingleField(final SolrDocument doc, final String fieldName) {

		Object value = doc.getFieldValue(fieldName);

		if (value instanceof Collection) return Iterables.getOnlyElement((Iterable<String>) value);

		return String.valueOf(value);

	}

	/**

	 * Gets the highlighting.

	 *

	 * @param docId the doc id

	 * @return the highlighting

	 */

	private String getHighlighting(final String docId) {

		final Map<String, List<String>> highlight = queryRsp.getHighlighting().get(docId);

		String result = new String();

		if ((highlight != null) && (highlight.get(IndexFieldUtility.RESULT) != null)) {

			for (String s : highlight.get(IndexFieldUtility.RESULT)) {

				result = result.concat(s);

			}

			return result;

		}

		return null;

	}

	/**

	 * helper method.

	 *

	 * @param facets the list of facets to analyze

	 * @return the number of non-empty facets in the list whose count is greater than zero

	 */

	private Long countFacets(final List<Count> facets) {

		if (facets == null) return 0L;

		return facets.stream().filter(c -> (c != null) && (c.getName() != null) && !c.getName().isEmpty() && (c.getCount() > 0)).count();

	}

	@Override

	public long getStart() {

		// TODO Auto-generated method stub

		return queryRsp.getResults().getStart();

	}

}