/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.jackrabbit.core.query.lucene;

import org.apache.jackrabbit.core.NodeImpl;
import org.apache.jackrabbit.core.id.NodeId;
import org.apache.jackrabbit.core.ItemManager;
import org.apache.jackrabbit.core.HierarchyManager;
import org.apache.jackrabbit.spi.commons.conversion.NameException;
import org.apache.jackrabbit.spi.Name;
import org.apache.jackrabbit.spi.QValueFactory;
import org.apache.jackrabbit.spi.QValue;
import org.apache.jackrabbit.spi.commons.name.NameConstants;
import org.apache.jackrabbit.spi.commons.name.NameFactoryImpl;
import org.apache.jackrabbit.spi.commons.conversion.NamePathResolver;
import org.apache.jackrabbit.spi.commons.value.QValueFactoryImpl;
import org.apache.jackrabbit.spi.commons.value.ValueFactoryQImpl;
import org.apache.jackrabbit.spi.commons.query.qom.ColumnImpl;
import org.apache.jackrabbit.util.ISO9075;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import javax.jcr.ItemNotFoundException;
import javax.jcr.Property;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Value;
import javax.jcr.PathNotFoundException;
import javax.jcr.NamespaceException;
import javax.jcr.Node;
import javax.jcr.ValueFactory;
import javax.jcr.query.Row;
import javax.jcr.query.RowIterator;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.io.IOException;

/**
 * Implements the {@link javax.jcr.query.RowIterator} interface returned by
 * a {@link javax.jcr.query.QueryResult}.
 */
class RowIteratorImpl implements RowIterator {

    /**
     * The logger instance for this class.
     */
    private static final Logger log = LoggerFactory.getLogger(RowIteratorImpl.class);

    /**
     * The name of the excerpt function without prefix but with left parenthesis.
     */
    private static final String EXCERPT_FUNC_LPAR = "excerpt(";

    /**
     * The name of the spell check function without prefix but with left
     * parenthesis.
     */
    private static final String SPELLCHECK_FUNC_LPAR = "spellcheck(";

    /**
     * The start Name for the rep:excerpt function: rep:excerpt(
     */
    private static final Name REP_EXCERPT_LPAR = NameFactoryImpl.getInstance().create(
            Name.NS_REP_URI, EXCERPT_FUNC_LPAR);

    /**
     * Iterator over nodes, that constitute the result set.
     */
    private final ScoreNodeIterator scoreNodes;

    /**
     * Linked map of {@link ColumnImpl columns}, indexed by their column name
     * (String).
     */
    private final Map<String, ColumnImpl> columns;

    /**
     * List of valid selector {@link Name}s.
     */
    private final List<Name> selectorNames = new ArrayList<Name>();

    /**
     * The item manager of the session that executes the query.
     */
    private final ItemManager itemMgr;

    /**
     * The hierarchy manager of the workspace.
     */
    private final HierarchyManager hmgr;

    /**
     * The <code>NamePathResolver</code> of the user <code>Session</code>.
     */
    private final NamePathResolver resolver;

    /**
     * The excerpt provider or <code>null</code> if none is available.
     */
    private final ExcerptProvider excerptProvider;

    /**
     * The spell suggestion or <code>null</code> if none is available.
     */
    private final SpellSuggestion spellSuggestion;

    /**
     * A value factory for the session that executes the query.
     */
    private final ValueFactoryQImpl valueFactory;

    /**
     * Creates a new <code>RowIteratorImpl</code> that iterates over the result
     * nodes.
     *
     * @param scoreNodes      a <code>ScoreNodeIterator</code> that contains the
     *                        nodes of the query result.
     * @param columns         the columns to select.
     * @param selectorNames   the selector names.
     * @param itemMgr         the item manager of the session that executes the
     *                        query.
     * @param hmgr            the hierarchy manager of the workspace.
     * @param resolver        <code>NamespaceResolver</code> of the user
     *                        <code>Session</code>.
     * @param valueFactory    the value factory of the current session.
     * @param exProvider      the excerpt provider associated with the query
     *                        result that created this row iterator.
     * @param spellSuggestion the spell suggestion associated with the query
     *                        result or <code>null</code> if none is available.
     * @throws NamespaceException if an error occurs while translating a JCR
     *                            name.
     */
    RowIteratorImpl(ScoreNodeIterator scoreNodes,
                    Map<String, ColumnImpl> columns,
                    Name[] selectorNames,
                    ItemManager itemMgr,
                    HierarchyManager hmgr,
                    NamePathResolver resolver,
                    ValueFactory valueFactory,
                    ExcerptProvider exProvider,
                    SpellSuggestion spellSuggestion)
            throws NamespaceException {
        this.scoreNodes = scoreNodes;
        this.columns = columns;
        this.selectorNames.addAll(Arrays.asList(selectorNames));
        this.itemMgr = itemMgr;
        this.hmgr = hmgr;
        this.resolver = resolver;
        this.excerptProvider = exProvider;
        this.spellSuggestion = spellSuggestion;
        if (valueFactory instanceof ValueFactoryQImpl) {
            this.valueFactory = (ValueFactoryQImpl) valueFactory;
        } else {
            QValueFactory qvf = QValueFactoryImpl.getInstance();
            this.valueFactory = new ValueFactoryQImpl(qvf, resolver);
        }
    }

