/*
 * 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.commons.jxpath.ri;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

import org.apache.commons.jxpath.BasicNodeSet;
import org.apache.commons.jxpath.ExpressionContext;
import org.apache.commons.jxpath.JXPathContext;
import org.apache.commons.jxpath.JXPathException;
import org.apache.commons.jxpath.NodeSet;
import org.apache.commons.jxpath.Pointer;
import org.apache.commons.jxpath.ri.axes.RootContext;
import org.apache.commons.jxpath.ri.model.NodePointer;
import org.apache.commons.jxpath.util.ReverseComparator;

/**
 * An XPath evaluation context.
 *
 * When evaluating a path, a chain of EvalContexts is created, each context in the chain representing a step of the path. Subclasses of EvalContext implement
 * behavior of various XPath axes: "child::", "parent::" etc.
 */
public abstract class EvalContext implements ExpressionContext, Iterator {

    /** Parent context */
    protected EvalContext parentContext;
    /** Root context */
    protected RootContext rootContext;
    /** Position */
    protected int position;
    private boolean startedSetIteration;
    private boolean done;
    private boolean hasPerformedIteratorStep;
    private Iterator<Pointer> pointerIterator;

    /**
     * Constructs a new EvalContext.
     *
     * @param parentContext parent context
     */
    public EvalContext(final EvalContext parentContext) {
        this.parentContext = parentContext;
    }

    /**
     * Constructs an iterator.
     *
     * @return whether the Iterator was constructed
     */
    private boolean constructIterator() {
        final HashSet<Pointer> set = new HashSet<>();
        final ArrayList<Pointer> list = new ArrayList<>();
        while (nextSet()) {
            while (nextNode()) {
                final NodePointer pointer = getCurrentNodePointer();
                if (!set.contains(pointer)) {
                    set.add(pointer);
                    list.add(pointer);
                }
            }
        }
        if (list.isEmpty()) {
            return false;
        }
        sortPointers(list);
        pointerIterator = list.iterator();
        return true;
    }

    /**
     * Returns the list of all Pointers in this context for the current position of the parent context.
     *
     * @return List
     */
    @Override
    public List<Pointer> getContextNodeList() {
        final int pos = position;
        if (pos != 0) {
            reset();
        }
        final List<Pointer> list = new ArrayList<>();
        while (nextNode()) {
            list.add(getCurrentNodePointer());
        }
        if (pos != 0) {
            setPosition(pos);
        } else {
            reset();
        }
        return list;
    }

    @Override
    public Pointer getContextNodePointer() {
        return getCurrentNodePointer();
    }

    /**
     * Returns the current context node. Undefined before the beginning of the iteration.
     *
     * @return NodePoiner
     */
    public abstract NodePointer getCurrentNodePointer();

    /**
     * Gets the current position.
     *
     * @return int position.
     */
    public int getCurrentPosition() {
        return position;
    }

    /**
     * Determines the document order for this context.
     *
     * @return 1 ascending order, -1 descending order, 0 - does not require ordering
     */
    public int getDocumentOrder() {
        return parentContext != null && parentContext.isChildOrderingRequired() ? 1 : 0;
    }

    @Override
    public JXPathContext getJXPathContext() {
        return getRootContext().getJXPathContext();
    }

    /**
     * Returns the list of all Pointers in this context for all positions of the parent contexts. If there was an ongoing iteration over this context, the
     * method should not be called.
     *
     * @return NodeSet
     */
    public NodeSet getNodeSet() {
        if (position != 0) {
            throw new JXPathException("Simultaneous operations: " + "should not request pointer list while " + "iterating over an EvalContext");
        }
        final BasicNodeSet set = new BasicNodeSet();
        while (nextSet()) {
            while (nextNode()) {
                set.add((Pointer) getCurrentNodePointer().clone());
            }
        }
        return set;
    }

    @Override
    public int getPosition() {
        return position;
    }

    /**
     * Returns the root context of the path, which provides easy access to variables and functions.
     *
     * @return RootContext
     */
    public RootContext getRootContext() {
        if (rootContext == null) {
            rootContext = parentContext.getRootContext();
        }
        return rootContext;
    }