    /**
     * Returns the next <code>Row</code> in the iteration.
     *
     * @return the next <code>Row</code> in the iteration.
     * @throws NoSuchElementException if iteration has no more
     *                                <code>Row</code>s.
     */
    public Row nextRow() throws NoSuchElementException {
        return new RowImpl(scoreNodes.nextScoreNodes());
    }

    /**
     * Skip a number of <code>Row</code>s in this iterator.
     *
     * @param skipNum the non-negative number of <code>Row</code>s to skip
     * @throws NoSuchElementException if skipped past the last
     *                                <code>Row</code> in this iterator.
     */
    public void skip(long skipNum) throws NoSuchElementException {
        scoreNodes.skip(skipNum);
    }

    /**
     * Returns the number of <code>Row</code>s in this iterator.
     *
     * @return the number of <code>Row</code>s in this iterator.
     */
    public long getSize() {
        return scoreNodes.getSize();
    }

    /**
     * Returns the current position within this iterator. The number
     * returned is the 0-based index of the next <code>Row</code> in the iterator,
     * i.e. the one that will be returned on the subsequent <code>next</code> call.
     * <p>
     * Note that this method does not check if there is a next element,
     * i.e. an empty iterator will always return 0.
     *
     * @return the current position withing this iterator.
     */
    public long getPosition() {
        return scoreNodes.getPosition();
    }

    /**
     * @throws UnsupportedOperationException always.
     */
    public void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * Returns <code>true</code> if the iteration has more <code>Row</code>s.
     * (In other words, returns <code>true</code> if <code>next</code> would
     * return an <code>Row</code> rather than throwing an exception.)
     *
     * @return <code>true</code> if the iterator has more elements.
     */
    public boolean hasNext() {
        return scoreNodes.hasNext();
    }

    /**
     * Returns the next <code>Row</code> in the iteration.
     *
     * @return the next <code>Row</code> in the iteration.
     * @throws NoSuchElementException if iteration has no more <code>Row</code>s.
     */
    public Object next() throws NoSuchElementException {
        return nextRow();
    }

    //---------------------< class RowImpl >------------------------------------

    /**
     * Implements the {@link javax.jcr.query.Row} interface, which represents
     * a row in the query result.
     */
    class RowImpl implements javax.jcr.query.Row {

        /**
         * The score for this result row
         */
        private final float score;

        /**
         * The underlying <code>Node</code> of this result row.
         */
        private NodeImpl node;

        /**
         * The score nodes associated with this row.
         */
        private final ScoreNode[] sn;

        /**
         * Cached value array for returned by {@link #getValues()}.
         */
        private Value[] values;

        /**
         * Creates a new <code>RowImpl</code> instance based on <code>node</code>.
         *
         * @param sn    the score nodes associated with this row.
         */
        RowImpl(ScoreNode[] sn) {
            this.sn = sn;
            this.score = sn[0].getScore();
        }

        /**
         * Returns an array of all the values in the same order as the property
         * names (column names) returned by
         * {@link javax.jcr.query.QueryResult#getColumnNames()}.
         *
         * @return a <code>Value</code> array.
         * @throws RepositoryException if an error occurs while retrieving the
         *                             values from the <code>Node</code>.
         */
        public Value[] getValues() throws RepositoryException {
            if (values == null) {
                Value[] tmp = new Value[columns.size()];
                int i = 0;
                for (String columnName : columns.keySet()) {
                    tmp[i++] = getValue(columnName);
                }
                values = tmp;
            }
            // return a copy of the array
            Value[] ret = new Value[values.length];
            System.arraycopy(values, 0, ret, 0, values.length);
            return ret;
        }

        /**
         * Returns the value of the indicated  column in this <code>Row</code>.
         * <p>
         * If <code>columnbName</code> is not among the column names of the
         * query result table, an <code>ItemNotFoundException</code> is thrown.
         *
         * @return a <code>Value</code>
         * @throws ItemNotFoundException if <code>columnName</code> is not
         *                               among the column names of the query result table.
         * @throws RepositoryException   if another error occurs.
         */
        public Value getValue(String columnName) throws ItemNotFoundException, RepositoryException {
            try {
                ColumnImpl col = columns.get(columnName);
                if (col == null) {
                    if (isExcerptFunction(columnName)) {
                        // excerpt function with parameter
                        return getExcerpt(columnName);
                    } else {
                        throw new ItemNotFoundException(columnName);
                    }
                }
                Node n = getNode(col.getSelectorName());
                if (n == null) {
                    return null;
                }

                if (NameConstants.JCR_PATH.equals(col.getPropertyQName())) {
                    int idx = getSelectorIndex(col.getSelectorName());
                    QValue p = valueFactory.getQValueFactory().create(hmgr.getPath(sn[idx].getNodeId()));
                    return valueFactory.createValue(p);
                } else if (n.hasProperty(col.getPropertyName())) {
                    Property p = n.getProperty(col.getPropertyName());
                    if (p.isMultiple()) {
                        // mvp values cannot be returned
                        return null;
                    } else {
                        if (p.getDefinition().getRequiredType() == PropertyType.UNDEFINED) {
                            return valueFactory.createValue(p.getString());
                        } else {
                            return p.getValue();
                        }
                    }
                } else {
                    Name prop = resolver.getQName(columnName);
                    // either jcr:score, rep:excerpt,
                    // rep:spellcheck or not set
                    if (NameConstants.JCR_SCORE.equals(prop)) {
                        return valueFactory.createValue(Math.round(score * 1000f));
                    } else if (isExcerptFunction(prop)) {
                        return getExcerpt();
                    } else if (isSpellCheckFunction(prop)) {
                        return getSpellCheckedStatement();
                    } else {
                        return null;
                    }
                }
            } catch (NameException e) {
                if (isExcerptFunction(columnName)) {
                    // excerpt function with parameter
                    return getExcerpt(columnName);
                } else {
                    throw new RepositoryException(e.getMessage(), e);
                }
            }
        }

        /**
         * Returns the <code>Node</code> corresponding to this <code>Row</code>.
         * <p>
         * A <code>RepositoryException</code> is thrown if this <code>Row</code>
         * contains values from more than one node. This will be the case when more
         * than one selector is included among the columns specified for the query.
         *
         * @return a <code>Node</code>
         * @throws RepositoryException if this query has more than one selector
         * (and therefore, this <code>Row</code> corresponds to more than one
         * <code>Node</code>) or if another error occurs.
         * @since JCR 2.0
         */
        public Node getNode() throws RepositoryException {
            checkSingleSelector("Use getNode(String) instead.");
            return getNodeImpl();
        }

        /**
         * Returns the <code>Node</code> corresponding to this <code>Row</code> and
         * the specified selector.
         *
         * @param selectorName a <code>String</code>
         * @return a <code>Node</code>
         * @throws RepositoryException if <code>selectorName</code> is not the alias
         * of a selector in this query or if another error occurs.
         * @since JCR 2.0
         */
        public Node getNode(String selectorName) throws RepositoryException {
            ScoreNode s = sn[getSelectorIndex(selectorName)];
            if (s == null) {
                return null;
            }
            return (Node) itemMgr.getItem(s.getNodeId());
        }

        /**
         * Equivalent to <code>Row.getNode().getPath()</code>. However, some
         * implementations may be able gain efficiency by not resolving the actual
         * <code>Node</code>.
         *
         * @return a <code>String</code>
         * @throws RepositoryException if this query has more than one selector
         * (and therefore, this <code>Row</code> corresponds to more than one
         * <code>Node</code>) or if another error occurs.
         * @since JCR 2.0
         */
        public String getPath() throws RepositoryException {
            checkSingleSelector("Use getPath(String) instead.");
            return resolver.getJCRPath(hmgr.getPath(sn[0].getNodeId()));
        }