    /**
     * Returns the first encountered Pointer that matches the current context's criteria.
     *
     * @return Pointer
     */
    public Pointer getSingleNodePointer() {
        reset();
        while (nextSet()) {
            if (nextNode()) {
                return getCurrentNodePointer();
            }
        }
        return null;
    }

    /**
     * Typically returns the NodeSet by calling getNodeSet(), but will be overridden for contexts that more naturally produce individual values, e.g.
     * VariableContext
     *
     * @return Object
     */
    public Object getValue() {
        return getNodeSet();
    }

    /**
     * Returns true if there are mode nodes matching the context's constraints.
     *
     * @return boolean
     */
    @Override
    public boolean hasNext() {
        if (pointerIterator != null) {
            return pointerIterator.hasNext();
        }
        if (getDocumentOrder() != 0) {
            return constructIterator();
        }
        if (!done && !hasPerformedIteratorStep) {
            performIteratorStep();
        }
        return !done;
    }

    /**
     * Even if this context has the natural ordering and therefore does not require collecting and sorting all nodes prior to returning them, such operation may
     * be required for any child context.
     *
     * @return boolean
     */
    public boolean isChildOrderingRequired() {
        // Default behavior: if this context needs to be ordered,
        // the children need to be ordered too
        return getDocumentOrder() != 0;
    }

    /**
     * Returns the next node pointer in the context
     *
     * @return Object
     */
    @Override
    public Object next() {
        if (pointerIterator != null) {
            return pointerIterator.next();
        }
        if (getDocumentOrder() != 0) {
            if (!constructIterator()) {
                throw new NoSuchElementException();
            }
            return pointerIterator.next();
        }
        if (!done && !hasPerformedIteratorStep) {
            performIteratorStep();
        }
        if (done) {
            throw new NoSuchElementException();
        }
        hasPerformedIteratorStep = false;
        return getCurrentNodePointer();
    }

    /**
     * Returns true if there is another object in the current set. Switches the current position and node to the next object.
     *
     * @return boolean
     */
    public abstract boolean nextNode();

    /**
     * Returns true if there is another sets of objects to interate over. Resets the current position and node.
     *
     * @return boolean
     */
    public boolean nextSet() {
        reset(); // Restart iteration within the set
        // Most of the time you have one set per parent node
        // First time this method is called, we should look for
        // the first parent set that contains at least one node.
        if (!startedSetIteration) {
            startedSetIteration = true;
            while (parentContext.nextSet()) {
                if (parentContext.nextNode()) {
                    return true;
                }
            }
            return false;
        }
        // In subsequent calls, we see if the parent context
        // has any nodes left in the current set
        if (parentContext.nextNode()) {
            return true;
        }
        // If not, we look for the next set that contains
        // at least one node
        while (parentContext.nextSet()) {
            if (parentContext.nextNode()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Moves the iterator forward by one position
     */
    private void performIteratorStep() {
        done = true;
        if (position != 0 && nextNode()) {
            done = false;
        } else {
            while (nextSet()) {
                if (nextNode()) {
                    done = false;
                    break;
                }
            }
        }
        hasPerformedIteratorStep = true;
    }

    /**
     * Operation is not supported
     *
     * @throws UnsupportedOperationException Always thrown.
     */
    @Override
    public void remove() {
        throw new UnsupportedOperationException("JXPath iterators cannot remove nodes");
    }

    /**
     * Sets current position = 0, which is the pre-iteration state.
     */
    public void reset() {
        position = 0;
    }

    /**
     * Moves the current position to the specified index. Used with integer predicates to quickly get to the n'th element of the node set. Returns false if the
     * position is out of the node set range. You can call it with 0 as the position argument to restart the iteration.
     *
     * @param position to set
     * @return boolean
     */
    public boolean setPosition(final int position) {
        this.position = position;
        return true;
    }

    /**
     * Sort a list of pointers based on document order.
     *
     * @param l the list to sort.
     */
    protected void sortPointers(final List l) {
        switch (getDocumentOrder()) {
        case 1:
            Collections.sort(l);
            break;
        case -1:
            Collections.sort(l, ReverseComparator.INSTANCE);
            break;
        default:
            break;
        }
    }

    @Override
    public String toString() {
        final Pointer ptr = getContextNodePointer();
        return ptr == null ? "Empty expression context" : "Expression context [" + getPosition() + "] " + ptr.asPath();
    }
}