        /**
         * Equivalent to <code>Row.getNode(selectorName).getPath()</code>. However, some
         * implementations may be able gain efficiency by not resolving the actual
         * <code>Node</code>.
         *
         * @param selectorName a <code>String</code>
         * @return a <code>String</code>
         * @throws RepositoryException if <code>selectorName</code> is not the alias
         * of a selector in this query or if another error occurs.
         * @since JCR 2.0
         */
        public String getPath(String selectorName) throws RepositoryException {
            Node n = getNode(selectorName);
            if (n != null) {
                return n.getPath();
            } else {
                return null;
            }
        }

        /**
         * Returns the full text search score for this row associated with the
         * default selector. This corresponds to the score of a particular node.
         * <p>
         * If no <code>FullTextSearchScore</code> AQM object is associated with the
         * default selector this method will still return a value. However, in that
         * case the returned value may not be meaningful or may simply reflect the
         * minimum possible relevance level (for example, in some systems this might
         * be a score of 0).
         * <p>
         * Note, in JCR-SQL2 a <code>FullTextSearchScore</code> AQM object is represented
         * by a <code>SCORE()</code> function. In JCR-JQOM it is represented by a
         * Java object of type <code>javax.jcr.query.qom.FullTextSearchScore</code>.
         *
         * @return a <code>double</code>
         * @throws RepositoryException if this query has more than one selector
         * (and therefore, this <code>Row</code> corresponds to more than one
         * <code>Node</code>) or if another error occurs.
         * @since JCR 2.0
         */
        public double getScore() throws RepositoryException {
            checkSingleSelector("Use getScore(String) instead.");
            return score;
        }

        /**
         * Returns the full text search score for this row associated with the
         * specified selector. This corresponds to the score of a particular node.
         * <p>
         * If no <code>FullTextSearchScore</code> AQM object is associated with the
         * selector <code>selectorName</code> this method will still return a value.
         * However, in that case the returned value may not be meaningful or may
         * simply reflect the minimum possible relevance level (for example, in some
         * systems this might be a score of 0).
         * <p>
         * Note, in JCR-SQL2 a <code>FullTextSearchScore</code> AQM object is represented
         * by a <code>SCORE()</code> function. In JCR-JQOM it is represented by a
         * Java object of type <code>javax.jcr.query.qom.FullTextSearchScore</code>.
         *
         * @param selectorName a <code>String</code>
         * @return a <code>String</code>
         * @throws RepositoryException if <code>selectorName</code> is not the alias
         * of a selector in this query or if another error occurs.
         * @since JCR 2.0
         */
        public double getScore(String selectorName) throws RepositoryException {
            ScoreNode s = sn[getSelectorIndex(selectorName)];
            if (s == null) {
                return 0;
            }
            return s.getScore();
        }

        //-----------------------------< internal >-----------------------------

        /**
         * Returns the node corresponding to this row.
         *
         * @return the node.
         * @throws RepositoryException if an error occurs while retrieving the
         *                             node. e.g. node does not exist anymore.
         */
        private NodeImpl getNodeImpl() throws RepositoryException {
            if (node == null) {
                node = (NodeImpl) itemMgr.getItem(sn[0].getNodeId());
            }
            return node;
        }

        /**
         * Checks if there is a single selector and otherwise throws a
         * RepositoryException.
         *
         * @param useInstead message telling, which method to use instead.
         * @throws RepositoryException if there is more than one selector.
         */
        private void checkSingleSelector(String useInstead) throws RepositoryException {
            if (sn.length > 1) {
                String msg = "More than one selector. " + useInstead;
                throw new RepositoryException(msg);
            }
        }

        /**
         * Gets the selector index for the given <code>selectorName</code>.
         *
         * @param selectorName the selector name.
         * @return the selector index.
         * @throws RepositoryException if the selector name is not a valid JCR
         *                             name or the selector name is not the
         *                             alias of a selector in this query.
         */
        private int getSelectorIndex(String selectorName)
                throws RepositoryException {
            int idx = selectorNames.indexOf(resolver.getQName(selectorName));
            if (idx == -1) {
                throw new RepositoryException("Unknown selector name: " + selectorName);
            }
            return idx;
        }

        /**
         * @param name a Name.
         * @return <code>true</code> if <code>name</code> is the rep:excerpt
         *         function, <code>false</code> otherwise.
         */
        private boolean isExcerptFunction(Name name) {
            return name.getNamespaceURI().equals(Name.NS_REP_URI)
                && name.getLocalName().startsWith(EXCERPT_FUNC_LPAR);
        }

        /**
         * @param name a String.
         * @return <code>true</code> if <code>name</code> is the rep:excerpt
         *         function, <code>false</code> otherwise.
         */
        private boolean isExcerptFunction(String name) {
            try {
                return name.startsWith(
                        resolver.getJCRName(REP_EXCERPT_LPAR));
            } catch (NamespaceException e) {
                // will never happen
                return false;
            }
        }

        /**
         * Returns an excerpt for the node associated with this row.
         *
         * @return a StringValue or <code>null</code> if the excerpt cannot be
         *         created or an error occurs.
         */
        private Value getExcerpt() {
            return createExcerpt(sn[0].getNodeId());
        }

        /**
         * Returns an excerpt for the node indicated by the relative path
         * parameter of the rep:excerpt function. The relative path is resolved
         * against the node associated with this row.
         *
         * @param excerptCall the rep:excerpt function with the parameter as
         *                    string.
         * @return a StringValue or <code>null</code> if the excerpt cannot be
         *         created or an error occurs.
         * @throws RepositoryException if the function call is not well-formed.
         */
        private Value getExcerpt(String excerptCall) throws RepositoryException {
            int idx = excerptCall.indexOf(EXCERPT_FUNC_LPAR);
            int end = excerptCall.lastIndexOf(')');
            if (end == -1) {
                throw new RepositoryException("Missing right parenthesis");
            }
            String pathStr = excerptCall.substring(
                    idx + EXCERPT_FUNC_LPAR.length(), end).trim();
            String decodedPath = ISO9075.decode(pathStr);
            try {
                NodeImpl n = (NodeImpl) getNodeImpl().getNode(decodedPath);
                return createExcerpt(n.getNodeId());
            } catch (PathNotFoundException e) {
                // does not exist or references a property
                try {
                    Property p = getNode().getProperty(decodedPath);
                    return highlight(p.getValue().getString());
                } catch (PathNotFoundException e1) {
                    // does not exist
                    return null;
                }
            }
        }

        /**
         * Creates an excerpt for node with the given <code>id</code>.
         *
         * @param id a node id.
         * @return a StringValue or <code>null</code> if the excerpt cannot be
         *         created or an error occurs.
         */
        private Value createExcerpt(NodeId id) {
            if (excerptProvider == null) {
                return null;
            }
            try {
                long time = System.currentTimeMillis();
                String excerpt = excerptProvider.getExcerpt(id, 3, 150);
                time = System.currentTimeMillis() - time;
                log.debug("Created excerpt in {} ms.", time);
                if (excerpt != null) {
                    return valueFactory.createValue(excerpt);
                } else {
                    return null;
                }
            } catch (IOException e) {
                return null;
            }
        }

        /**
         * Highlights the matching terms in the passed <code>text</code>.
         *
         * @param text the text where to apply highlighting.
         * @return a StringValue or <code>null</code> if highlighting fails.
         */
        private Value highlight(String text) {
            if (!(excerptProvider instanceof HighlightingExcerptProvider)) {
                return null;
            }
            HighlightingExcerptProvider hep =
                    (HighlightingExcerptProvider) excerptProvider;
            try {
                long time = System.currentTimeMillis();
                text = hep.highlight(text);
                time = System.currentTimeMillis() - time;
                log.debug("Highlighted text in {} ms.", time);
                return valueFactory.createValue(text);
            } catch (IOException e) {
                return null;
            }
        }

        /**
         * @param name a Name.
         * @return <code>true</code> if <code>name</code> is the rep:spellcheck
         *         function, <code>false</code> otherwise.
         */
        private boolean isSpellCheckFunction(Name name) {
            return name.getNamespaceURI().equals(Name.NS_REP_URI)
                && name.getLocalName().startsWith(SPELLCHECK_FUNC_LPAR);
        }

        /**
         * Returns the spell checked string of the first relation query node
         * with a spellcheck operation.
         *
         * @return a StringValue or <code>null</code> if the spell checker
         *         thinks the words are spelled correctly. This method also
         *         returns <code>null</code> if no spell checker is configured.
         */
        private Value getSpellCheckedStatement() {
            String v = null;
            if (spellSuggestion != null) {
                try {
                    v = spellSuggestion.getSuggestion();
                } catch (IOException e) {
                    log.warn("Spell checking failed", e);
                }
            }
            if (v != null) {
                return valueFactory.createValue(v);
            } else {
                return null;
            }
        }
    }
}
